git.maemo.org Git - qemu/blob - exec.c

   1 /*
   2  *  virtual page mapping and translated block handling
   3  *
   4  *  Copyright (c) 2003 Fabrice Bellard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20 #include "config.h"
  21 #ifdef _WIN32
  22 #include <windows.h>
  23 #else
  24 #include <sys/types.h>
  25 #include <sys/mman.h>
  26 #endif
  27 #include <stdlib.h>
  28 #include <stdio.h>
  29 #include <stdarg.h>
  30 #include <string.h>
  31 #include <errno.h>
  32 #include <unistd.h>
  33 #include <inttypes.h>
  34
  35 #include "cpu.h"
  36 #include "exec-all.h"
  37 #if defined(CONFIG_USER_ONLY)
  38 #include <qemu.h>
  39 #endif
  40
  41 //#define DEBUG_TB_INVALIDATE
  42 //#define DEBUG_FLUSH
  43 //#define DEBUG_TLB
  44 //#define DEBUG_UNASSIGNED
  45
  46 /* make various TB consistency checks */
  47 //#define DEBUG_TB_CHECK
  48 //#define DEBUG_TLB_CHECK
  49
  50 //#define DEBUG_IOPORT
  51 //#define DEBUG_SUBPAGE
  52
  53 #if !defined(CONFIG_USER_ONLY)
  54 /* TB consistency checks only implemented for usermode emulation.  */
  55 #undef DEBUG_TB_CHECK
  56 #endif
  57
  58 /* threshold to flush the translated code buffer */
  59 #define CODE_GEN_BUFFER_MAX_SIZE (CODE_GEN_BUFFER_SIZE - CODE_GEN_MAX_SIZE)
  60
  61 #define SMC_BITMAP_USE_THRESHOLD 10
  62
  63 #define MMAP_AREA_START        0x00000000
  64 #define MMAP_AREA_END          0xa8000000
  65
  66 #if defined(TARGET_SPARC64)
  67 #define TARGET_PHYS_ADDR_SPACE_BITS 41
  68 #elif defined(TARGET_SPARC)
  69 #define TARGET_PHYS_ADDR_SPACE_BITS 36
  70 #elif defined(TARGET_ALPHA)
  71 #define TARGET_PHYS_ADDR_SPACE_BITS 42
  72 #define TARGET_VIRT_ADDR_SPACE_BITS 42
  73 #elif defined(TARGET_PPC64)
  74 #define TARGET_PHYS_ADDR_SPACE_BITS 42
  75 #else
  76 /* Note: for compatibility with kqemu, we use 32 bits for x86_64 */
  77 #define TARGET_PHYS_ADDR_SPACE_BITS 32
  78 #endif
  79
  80 TranslationBlock tbs[CODE_GEN_MAX_BLOCKS];
  81 TranslationBlock *tb_phys_hash[CODE_GEN_PHYS_HASH_SIZE];
  82 int nb_tbs;
  83 /* any access to the tbs or the page table must use this lock */
  84 spinlock_t tb_lock = SPIN_LOCK_UNLOCKED;
  85
  86 uint8_t code_gen_buffer[CODE_GEN_BUFFER_SIZE] __attribute__((aligned (32)));
  87 uint8_t *code_gen_ptr;
  88
  89 int phys_ram_size;
  90 int phys_ram_fd;
  91 uint8_t *phys_ram_base;
  92 uint8_t *phys_ram_dirty;
  93 static ram_addr_t phys_ram_alloc_offset = 0;
  94
  95 CPUState *first_cpu;
  96 /* current CPU in the current thread. It is only valid inside
  97    cpu_exec() */
  98 CPUState *cpu_single_env;
  99
 100 typedef struct PageDesc {
 101     /* list of TBs intersecting this ram page */
 102     TranslationBlock *first_tb;
 103     /* in order to optimize self modifying code, we count the number
 104        of lookups we do to a given page to use a bitmap */
 105     unsigned int code_write_count;
 106     uint8_t *code_bitmap;
 107 #if defined(CONFIG_USER_ONLY)
 108     unsigned long flags;
 109 #endif
 110 } PageDesc;
 111
 112 typedef struct PhysPageDesc {
 113     /* offset in host memory of the page + io_index in the low 12 bits */
 114     uint32_t phys_offset;
 115 } PhysPageDesc;
 116
 117 #define L2_BITS 10
 118 #if defined(CONFIG_USER_ONLY) && defined(TARGET_VIRT_ADDR_SPACE_BITS)
 119 /* XXX: this is a temporary hack for alpha target.
 120  *      In the future, this is to be replaced by a multi-level table
 121  *      to actually be able to handle the complete 64 bits address space.
 122  */
 123 #define L1_BITS (TARGET_VIRT_ADDR_SPACE_BITS - L2_BITS - TARGET_PAGE_BITS)
 124 #else
 125 #define L1_BITS (32 - L2_BITS - TARGET_PAGE_BITS)
 126 #endif
 127
 128 #define L1_SIZE (1 << L1_BITS)
 129 #define L2_SIZE (1 << L2_BITS)
 130
 131 static void io_mem_init(void);
 132
 133 unsigned long qemu_real_host_page_size;
 134 unsigned long qemu_host_page_bits;
 135 unsigned long qemu_host_page_size;
 136 unsigned long qemu_host_page_mask;
 137
 138 /* XXX: for system emulation, it could just be an array */
 139 static PageDesc *l1_map[L1_SIZE];
 140 PhysPageDesc **l1_phys_map;
 141
 142 /* io memory support */
 143 CPUWriteMemoryFunc *io_mem_write[IO_MEM_NB_ENTRIES][4];
 144 CPUReadMemoryFunc *io_mem_read[IO_MEM_NB_ENTRIES][4];
 145 void *io_mem_opaque[IO_MEM_NB_ENTRIES];
 146 static int io_mem_nb;
 147 #if defined(CONFIG_SOFTMMU)
 148 static int io_mem_watch;
 149 #endif
 150
 151 /* log support */
 152 char *logfilename = "/tmp/qemu.log";
 153 FILE *logfile;
 154 int loglevel;
 155 static int log_append = 0;
 156
 157 /* statistics */
 158 static int tlb_flush_count;
 159 static int tb_flush_count;
 160 static int tb_phys_invalidate_count;
 161
 162 #define SUBPAGE_IDX(addr) ((addr) & ~TARGET_PAGE_MASK)
 163 typedef struct subpage_t {
 164     target_phys_addr_t base;
 165     CPUReadMemoryFunc **mem_read[TARGET_PAGE_SIZE];
 166     CPUWriteMemoryFunc **mem_write[TARGET_PAGE_SIZE];
 167     void *opaque[TARGET_PAGE_SIZE];
 168 } subpage_t;
 169
 170 static void page_init(void)
 171 {
 172     /* NOTE: we can always suppose that qemu_host_page_size >=
 173        TARGET_PAGE_SIZE */
 174 #ifdef _WIN32
 175     {
 176         SYSTEM_INFO system_info;
 177         DWORD old_protect;
 178
 179         GetSystemInfo(&system_info);
 180         qemu_real_host_page_size = system_info.dwPageSize;
 181
 182         VirtualProtect(code_gen_buffer, sizeof(code_gen_buffer),
 183                        PAGE_EXECUTE_READWRITE, &old_protect);
 184     }
 185 #else
 186     qemu_real_host_page_size = getpagesize();
 187     {
 188         unsigned long start, end;
 189
 190         start = (unsigned long)code_gen_buffer;
 191         start &= ~(qemu_real_host_page_size - 1);
 192
 193         end = (unsigned long)code_gen_buffer + sizeof(code_gen_buffer);
 194         end += qemu_real_host_page_size - 1;
 195         end &= ~(qemu_real_host_page_size - 1);
 196
 197         mprotect((void *)start, end - start,
 198                  PROT_READ | PROT_WRITE | PROT_EXEC);
 199     }
 200 #endif
 201
 202     if (qemu_host_page_size == 0)
 203         qemu_host_page_size = qemu_real_host_page_size;
 204     if (qemu_host_page_size < TARGET_PAGE_SIZE)
 205         qemu_host_page_size = TARGET_PAGE_SIZE;
 206     qemu_host_page_bits = 0;
 207     while ((1 << qemu_host_page_bits) < qemu_host_page_size)
 208         qemu_host_page_bits++;
 209     qemu_host_page_mask = ~(qemu_host_page_size - 1);
 210     l1_phys_map = qemu_vmalloc(L1_SIZE * sizeof(void *));
 211     memset(l1_phys_map, 0, L1_SIZE * sizeof(void *));
 212 }
 213
 214 static inline PageDesc *page_find_alloc(unsigned int index)
 215 {
 216     PageDesc **lp, *p;
 217
 218     lp = &l1_map[index >> L2_BITS];
 219     p = *lp;
 220     if (!p) {
 221         /* allocate if not found */
 222         p = qemu_malloc(sizeof(PageDesc) * L2_SIZE);
 223         memset(p, 0, sizeof(PageDesc) * L2_SIZE);
 224         *lp = p;
 225     }
 226     return p + (index & (L2_SIZE - 1));
 227 }
 228
 229 static inline PageDesc *page_find(unsigned int index)
 230 {
 231     PageDesc *p;
 232
 233     p = l1_map[index >> L2_BITS];
 234     if (!p)
 235         return 0;
 236     return p + (index & (L2_SIZE - 1));
 237 }
 238
 239 static PhysPageDesc *phys_page_find_alloc(target_phys_addr_t index, int alloc)
 240 {
 241     void **lp, **p;
 242     PhysPageDesc *pd;
 243
 244     p = (void **)l1_phys_map;
 245 #if TARGET_PHYS_ADDR_SPACE_BITS > 32
 246
 247 #if TARGET_PHYS_ADDR_SPACE_BITS > (32 + L1_BITS)
 248 #error unsupported TARGET_PHYS_ADDR_SPACE_BITS
 249 #endif
 250     lp = p + ((index >> (L1_BITS + L2_BITS)) & (L1_SIZE - 1));
 251     p = *lp;
 252     if (!p) {
 253         /* allocate if not found */
 254         if (!alloc)
 255             return NULL;
 256         p = qemu_vmalloc(sizeof(void *) * L1_SIZE);
 257         memset(p, 0, sizeof(void *) * L1_SIZE);
 258         *lp = p;
 259     }
 260 #endif
 261     lp = p + ((index >> L2_BITS) & (L1_SIZE - 1));
 262     pd = *lp;
 263     if (!pd) {
 264         int i;
 265         /* allocate if not found */
 266         if (!alloc)
 267             return NULL;
 268         pd = qemu_vmalloc(sizeof(PhysPageDesc) * L2_SIZE);
 269         *lp = pd;
 270         for (i = 0; i < L2_SIZE; i++)
 271           pd[i].phys_offset = IO_MEM_UNASSIGNED;
 272     }
 273     return ((PhysPageDesc *)pd) + (index & (L2_SIZE - 1));
 274 }
 275
 276 static inline PhysPageDesc *phys_page_find(target_phys_addr_t index)
 277 {
 278     return phys_page_find_alloc(index, 0);
 279 }
 280
 281 #if !defined(CONFIG_USER_ONLY)
 282 static void tlb_protect_code(ram_addr_t ram_addr);
 283 static void tlb_unprotect_code_phys(CPUState *env, ram_addr_t ram_addr,
 284                                     target_ulong vaddr);
 285 #endif
 286
 287 void cpu_exec_init(CPUState *env)
 288 {
 289     CPUState **penv;
 290     int cpu_index;
 291
 292     if (!code_gen_ptr) {
 293         code_gen_ptr = code_gen_buffer;
 294         page_init();
 295         io_mem_init();
 296     }
 297     env->next_cpu = NULL;
 298     penv = &first_cpu;
 299     cpu_index = 0;
 300     while (*penv != NULL) {
 301         penv = (CPUState **)&(*penv)->next_cpu;
 302         cpu_index++;
 303     }
 304     env->cpu_index = cpu_index;
 305     env->nb_watchpoints = 0;
 306     *penv = env;
 307 }
 308
 309 static inline void invalidate_page_bitmap(PageDesc *p)
 310 {
 311     if (p->code_bitmap) {
 312         qemu_free(p->code_bitmap);
 313         p->code_bitmap = NULL;
 314     }
 315     p->code_write_count = 0;
 316 }
 317
 318 /* set to NULL all the 'first_tb' fields in all PageDescs */
 319 static void page_flush_tb(void)
 320 {
 321     int i, j;
 322     PageDesc *p;
 323
 324     for(i = 0; i < L1_SIZE; i++) {
 325         p = l1_map[i];
 326         if (p) {
 327             for(j = 0; j < L2_SIZE; j++) {
 328                 p->first_tb = NULL;
 329                 invalidate_page_bitmap(p);
 330                 p++;
 331             }
 332         }
 333     }
 334 }
 335
 336 /* flush all the translation blocks */
 337 /* XXX: tb_flush is currently not thread safe */
 338 void tb_flush(CPUState *env1)
 339 {
 340     CPUState *env;
 341 #if defined(DEBUG_FLUSH)
 342     printf("qemu: flush code_size=%d nb_tbs=%d avg_tb_size=%d\n",
 343            code_gen_ptr - code_gen_buffer,
 344            nb_tbs,
 345            nb_tbs > 0 ? (code_gen_ptr - code_gen_buffer) / nb_tbs : 0);
 346 #endif
 347     nb_tbs = 0;
 348
 349     for(env = first_cpu; env != NULL; env = env->next_cpu) {
 350         memset (env->tb_jmp_cache, 0, TB_JMP_CACHE_SIZE * sizeof (void *));
 351     }
 352
 353     memset (tb_phys_hash, 0, CODE_GEN_PHYS_HASH_SIZE * sizeof (void *));
 354     page_flush_tb();
 355
 356     code_gen_ptr = code_gen_buffer;
 357     /* XXX: flush processor icache at this point if cache flush is
 358        expensive */
 359     tb_flush_count++;
 360 }
 361
 362 #ifdef DEBUG_TB_CHECK
 363
 364 static void tb_invalidate_check(target_ulong address)
 365 {
 366     TranslationBlock *tb;
 367     int i;
 368     address &= TARGET_PAGE_MASK;
 369     for(i = 0;i < CODE_GEN_PHYS_HASH_SIZE; i++) {
 370         for(tb = tb_phys_hash[i]; tb != NULL; tb = tb->phys_hash_next) {
 371             if (!(address + TARGET_PAGE_SIZE <= tb->pc ||
 372                   address >= tb->pc + tb->size)) {
 373                 printf("ERROR invalidate: address=%08lx PC=%08lx size=%04x\n",
 374                        address, (long)tb->pc, tb->size);
 375             }
 376         }
 377     }
 378 }
 379
 380 /* verify that all the pages have correct rights for code */
 381 static void tb_page_check(void)
 382 {
 383     TranslationBlock *tb;
 384     int i, flags1, flags2;
 385
 386     for(i = 0;i < CODE_GEN_PHYS_HASH_SIZE; i++) {
 387         for(tb = tb_phys_hash[i]; tb != NULL; tb = tb->phys_hash_next) {
 388             flags1 = page_get_flags(tb->pc);
 389             flags2 = page_get_flags(tb->pc + tb->size - 1);
 390             if ((flags1 & PAGE_WRITE) || (flags2 & PAGE_WRITE)) {
 391                 printf("ERROR page flags: PC=%08lx size=%04x f1=%x f2=%x\n",
 392                        (long)tb->pc, tb->size, flags1, flags2);
 393             }
 394         }
 395     }
 396 }
 397
 398 void tb_jmp_check(TranslationBlock *tb)
 399 {
 400     TranslationBlock *tb1;
 401     unsigned int n1;
 402
 403     /* suppress any remaining jumps to this TB */
 404     tb1 = tb->jmp_first;
 405     for(;;) {
 406         n1 = (long)tb1 & 3;
 407         tb1 = (TranslationBlock *)((long)tb1 & ~3);
 408         if (n1 == 2)
 409             break;
 410         tb1 = tb1->jmp_next[n1];
 411     }
 412     /* check end of list */
 413     if (tb1 != tb) {
 414         printf("ERROR: jmp_list from 0x%08lx\n", (long)tb);
 415     }
 416 }
 417
 418 #endif
 419
 420 /* invalidate one TB */
 421 static inline void tb_remove(TranslationBlock **ptb, TranslationBlock *tb,
 422                              int next_offset)
 423 {
 424     TranslationBlock *tb1;
 425     for(;;) {
 426         tb1 = *ptb;
 427         if (tb1 == tb) {
 428             *ptb = *(TranslationBlock **)((char *)tb1 + next_offset);
 429             break;
 430         }
 431         ptb = (TranslationBlock **)((char *)tb1 + next_offset);
 432     }
 433 }
 434
 435 static inline void tb_page_remove(TranslationBlock **ptb, TranslationBlock *tb)
 436 {
 437     TranslationBlock *tb1;
 438     unsigned int n1;
 439
 440     for(;;) {
 441         tb1 = *ptb;
 442         n1 = (long)tb1 & 3;
 443         tb1 = (TranslationBlock *)((long)tb1 & ~3);
 444         if (tb1 == tb) {
 445             *ptb = tb1->page_next[n1];
 446             break;
 447         }
 448         ptb = &tb1->page_next[n1];
 449     }
 450 }
 451
 452 static inline void tb_jmp_remove(TranslationBlock *tb, int n)
 453 {
 454     TranslationBlock *tb1, **ptb;
 455     unsigned int n1;
 456
 457     ptb = &tb->jmp_next[n];
 458     tb1 = *ptb;
 459     if (tb1) {
 460         /* find tb(n) in circular list */
 461         for(;;) {
 462             tb1 = *ptb;
 463             n1 = (long)tb1 & 3;
 464             tb1 = (TranslationBlock *)((long)tb1 & ~3);
 465             if (n1 == n && tb1 == tb)
 466                 break;
 467             if (n1 == 2) {
 468                 ptb = &tb1->jmp_first;
 469             } else {
 470                 ptb = &tb1->jmp_next[n1];
 471             }
 472         }
 473         /* now we can suppress tb(n) from the list */
 474         *ptb = tb->jmp_next[n];
 475
 476         tb->jmp_next[n] = NULL;
 477     }
 478 }
 479
 480 /* reset the jump entry 'n' of a TB so that it is not chained to
 481    another TB */
 482 static inline void tb_reset_jump(TranslationBlock *tb, int n)
 483 {
 484     tb_set_jmp_target(tb, n, (unsigned long)(tb->tc_ptr + tb->tb_next_offset[n]));
 485 }
 486
 487 static inline void tb_phys_invalidate(TranslationBlock *tb, unsigned int page_addr)
 488 {
 489     CPUState *env;
 490     PageDesc *p;
 491     unsigned int h, n1;
 492     target_ulong phys_pc;
 493     TranslationBlock *tb1, *tb2;
 494
 495     /* remove the TB from the hash list */
 496     phys_pc = tb->page_addr[0] + (tb->pc & ~TARGET_PAGE_MASK);
 497     h = tb_phys_hash_func(phys_pc);
 498     tb_remove(&tb_phys_hash[h], tb,
 499               offsetof(TranslationBlock, phys_hash_next));
 500
 501     /* remove the TB from the page list */
 502     if (tb->page_addr[0] != page_addr) {
 503         p = page_find(tb->page_addr[0] >> TARGET_PAGE_BITS);
 504         tb_page_remove(&p->first_tb, tb);
 505         invalidate_page_bitmap(p);
 506     }
 507     if (tb->page_addr[1] != -1 && tb->page_addr[1] != page_addr) {
 508         p = page_find(tb->page_addr[1] >> TARGET_PAGE_BITS);
 509         tb_page_remove(&p->first_tb, tb);
 510         invalidate_page_bitmap(p);
 511     }
 512
 513     tb_invalidated_flag = 1;
 514
 515     /* remove the TB from the hash list */
 516     h = tb_jmp_cache_hash_func(tb->pc);
 517     for(env = first_cpu; env != NULL; env = env->next_cpu) {
 518         if (env->tb_jmp_cache[h] == tb)
 519             env->tb_jmp_cache[h] = NULL;
 520     }
 521
 522     /* suppress this TB from the two jump lists */
 523     tb_jmp_remove(tb, 0);
 524     tb_jmp_remove(tb, 1);
 525
 526     /* suppress any remaining jumps to this TB */
 527     tb1 = tb->jmp_first;
 528     for(;;) {
 529         n1 = (long)tb1 & 3;
 530         if (n1 == 2)
 531             break;
 532         tb1 = (TranslationBlock *)((long)tb1 & ~3);
 533         tb2 = tb1->jmp_next[n1];
 534         tb_reset_jump(tb1, n1);
 535         tb1->jmp_next[n1] = NULL;
 536         tb1 = tb2;
 537     }
 538     tb->jmp_first = (TranslationBlock *)((long)tb | 2); /* fail safe */
 539
 540     tb_phys_invalidate_count++;
 541 }
 542
 543 static inline void set_bits(uint8_t *tab, int start, int len)
 544 {
 545     int end, mask, end1;
 546
 547     end = start + len;
 548     tab += start >> 3;
 549     mask = 0xff << (start & 7);
 550     if ((start & ~7) == (end & ~7)) {
 551         if (start < end) {
 552             mask &= ~(0xff << (end & 7));
 553             *tab |= mask;
 554         }
 555     } else {
 556         *tab++ |= mask;
 557         start = (start + 8) & ~7;
 558         end1 = end & ~7;
 559         while (start < end1) {
 560             *tab++ = 0xff;
 561             start += 8;
 562         }
 563         if (start < end) {
 564             mask = ~(0xff << (end & 7));
 565             *tab |= mask;
 566         }
 567     }
 568 }
 569
 570 static void build_page_bitmap(PageDesc *p)
 571 {
 572     int n, tb_start, tb_end;
 573     TranslationBlock *tb;
 574
 575     p->code_bitmap = qemu_malloc(TARGET_PAGE_SIZE / 8);
 576     if (!p->code_bitmap)
 577         return;
 578     memset(p->code_bitmap, 0, TARGET_PAGE_SIZE / 8);
 579
 580     tb = p->first_tb;
 581     while (tb != NULL) {
 582         n = (long)tb & 3;
 583         tb = (TranslationBlock *)((long)tb & ~3);
 584         /* NOTE: this is subtle as a TB may span two physical pages */
 585         if (n == 0) {
 586             /* NOTE: tb_end may be after the end of the page, but
 587                it is not a problem */
 588             tb_start = tb->pc & ~TARGET_PAGE_MASK;
 589             tb_end = tb_start + tb->size;
 590             if (tb_end > TARGET_PAGE_SIZE)
 591                 tb_end = TARGET_PAGE_SIZE;
 592         } else {
 593             tb_start = 0;
 594             tb_end = ((tb->pc + tb->size) & ~TARGET_PAGE_MASK);
 595         }
 596         set_bits(p->code_bitmap, tb_start, tb_end - tb_start);
 597         tb = tb->page_next[n];
 598     }
 599 }
 600
 601 #ifdef TARGET_HAS_PRECISE_SMC
 602
 603 static void tb_gen_code(CPUState *env,
 604                         target_ulong pc, target_ulong cs_base, int flags,
 605                         int cflags)
 606 {
 607     TranslationBlock *tb;
 608     uint8_t *tc_ptr;
 609     target_ulong phys_pc, phys_page2, virt_page2;
 610     int code_gen_size;
 611
 612     phys_pc = get_phys_addr_code(env, pc);
 613     tb = tb_alloc(pc);
 614     if (!tb) {
 615         /* flush must be done */
 616         tb_flush(env);
 617         /* cannot fail at this point */
 618         tb = tb_alloc(pc);
 619     }
 620     tc_ptr = code_gen_ptr;
 621     tb->tc_ptr = tc_ptr;
 622     tb->cs_base = cs_base;
 623     tb->flags = flags;
 624     tb->cflags = cflags;
 625     cpu_gen_code(env, tb, CODE_GEN_MAX_SIZE, &code_gen_size);
 626     code_gen_ptr = (void *)(((unsigned long)code_gen_ptr + code_gen_size + CODE_GEN_ALIGN - 1) & ~(CODE_GEN_ALIGN - 1));
 627
 628     /* check next page if needed */
 629     virt_page2 = (pc + tb->size - 1) & TARGET_PAGE_MASK;
 630     phys_page2 = -1;
 631     if ((pc & TARGET_PAGE_MASK) != virt_page2) {
 632         phys_page2 = get_phys_addr_code(env, virt_page2);
 633     }
 634     tb_link_phys(tb, phys_pc, phys_page2);
 635 }
 636 #endif
 637
 638 /* invalidate all TBs which intersect with the target physical page
 639    starting in range [start;end[. NOTE: start and end must refer to
 640    the same physical page. 'is_cpu_write_access' should be true if called
 641    from a real cpu write access: the virtual CPU will exit the current
 642    TB if code is modified inside this TB. */
 643 void tb_invalidate_phys_page_range(target_ulong start, target_ulong end,
 644                                    int is_cpu_write_access)
 645 {
 646     int n, current_tb_modified, current_tb_not_found, current_flags;
 647     CPUState *env = cpu_single_env;
 648     PageDesc *p;
 649     TranslationBlock *tb, *tb_next, *current_tb, *saved_tb;
 650     target_ulong tb_start, tb_end;
 651     target_ulong current_pc, current_cs_base;
 652
 653     p = page_find(start >> TARGET_PAGE_BITS);
 654     if (!p)
 655         return;
 656     if (!p->code_bitmap &&
 657         ++p->code_write_count >= SMC_BITMAP_USE_THRESHOLD &&
 658         is_cpu_write_access) {
 659         /* build code bitmap */
 660         build_page_bitmap(p);
 661     }
 662
 663     /* we remove all the TBs in the range [start, end[ */
 664     /* XXX: see if in some cases it could be faster to invalidate all the code */
 665     current_tb_not_found = is_cpu_write_access;
 666     current_tb_modified = 0;
 667     current_tb = NULL; /* avoid warning */
 668     current_pc = 0; /* avoid warning */
 669     current_cs_base = 0; /* avoid warning */
 670     current_flags = 0; /* avoid warning */
 671     tb = p->first_tb;
 672     while (tb != NULL) {
 673         n = (long)tb & 3;
 674         tb = (TranslationBlock *)((long)tb & ~3);
 675         tb_next = tb->page_next[n];
 676         /* NOTE: this is subtle as a TB may span two physical pages */
 677         if (n == 0) {
 678             /* NOTE: tb_end may be after the end of the page, but
 679                it is not a problem */
 680             tb_start = tb->page_addr[0] + (tb->pc & ~TARGET_PAGE_MASK);
 681             tb_end = tb_start + tb->size;
 682         } else {
 683             tb_start = tb->page_addr[1];
 684             tb_end = tb_start + ((tb->pc + tb->size) & ~TARGET_PAGE_MASK);
 685         }
 686         if (!(tb_end <= start || tb_start >= end)) {
 687 #ifdef TARGET_HAS_PRECISE_SMC
 688             if (current_tb_not_found) {
 689                 current_tb_not_found = 0;
 690                 current_tb = NULL;
 691                 if (env->mem_write_pc) {
 692                     /* now we have a real cpu fault */
 693                     current_tb = tb_find_pc(env->mem_write_pc);
 694                 }
 695             }
 696             if (current_tb == tb &&
 697                 !(current_tb->cflags & CF_SINGLE_INSN)) {
 698                 /* If we are modifying the current TB, we must stop
 699                 its execution. We could be more precise by checking
 700                 that the modification is after the current PC, but it
 701                 would require a specialized function to partially
 702                 restore the CPU state */
 703
 704                 current_tb_modified = 1;
 705                 cpu_restore_state(current_tb, env,
 706                                   env->mem_write_pc, NULL);
 707 #if defined(TARGET_I386)
 708                 current_flags = env->hflags;
 709                 current_flags |= (env->eflags & (IOPL_MASK | TF_MASK | VM_MASK));
 710                 current_cs_base = (target_ulong)env->segs[R_CS].base;
 711                 current_pc = current_cs_base + env->eip;
 712 #else
 713 #error unsupported CPU
 714 #endif
 715             }
 716 #endif /* TARGET_HAS_PRECISE_SMC */
 717             /* we need to do that to handle the case where a signal
 718                occurs while doing tb_phys_invalidate() */
 719             saved_tb = NULL;
 720             if (env) {
 721                 saved_tb = env->current_tb;
 722                 env->current_tb = NULL;
 723             }
 724             tb_phys_invalidate(tb, -1);
 725             if (env) {
 726                 env->current_tb = saved_tb;
 727                 if (env->interrupt_request && env->current_tb)
 728                     cpu_interrupt(env, env->interrupt_request);
 729             }
 730         }
 731         tb = tb_next;
 732     }
 733 #if !defined(CONFIG_USER_ONLY)
 734     /* if no code remaining, no need to continue to use slow writes */
 735     if (!p->first_tb) {
 736         invalidate_page_bitmap(p);
 737         if (is_cpu_write_access) {
 738             tlb_unprotect_code_phys(env, start, env->mem_write_vaddr);
 739         }
 740     }
 741 #endif
 742 #ifdef TARGET_HAS_PRECISE_SMC
 743     if (current_tb_modified) {
 744         /* we generate a block containing just the instruction
 745            modifying the memory. It will ensure that it cannot modify
 746            itself */
 747         env->current_tb = NULL;
 748         tb_gen_code(env, current_pc, current_cs_base, current_flags,
 749                     CF_SINGLE_INSN);
 750         cpu_resume_from_signal(env, NULL);
 751     }
 752 #endif
 753 }
 754
 755 /* len must be <= 8 and start must be a multiple of len */
 756 static inline void tb_invalidate_phys_page_fast(target_ulong start, int len)
 757 {
 758     PageDesc *p;
 759     int offset, b;
 760 #if 0
 761     if (1) {
 762         if (loglevel) {
 763             fprintf(logfile, "modifying code at 0x%x size=%d EIP=%x PC=%08x\n",
 764                    cpu_single_env->mem_write_vaddr, len,
 765                    cpu_single_env->eip,
 766                    cpu_single_env->eip + (long)cpu_single_env->segs[R_CS].base);
 767         }
 768     }
 769 #endif
 770     p = page_find(start >> TARGET_PAGE_BITS);
 771     if (!p)
 772         return;
 773     if (p->code_bitmap) {
 774         offset = start & ~TARGET_PAGE_MASK;
 775         b = p->code_bitmap[offset >> 3] >> (offset & 7);
 776         if (b & ((1 << len) - 1))
 777             goto do_invalidate;
 778     } else {
 779     do_invalidate:
 780         tb_invalidate_phys_page_range(start, start + len, 1);
 781     }
 782 }
 783
 784 #if !defined(CONFIG_SOFTMMU)
 785 static void tb_invalidate_phys_page(target_ulong addr,
 786                                     unsigned long pc, void *puc)
 787 {
 788     int n, current_flags, current_tb_modified;
 789     target_ulong current_pc, current_cs_base;
 790     PageDesc *p;
 791     TranslationBlock *tb, *current_tb;
 792 #ifdef TARGET_HAS_PRECISE_SMC
 793     CPUState *env = cpu_single_env;
 794 #endif
 795
 796     addr &= TARGET_PAGE_MASK;
 797     p = page_find(addr >> TARGET_PAGE_BITS);
 798     if (!p)
 799         return;
 800     tb = p->first_tb;
 801     current_tb_modified = 0;
 802     current_tb = NULL;
 803     current_pc = 0; /* avoid warning */
 804     current_cs_base = 0; /* avoid warning */
 805     current_flags = 0; /* avoid warning */
 806 #ifdef TARGET_HAS_PRECISE_SMC
 807     if (tb && pc != 0) {
 808         current_tb = tb_find_pc(pc);
 809     }
 810 #endif
 811     while (tb != NULL) {
 812         n = (long)tb & 3;
 813         tb = (TranslationBlock *)((long)tb & ~3);
 814 #ifdef TARGET_HAS_PRECISE_SMC
 815         if (current_tb == tb &&
 816             !(current_tb->cflags & CF_SINGLE_INSN)) {
 817                 /* If we are modifying the current TB, we must stop
 818                    its execution. We could be more precise by checking
 819                    that the modification is after the current PC, but it
 820                    would require a specialized function to partially
 821                    restore the CPU state */
 822
 823             current_tb_modified = 1;
 824             cpu_restore_state(current_tb, env, pc, puc);
 825 #if defined(TARGET_I386)
 826             current_flags = env->hflags;
 827             current_flags |= (env->eflags & (IOPL_MASK | TF_MASK | VM_MASK));
 828             current_cs_base = (target_ulong)env->segs[R_CS].base;
 829             current_pc = current_cs_base + env->eip;
 830 #else
 831 #error unsupported CPU
 832 #endif
 833         }
 834 #endif /* TARGET_HAS_PRECISE_SMC */
 835         tb_phys_invalidate(tb, addr);
 836         tb = tb->page_next[n];
 837     }
 838     p->first_tb = NULL;
 839 #ifdef TARGET_HAS_PRECISE_SMC
 840     if (current_tb_modified) {
 841         /* we generate a block containing just the instruction
 842            modifying the memory. It will ensure that it cannot modify
 843            itself */
 844         env->current_tb = NULL;
 845         tb_gen_code(env, current_pc, current_cs_base, current_flags,
 846                     CF_SINGLE_INSN);
 847         cpu_resume_from_signal(env, puc);
 848     }
 849 #endif
 850 }
 851 #endif
 852
 853 /* add the tb in the target page and protect it if necessary */
 854 static inline void tb_alloc_page(TranslationBlock *tb,
 855                                  unsigned int n, target_ulong page_addr)
 856 {
 857     PageDesc *p;
 858     TranslationBlock *last_first_tb;
 859
 860     tb->page_addr[n] = page_addr;
 861     p = page_find_alloc(page_addr >> TARGET_PAGE_BITS);
 862     tb->page_next[n] = p->first_tb;
 863     last_first_tb = p->first_tb;
 864     p->first_tb = (TranslationBlock *)((long)tb | n);
 865     invalidate_page_bitmap(p);
 866
 867 #if defined(TARGET_HAS_SMC) || 1
 868
 869 #if defined(CONFIG_USER_ONLY)
 870     if (p->flags & PAGE_WRITE) {
 871         target_ulong addr;
 872         PageDesc *p2;
 873         int prot;
 874
 875         /* force the host page as non writable (writes will have a
 876            page fault + mprotect overhead) */
 877         page_addr &= qemu_host_page_mask;
 878         prot = 0;
 879         for(addr = page_addr; addr < page_addr + qemu_host_page_size;
 880             addr += TARGET_PAGE_SIZE) {
 881
 882             p2 = page_find (addr >> TARGET_PAGE_BITS);
 883             if (!p2)
 884                 continue;
 885             prot |= p2->flags;
 886             p2->flags &= ~PAGE_WRITE;
 887             page_get_flags(addr);
 888           }
 889         mprotect(g2h(page_addr), qemu_host_page_size,
 890                  (prot & PAGE_BITS) & ~PAGE_WRITE);
 891 #ifdef DEBUG_TB_INVALIDATE
 892         printf("protecting code page: 0x%08lx\n",
 893                page_addr);
 894 #endif
 895     }
 896 #else
 897     /* if some code is already present, then the pages are already
 898        protected. So we handle the case where only the first TB is
 899        allocated in a physical page */
 900     if (!last_first_tb) {
 901         tlb_protect_code(page_addr);
 902     }
 903 #endif
 904
 905 #endif /* TARGET_HAS_SMC */
 906 }
 907
 908 /* Allocate a new translation block. Flush the translation buffer if
 909    too many translation blocks or too much generated code. */
 910 TranslationBlock *tb_alloc(target_ulong pc)
 911 {
 912     TranslationBlock *tb;
 913
 914     if (nb_tbs >= CODE_GEN_MAX_BLOCKS ||
 915         (code_gen_ptr - code_gen_buffer) >= CODE_GEN_BUFFER_MAX_SIZE)
 916         return NULL;
 917     tb = &tbs[nb_tbs++];
 918     tb->pc = pc;
 919     tb->cflags = 0;
 920     return tb;
 921 }
 922
 923 /* add a new TB and link it to the physical page tables. phys_page2 is
 924    (-1) to indicate that only one page contains the TB. */
 925 void tb_link_phys(TranslationBlock *tb,
 926                   target_ulong phys_pc, target_ulong phys_page2)
 927 {
 928     unsigned int h;
 929     TranslationBlock **ptb;
 930
 931     /* add in the physical hash table */
 932     h = tb_phys_hash_func(phys_pc);
 933     ptb = &tb_phys_hash[h];
 934     tb->phys_hash_next = *ptb;
 935     *ptb = tb;
 936
 937     /* add in the page list */
 938     tb_alloc_page(tb, 0, phys_pc & TARGET_PAGE_MASK);
 939     if (phys_page2 != -1)
 940         tb_alloc_page(tb, 1, phys_page2);
 941     else
 942         tb->page_addr[1] = -1;
 943
 944     tb->jmp_first = (TranslationBlock *)((long)tb | 2);
 945     tb->jmp_next[0] = NULL;
 946     tb->jmp_next[1] = NULL;
 947 #ifdef USE_CODE_COPY
 948     tb->cflags &= ~CF_FP_USED;
 949     if (tb->cflags & CF_TB_FP_USED)
 950         tb->cflags |= CF_FP_USED;
 951 #endif
 952
 953     /* init original jump addresses */
 954     if (tb->tb_next_offset[0] != 0xffff)
 955         tb_reset_jump(tb, 0);
 956     if (tb->tb_next_offset[1] != 0xffff)
 957         tb_reset_jump(tb, 1);
 958
 959 #ifdef DEBUG_TB_CHECK
 960     tb_page_check();
 961 #endif
 962 }
 963
 964 /* find the TB 'tb' such that tb[0].tc_ptr <= tc_ptr <
 965    tb[1].tc_ptr. Return NULL if not found */
 966 TranslationBlock *tb_find_pc(unsigned long tc_ptr)
 967 {
 968     int m_min, m_max, m;
 969     unsigned long v;
 970     TranslationBlock *tb;
 971
 972     if (nb_tbs <= 0)
 973         return NULL;
 974     if (tc_ptr < (unsigned long)code_gen_buffer ||
 975         tc_ptr >= (unsigned long)code_gen_ptr)
 976         return NULL;
 977     /* binary search (cf Knuth) */
 978     m_min = 0;
 979     m_max = nb_tbs - 1;
 980     while (m_min <= m_max) {
 981         m = (m_min + m_max) >> 1;
 982         tb = &tbs[m];
 983         v = (unsigned long)tb->tc_ptr;
 984         if (v == tc_ptr)
 985             return tb;
 986         else if (tc_ptr < v) {
 987             m_max = m - 1;
 988         } else {
 989             m_min = m + 1;
 990         }
 991     }
 992     return &tbs[m_max];
 993 }
 994
 995 static void tb_reset_jump_recursive(TranslationBlock *tb);
 996
 997 static inline void tb_reset_jump_recursive2(TranslationBlock *tb, int n)
 998 {
 999     TranslationBlock *tb1, *tb_next, **ptb;
1000     unsigned int n1;
1001
1002     tb1 = tb->jmp_next[n];
1003     if (tb1 != NULL) {
1004         /* find head of list */
1005         for(;;) {
1006             n1 = (long)tb1 & 3;
1007             tb1 = (TranslationBlock *)((long)tb1 & ~3);
1008             if (n1 == 2)
1009                 break;
1010             tb1 = tb1->jmp_next[n1];
1011         }
1012         /* we are now sure now that tb jumps to tb1 */
1013         tb_next = tb1;
1014
1015         /* remove tb from the jmp_first list */
1016         ptb = &tb_next->jmp_first;
1017         for(;;) {
1018             tb1 = *ptb;
1019             n1 = (long)tb1 & 3;
1020             tb1 = (TranslationBlock *)((long)tb1 & ~3);
1021             if (n1 == n && tb1 == tb)
1022                 break;
1023             ptb = &tb1->jmp_next[n1];
1024         }
1025         *ptb = tb->jmp_next[n];
1026         tb->jmp_next[n] = NULL;
1027
1028         /* suppress the jump to next tb in generated code */
1029         tb_reset_jump(tb, n);
1030
1031         /* suppress jumps in the tb on which we could have jumped */
1032         tb_reset_jump_recursive(tb_next);
1033     }
1034 }
1035
1036 static void tb_reset_jump_recursive(TranslationBlock *tb)
1037 {
1038     tb_reset_jump_recursive2(tb, 0);
1039     tb_reset_jump_recursive2(tb, 1);
1040 }
1041
1042 #if defined(TARGET_HAS_ICE)
1043 static void breakpoint_invalidate(CPUState *env, target_ulong pc)
1044 {
1045     target_phys_addr_t addr;
1046     target_ulong pd;
1047     ram_addr_t ram_addr;
1048     PhysPageDesc *p;
1049
1050     addr = cpu_get_phys_page_debug(env, pc);
1051     p = phys_page_find(addr >> TARGET_PAGE_BITS);
1052     if (!p) {
1053         pd = IO_MEM_UNASSIGNED;
1054     } else {
1055         pd = p->phys_offset;
1056     }
1057     ram_addr = (pd & TARGET_PAGE_MASK) | (pc & ~TARGET_PAGE_MASK);
1058     tb_invalidate_phys_page_range(ram_addr, ram_addr + 1, 0);
1059 }
1060 #endif
1061
1062 /* Add a watchpoint.  */
1063 int  cpu_watchpoint_insert(CPUState *env, target_ulong addr)
1064 {
1065     int i;
1066
1067     for (i = 0; i < env->nb_watchpoints; i++) {
1068         if (addr == env->watchpoint[i].vaddr)
1069             return 0;
1070     }
1071     if (env->nb_watchpoints >= MAX_WATCHPOINTS)
1072         return -1;
1073
1074     i = env->nb_watchpoints++;
1075     env->watchpoint[i].vaddr = addr;
1076     tlb_flush_page(env, addr);
1077     /* FIXME: This flush is needed because of the hack to make memory ops
1078        terminate the TB.  It can be removed once the proper IO trap and
1079        re-execute bits are in.  */
1080     tb_flush(env);
1081     return i;
1082 }
1083
1084 /* Remove a watchpoint.  */
1085 int cpu_watchpoint_remove(CPUState *env, target_ulong addr)
1086 {
1087     int i;
1088
1089     for (i = 0; i < env->nb_watchpoints; i++) {
1090         if (addr == env->watchpoint[i].vaddr) {
1091             env->nb_watchpoints--;
1092             env->watchpoint[i] = env->watchpoint[env->nb_watchpoints];
1093             tlb_flush_page(env, addr);
1094             return 0;
1095         }
1096     }
1097     return -1;
1098 }
1099
1100 /* add a breakpoint. EXCP_DEBUG is returned by the CPU loop if a
1101    breakpoint is reached */
1102 int cpu_breakpoint_insert(CPUState *env, target_ulong pc)
1103 {
1104 #if defined(TARGET_HAS_ICE)
1105     int i;
1106
1107     for(i = 0; i < env->nb_breakpoints; i++) {
1108         if (env->breakpoints[i] == pc)
1109             return 0;
1110     }
1111
1112     if (env->nb_breakpoints >= MAX_BREAKPOINTS)
1113         return -1;
1114     env->breakpoints[env->nb_breakpoints++] = pc;
1115
1116     breakpoint_invalidate(env, pc);
1117     return 0;
1118 #else
1119     return -1;
1120 #endif
1121 }
1122
1123 /* remove a breakpoint */
1124 int cpu_breakpoint_remove(CPUState *env, target_ulong pc)
1125 {
1126 #if defined(TARGET_HAS_ICE)
1127     int i;
1128     for(i = 0; i < env->nb_breakpoints; i++) {
1129         if (env->breakpoints[i] == pc)
1130             goto found;
1131     }
1132     return -1;
1133  found:
1134     env->nb_breakpoints--;
1135     if (i < env->nb_breakpoints)
1136       env->breakpoints[i] = env->breakpoints[env->nb_breakpoints];
1137
1138     breakpoint_invalidate(env, pc);
1139     return 0;
1140 #else
1141     return -1;
1142 #endif
1143 }
1144
1145 /* enable or disable single step mode. EXCP_DEBUG is returned by the
1146    CPU loop after each instruction */
1147 void cpu_single_step(CPUState *env, int enabled)
1148 {
1149 #if defined(TARGET_HAS_ICE)
1150     if (env->singlestep_enabled != enabled) {
1151         env->singlestep_enabled = enabled;
1152         /* must flush all the translated code to avoid inconsistancies */
1153         /* XXX: only flush what is necessary */
1154         tb_flush(env);
1155     }
1156 #endif
1157 }
1158
1159 /* enable or disable low levels log */
1160 void cpu_set_log(int log_flags)
1161 {
1162     loglevel = log_flags;
1163     if (loglevel && !logfile) {
1164         logfile = fopen(logfilename, log_append ? "a" : "w");
1165         if (!logfile) {
1166             perror(logfilename);
1167             _exit(1);
1168         }
1169 #if !defined(CONFIG_SOFTMMU)
1170         /* must avoid mmap() usage of glibc by setting a buffer "by hand" */
1171         {
1172             static uint8_t logfile_buf[4096];
1173             setvbuf(logfile, logfile_buf, _IOLBF, sizeof(logfile_buf));
1174         }
1175 #else
1176         setvbuf(logfile, NULL, _IOLBF, 0);
1177 #endif
1178         log_append = 1;
1179     }
1180     if (!loglevel && logfile) {
1181         fclose(logfile);
1182         logfile = NULL;
1183     }
1184 }
1185
1186 void cpu_set_log_filename(const char *filename)
1187 {
1188     logfilename = strdup(filename);
1189     if (logfile) {
1190         fclose(logfile);
1191         logfile = NULL;
1192     }
1193     cpu_set_log(loglevel);
1194 }
1195
1196 /* mask must never be zero, except for A20 change call */
1197 void cpu_interrupt(CPUState *env, int mask)
1198 {
1199     TranslationBlock *tb;
1200     static int interrupt_lock;
1201
1202     env->interrupt_request |= mask;
1203     /* if the cpu is currently executing code, we must unlink it and
1204        all the potentially executing TB */
1205     tb = env->current_tb;
1206     if (tb && !testandset(&interrupt_lock)) {
1207         env->current_tb = NULL;
1208         tb_reset_jump_recursive(tb);
1209         interrupt_lock = 0;
1210     }
1211 }
1212
1213 void cpu_reset_interrupt(CPUState *env, int mask)
1214 {
1215     env->interrupt_request &= ~mask;
1216 }
1217
1218 CPULogItem cpu_log_items[] = {
1219     { CPU_LOG_TB_OUT_ASM, "out_asm",
1220       "show generated host assembly code for each compiled TB" },
1221     { CPU_LOG_TB_IN_ASM, "in_asm",
1222       "show target assembly code for each compiled TB" },
1223     { CPU_LOG_TB_OP, "op",
1224       "show micro ops for each compiled TB (only usable if 'in_asm' used)" },
1225 #ifdef TARGET_I386
1226     { CPU_LOG_TB_OP_OPT, "op_opt",
1227       "show micro ops after optimization for each compiled TB" },
1228 #endif
1229     { CPU_LOG_INT, "int",
1230       "show interrupts/exceptions in short format" },
1231     { CPU_LOG_EXEC, "exec",
1232       "show trace before each executed TB (lots of logs)" },
1233     { CPU_LOG_TB_CPU, "cpu",
1234       "show CPU state before block translation" },
1235 #ifdef TARGET_I386
1236     { CPU_LOG_PCALL, "pcall",
1237       "show protected mode far calls/returns/exceptions" },
1238 #endif
1239 #ifdef DEBUG_IOPORT
1240     { CPU_LOG_IOPORT, "ioport",
1241       "show all i/o ports accesses" },
1242 #endif
1243     { 0, NULL, NULL },
1244 };
1245
1246 static int cmp1(const char *s1, int n, const char *s2)
1247 {
1248     if (strlen(s2) != n)
1249         return 0;
1250     return memcmp(s1, s2, n) == 0;
1251 }
1252
1253 /* takes a comma separated list of log masks. Return 0 if error. */
1254 int cpu_str_to_log_mask(const char *str)
1255 {
1256     CPULogItem *item;
1257     int mask;
1258     const char *p, *p1;
1259
1260     p = str;
1261     mask = 0;
1262     for(;;) {
1263         p1 = strchr(p, ',');
1264         if (!p1)
1265             p1 = p + strlen(p);
1266         if(cmp1(p,p1-p,"all")) {
1267                 for(item = cpu_log_items; item->mask != 0; item++) {
1268                         mask |= item->mask;
1269                 }
1270         } else {
1271         for(item = cpu_log_items; item->mask != 0; item++) {
1272             if (cmp1(p, p1 - p, item->name))
1273                 goto found;
1274         }
1275         return 0;
1276         }
1277     found:
1278         mask |= item->mask;
1279         if (*p1 != ',')
1280             break;
1281         p = p1 + 1;
1282     }
1283     return mask;
1284 }
1285
1286 void cpu_abort(CPUState *env, const char *fmt, ...)
1287 {
1288     va_list ap;
1289
1290     va_start(ap, fmt);
1291     fprintf(stderr, "qemu: fatal: ");
1292     vfprintf(stderr, fmt, ap);
1293     fprintf(stderr, "\n");
1294 #ifdef TARGET_I386
1295     if(env->intercept & INTERCEPT_SVM_MASK) {
1296         /* most probably the virtual machine should not
1297            be shut down but rather caught by the VMM */
1298         vmexit(SVM_EXIT_SHUTDOWN, 0);
1299     }
1300     cpu_dump_state(env, stderr, fprintf, X86_DUMP_FPU | X86_DUMP_CCOP);
1301 #else
1302     cpu_dump_state(env, stderr, fprintf, 0);
1303 #endif
1304     if (logfile) {
1305         fprintf(logfile, "qemu: fatal: ");
1306         vfprintf(logfile, fmt, ap);
1307         fprintf(logfile, "\n");
1308 #ifdef TARGET_I386
1309         cpu_dump_state(env, logfile, fprintf, X86_DUMP_FPU | X86_DUMP_CCOP);
1310 #else
1311         cpu_dump_state(env, logfile, fprintf, 0);
1312 #endif
1313         fflush(logfile);
1314         fclose(logfile);
1315     }
1316     va_end(ap);
1317     abort();
1318 }
1319
1320 CPUState *cpu_copy(CPUState *env)
1321 {
1322     CPUState *new_env = cpu_init();
1323     /* preserve chaining and index */
1324     CPUState *next_cpu = new_env->next_cpu;
1325     int cpu_index = new_env->cpu_index;
1326     memcpy(new_env, env, sizeof(CPUState));
1327     new_env->next_cpu = next_cpu;
1328     new_env->cpu_index = cpu_index;
1329     return new_env;
1330 }
1331
1332 #if !defined(CONFIG_USER_ONLY)
1333
1334 /* NOTE: if flush_global is true, also flush global entries (not
1335    implemented yet) */
1336 void tlb_flush(CPUState *env, int flush_global)
1337 {
1338     int i;
1339
1340 #if defined(DEBUG_TLB)
1341     printf("tlb_flush:\n");
1342 #endif
1343     /* must reset current TB so that interrupts cannot modify the
1344        links while we are modifying them */
1345     env->current_tb = NULL;
1346
1347     for(i = 0; i < CPU_TLB_SIZE; i++) {
1348         env->tlb_table[0][i].addr_read = -1;
1349         env->tlb_table[0][i].addr_write = -1;
1350         env->tlb_table[0][i].addr_code = -1;
1351         env->tlb_table[1][i].addr_read = -1;
1352         env->tlb_table[1][i].addr_write = -1;
1353         env->tlb_table[1][i].addr_code = -1;
1354 #if (NB_MMU_MODES >= 3)
1355         env->tlb_table[2][i].addr_read = -1;
1356         env->tlb_table[2][i].addr_write = -1;
1357         env->tlb_table[2][i].addr_code = -1;
1358 #if (NB_MMU_MODES == 4)
1359         env->tlb_table[3][i].addr_read = -1;
1360         env->tlb_table[3][i].addr_write = -1;
1361         env->tlb_table[3][i].addr_code = -1;
1362 #endif
1363 #endif
1364     }
1365
1366     memset (env->tb_jmp_cache, 0, TB_JMP_CACHE_SIZE * sizeof (void *));
1367
1368 #if !defined(CONFIG_SOFTMMU)
1369     munmap((void *)MMAP_AREA_START, MMAP_AREA_END - MMAP_AREA_START);
1370 #endif
1371 #ifdef USE_KQEMU
1372     if (env->kqemu_enabled) {
1373         kqemu_flush(env, flush_global);
1374     }
1375 #endif
1376     tlb_flush_count++;
1377 }
1378
1379 static inline void tlb_flush_entry(CPUTLBEntry *tlb_entry, target_ulong addr)
1380 {
1381     if (addr == (tlb_entry->addr_read &
1382                  (TARGET_PAGE_MASK | TLB_INVALID_MASK)) ||
1383         addr == (tlb_entry->addr_write &
1384                  (TARGET_PAGE_MASK | TLB_INVALID_MASK)) ||
1385         addr == (tlb_entry->addr_code &
1386                  (TARGET_PAGE_MASK | TLB_INVALID_MASK))) {
1387         tlb_entry->addr_read = -1;
1388         tlb_entry->addr_write = -1;
1389         tlb_entry->addr_code = -1;
1390     }
1391 }
1392
1393 void tlb_flush_page(CPUState *env, target_ulong addr)
1394 {
1395     int i;
1396     TranslationBlock *tb;
1397
1398 #if defined(DEBUG_TLB)
1399     printf("tlb_flush_page: " TARGET_FMT_lx "\n", addr);
1400 #endif
1401     /* must reset current TB so that interrupts cannot modify the
1402        links while we are modifying them */
1403     env->current_tb = NULL;
1404
1405     addr &= TARGET_PAGE_MASK;
1406     i = (addr >> TARGET_PAGE_BITS) & (CPU_TLB_SIZE - 1);
1407     tlb_flush_entry(&env->tlb_table[0][i], addr);
1408     tlb_flush_entry(&env->tlb_table[1][i], addr);
1409 #if (NB_MMU_MODES >= 3)
1410     tlb_flush_entry(&env->tlb_table[2][i], addr);
1411 #if (NB_MMU_MODES == 4)
1412     tlb_flush_entry(&env->tlb_table[3][i], addr);
1413 #endif
1414 #endif
1415
1416     /* Discard jump cache entries for any tb which might potentially
1417        overlap the flushed page.  */
1418     i = tb_jmp_cache_hash_page(addr - TARGET_PAGE_SIZE);
1419     memset (&env->tb_jmp_cache[i], 0, TB_JMP_PAGE_SIZE * sizeof(tb));
1420
1421     i = tb_jmp_cache_hash_page(addr);
1422     memset (&env->tb_jmp_cache[i], 0, TB_JMP_PAGE_SIZE * sizeof(tb));
1423
1424 #if !defined(CONFIG_SOFTMMU)
1425     if (addr < MMAP_AREA_END)
1426         munmap((void *)addr, TARGET_PAGE_SIZE);
1427 #endif
1428 #ifdef USE_KQEMU
1429     if (env->kqemu_enabled) {
1430         kqemu_flush_page(env, addr);
1431     }
1432 #endif
1433 }
1434
1435 /* update the TLBs so that writes to code in the virtual page 'addr'
1436    can be detected */
1437 static void tlb_protect_code(ram_addr_t ram_addr)
1438 {
1439     cpu_physical_memory_reset_dirty(ram_addr,
1440                                     ram_addr + TARGET_PAGE_SIZE,
1441                                     CODE_DIRTY_FLAG);
1442 }
1443
1444 /* update the TLB so that writes in physical page 'phys_addr' are no longer
1445    tested for self modifying code */
1446 static void tlb_unprotect_code_phys(CPUState *env, ram_addr_t ram_addr,
1447                                     target_ulong vaddr)
1448 {
1449     phys_ram_dirty[ram_addr >> TARGET_PAGE_BITS] |= CODE_DIRTY_FLAG;
1450 }
1451
1452 static inline void tlb_reset_dirty_range(CPUTLBEntry *tlb_entry,
1453                                          unsigned long start, unsigned long length)
1454 {
1455     unsigned long addr;
1456     if ((tlb_entry->addr_write & ~TARGET_PAGE_MASK) == IO_MEM_RAM) {
1457         addr = (tlb_entry->addr_write & TARGET_PAGE_MASK) + tlb_entry->addend;
1458         if ((addr - start) < length) {
1459             tlb_entry->addr_write = (tlb_entry->addr_write & TARGET_PAGE_MASK) | IO_MEM_NOTDIRTY;
1460         }
1461     }
1462 }
1463
1464 void cpu_physical_memory_reset_dirty(ram_addr_t start, ram_addr_t end,
1465                                      int dirty_flags)
1466 {
1467     CPUState *env;
1468     unsigned long length, start1;
1469     int i, mask, len;
1470     uint8_t *p;
1471
1472     start &= TARGET_PAGE_MASK;
1473     end = TARGET_PAGE_ALIGN(end);
1474
1475     length = end - start;
1476     if (length == 0)
1477         return;
1478     len = length >> TARGET_PAGE_BITS;
1479 #ifdef USE_KQEMU
1480     /* XXX: should not depend on cpu context */
1481     env = first_cpu;
1482     if (env->kqemu_enabled) {
1483         ram_addr_t addr;
1484         addr = start;
1485         for(i = 0; i < len; i++) {
1486             kqemu_set_notdirty(env, addr);
1487             addr += TARGET_PAGE_SIZE;
1488         }
1489     }
1490 #endif
1491     mask = ~dirty_flags;
1492     p = phys_ram_dirty + (start >> TARGET_PAGE_BITS);
1493     for(i = 0; i < len; i++)
1494         p[i] &= mask;
1495
1496     /* we modify the TLB cache so that the dirty bit will be set again
1497        when accessing the range */
1498     start1 = start + (unsigned long)phys_ram_base;
1499     for(env = first_cpu; env != NULL; env = env->next_cpu) {
1500         for(i = 0; i < CPU_TLB_SIZE; i++)
1501             tlb_reset_dirty_range(&env->tlb_table[0][i], start1, length);
1502         for(i = 0; i < CPU_TLB_SIZE; i++)
1503             tlb_reset_dirty_range(&env->tlb_table[1][i], start1, length);
1504 #if (NB_MMU_MODES >= 3)
1505         for(i = 0; i < CPU_TLB_SIZE; i++)
1506             tlb_reset_dirty_range(&env->tlb_table[2][i], start1, length);
1507 #if (NB_MMU_MODES == 4)
1508         for(i = 0; i < CPU_TLB_SIZE; i++)
1509             tlb_reset_dirty_range(&env->tlb_table[3][i], start1, length);
1510 #endif
1511 #endif
1512     }
1513
1514 #if !defined(CONFIG_SOFTMMU)
1515     /* XXX: this is expensive */
1516     {
1517         VirtPageDesc *p;
1518         int j;
1519         target_ulong addr;
1520
1521         for(i = 0; i < L1_SIZE; i++) {
1522             p = l1_virt_map[i];
1523             if (p) {
1524                 addr = i << (TARGET_PAGE_BITS + L2_BITS);
1525                 for(j = 0; j < L2_SIZE; j++) {
1526                     if (p->valid_tag == virt_valid_tag &&
1527                         p->phys_addr >= start && p->phys_addr < end &&
1528                         (p->prot & PROT_WRITE)) {
1529                         if (addr < MMAP_AREA_END) {
1530                             mprotect((void *)addr, TARGET_PAGE_SIZE,
1531                                      p->prot & ~PROT_WRITE);
1532                         }
1533                     }
1534                     addr += TARGET_PAGE_SIZE;
1535                     p++;
1536                 }
1537             }
1538         }
1539     }
1540 #endif
1541 }
1542
1543 static inline void tlb_update_dirty(CPUTLBEntry *tlb_entry)
1544 {
1545     ram_addr_t ram_addr;
1546
1547     if ((tlb_entry->addr_write & ~TARGET_PAGE_MASK) == IO_MEM_RAM) {
1548         ram_addr = (tlb_entry->addr_write & TARGET_PAGE_MASK) +
1549             tlb_entry->addend - (unsigned long)phys_ram_base;
1550         if (!cpu_physical_memory_is_dirty(ram_addr)) {
1551             tlb_entry->addr_write |= IO_MEM_NOTDIRTY;
1552         }
1553     }
1554 }
1555
1556 /* update the TLB according to the current state of the dirty bits */
1557 void cpu_tlb_update_dirty(CPUState *env)
1558 {
1559     int i;
1560     for(i = 0; i < CPU_TLB_SIZE; i++)
1561         tlb_update_dirty(&env->tlb_table[0][i]);
1562     for(i = 0; i < CPU_TLB_SIZE; i++)
1563         tlb_update_dirty(&env->tlb_table[1][i]);
1564 #if (NB_MMU_MODES >= 3)
1565     for(i = 0; i < CPU_TLB_SIZE; i++)
1566         tlb_update_dirty(&env->tlb_table[2][i]);
1567 #if (NB_MMU_MODES == 4)
1568     for(i = 0; i < CPU_TLB_SIZE; i++)
1569         tlb_update_dirty(&env->tlb_table[3][i]);
1570 #endif
1571 #endif
1572 }
1573
1574 static inline void tlb_set_dirty1(CPUTLBEntry *tlb_entry,
1575                                   unsigned long start)
1576 {
1577     unsigned long addr;
1578     if ((tlb_entry->addr_write & ~TARGET_PAGE_MASK) == IO_MEM_NOTDIRTY) {
1579         addr = (tlb_entry->addr_write & TARGET_PAGE_MASK) + tlb_entry->addend;
1580         if (addr == start) {
1581             tlb_entry->addr_write = (tlb_entry->addr_write & TARGET_PAGE_MASK) | IO_MEM_RAM;
1582         }
1583     }
1584 }
1585
1586 /* update the TLB corresponding to virtual page vaddr and phys addr
1587    addr so that it is no longer dirty */
1588 static inline void tlb_set_dirty(CPUState *env,
1589                                  unsigned long addr, target_ulong vaddr)
1590 {
1591     int i;
1592
1593     addr &= TARGET_PAGE_MASK;
1594     i = (vaddr >> TARGET_PAGE_BITS) & (CPU_TLB_SIZE - 1);
1595     tlb_set_dirty1(&env->tlb_table[0][i], addr);
1596     tlb_set_dirty1(&env->tlb_table[1][i], addr);
1597 #if (NB_MMU_MODES >= 3)
1598     tlb_set_dirty1(&env->tlb_table[2][i], addr);
1599 #if (NB_MMU_MODES == 4)
1600     tlb_set_dirty1(&env->tlb_table[3][i], addr);
1601 #endif
1602 #endif
1603 }
1604
1605 /* add a new TLB entry. At most one entry for a given virtual address
1606    is permitted. Return 0 if OK or 2 if the page could not be mapped
1607    (can only happen in non SOFTMMU mode for I/O pages or pages
1608    conflicting with the host address space). */
1609 int tlb_set_page_exec(CPUState *env, target_ulong vaddr,
1610                       target_phys_addr_t paddr, int prot,
1611                       int mmu_idx, int is_softmmu)
1612 {
1613     PhysPageDesc *p;
1614     unsigned long pd;
1615     unsigned int index;
1616     target_ulong address;
1617     target_phys_addr_t addend;
1618     int ret;
1619     CPUTLBEntry *te;
1620     int i;
1621
1622     p = phys_page_find(paddr >> TARGET_PAGE_BITS);
1623     if (!p) {
1624         pd = IO_MEM_UNASSIGNED;
1625     } else {
1626         pd = p->phys_offset;
1627     }
1628 #if defined(DEBUG_TLB)
1629     printf("tlb_set_page: vaddr=" TARGET_FMT_lx " paddr=0x%08x prot=%x idx=%d smmu=%d pd=0x%08lx\n",
1630            vaddr, (int)paddr, prot, mmu_idx, is_softmmu, pd);
1631 #endif
1632
1633     ret = 0;
1634 #if !defined(CONFIG_SOFTMMU)
1635     if (is_softmmu)
1636 #endif
1637     {
1638         if ((pd & ~TARGET_PAGE_MASK) > IO_MEM_ROM && !(pd & IO_MEM_ROMD)) {
1639             /* IO memory case */
1640             address = vaddr | pd;
1641             addend = paddr;
1642         } else {
1643             /* standard memory */
1644             address = vaddr;
1645             addend = (unsigned long)phys_ram_base + (pd & TARGET_PAGE_MASK);
1646         }
1647
1648         /* Make accesses to pages with watchpoints go via the
1649            watchpoint trap routines.  */
1650         for (i = 0; i < env->nb_watchpoints; i++) {
1651             if (vaddr == (env->watchpoint[i].vaddr & TARGET_PAGE_MASK)) {
1652                 if (address & ~TARGET_PAGE_MASK) {
1653                     env->watchpoint[i].addend = 0;
1654                     address = vaddr | io_mem_watch;
1655                 } else {
1656                     env->watchpoint[i].addend = pd - paddr +
1657                         (unsigned long) phys_ram_base;
1658                     /* TODO: Figure out how to make read watchpoints coexist
1659                        with code.  */
1660                     pd = (pd & TARGET_PAGE_MASK) | io_mem_watch | IO_MEM_ROMD;
1661                 }
1662             }
1663         }
1664
1665         index = (vaddr >> TARGET_PAGE_BITS) & (CPU_TLB_SIZE - 1);
1666         addend -= vaddr;
1667         te = &env->tlb_table[mmu_idx][index];
1668         te->addend = addend;
1669         if (prot & PAGE_READ) {
1670             te->addr_read = address;
1671         } else {
1672             te->addr_read = -1;
1673         }
1674         if (prot & PAGE_EXEC) {
1675             te->addr_code = address;
1676         } else {
1677             te->addr_code = -1;
1678         }
1679         if (prot & PAGE_WRITE) {
1680             if ((pd & ~TARGET_PAGE_MASK) == IO_MEM_ROM ||
1681                 (pd & IO_MEM_ROMD)) {
1682                 /* write access calls the I/O callback */
1683                 te->addr_write = vaddr |
1684                     (pd & ~(TARGET_PAGE_MASK | IO_MEM_ROMD));
1685             } else if ((pd & ~TARGET_PAGE_MASK) == IO_MEM_RAM &&
1686                        !cpu_physical_memory_is_dirty(pd)) {
1687                 te->addr_write = vaddr | IO_MEM_NOTDIRTY;
1688             } else {
1689                 te->addr_write = address;
1690             }
1691         } else {
1692             te->addr_write = -1;
1693         }
1694     }
1695 #if !defined(CONFIG_SOFTMMU)
1696     else {
1697         if ((pd & ~TARGET_PAGE_MASK) > IO_MEM_ROM) {
1698             /* IO access: no mapping is done as it will be handled by the
1699                soft MMU */
1700             if (!(env->hflags & HF_SOFTMMU_MASK))
1701                 ret = 2;
1702         } else {
1703             void *map_addr;
1704
1705             if (vaddr >= MMAP_AREA_END) {
1706                 ret = 2;
1707             } else {
1708                 if (prot & PROT_WRITE) {
1709                     if ((pd & ~TARGET_PAGE_MASK) == IO_MEM_ROM ||
1710 #if defined(TARGET_HAS_SMC) || 1
1711                         first_tb ||
1712 #endif
1713                         ((pd & ~TARGET_PAGE_MASK) == IO_MEM_RAM &&
1714                          !cpu_physical_memory_is_dirty(pd))) {
1715                         /* ROM: we do as if code was inside */
1716                         /* if code is present, we only map as read only and save the
1717                            original mapping */
1718                         VirtPageDesc *vp;
1719
1720                         vp = virt_page_find_alloc(vaddr >> TARGET_PAGE_BITS, 1);
1721                         vp->phys_addr = pd;
1722                         vp->prot = prot;
1723                         vp->valid_tag = virt_valid_tag;
1724                         prot &= ~PAGE_WRITE;
1725                     }
1726                 }
1727                 map_addr = mmap((void *)vaddr, TARGET_PAGE_SIZE, prot,
1728                                 MAP_SHARED | MAP_FIXED, phys_ram_fd, (pd & TARGET_PAGE_MASK));
1729                 if (map_addr == MAP_FAILED) {
1730                     cpu_abort(env, "mmap failed when mapped physical address 0x%08x to virtual address 0x%08x\n",
1731                               paddr, vaddr);
1732                 }
1733             }
1734         }
1735     }
1736 #endif
1737     return ret;
1738 }
1739
1740 /* called from signal handler: invalidate the code and unprotect the
1741    page. Return TRUE if the fault was succesfully handled. */
1742 int page_unprotect(target_ulong addr, unsigned long pc, void *puc)
1743 {
1744 #if !defined(CONFIG_SOFTMMU)
1745     VirtPageDesc *vp;
1746
1747 #if defined(DEBUG_TLB)
1748     printf("page_unprotect: addr=0x%08x\n", addr);
1749 #endif
1750     addr &= TARGET_PAGE_MASK;
1751
1752     /* if it is not mapped, no need to worry here */
1753     if (addr >= MMAP_AREA_END)
1754         return 0;
1755     vp = virt_page_find(addr >> TARGET_PAGE_BITS);
1756     if (!vp)
1757         return 0;
1758     /* NOTE: in this case, validate_tag is _not_ tested as it
1759        validates only the code TLB */
1760     if (vp->valid_tag != virt_valid_tag)
1761         return 0;
1762     if (!(vp->prot & PAGE_WRITE))
1763         return 0;
1764 #if defined(DEBUG_TLB)
1765     printf("page_unprotect: addr=0x%08x phys_addr=0x%08x prot=%x\n",
1766            addr, vp->phys_addr, vp->prot);
1767 #endif
1768     if (mprotect((void *)addr, TARGET_PAGE_SIZE, vp->prot) < 0)
1769         cpu_abort(cpu_single_env, "error mprotect addr=0x%lx prot=%d\n",
1770                   (unsigned long)addr, vp->prot);
1771     /* set the dirty bit */
1772     phys_ram_dirty[vp->phys_addr >> TARGET_PAGE_BITS] = 0xff;
1773     /* flush the code inside */
1774     tb_invalidate_phys_page(vp->phys_addr, pc, puc);
1775     return 1;
1776 #else
1777     return 0;
1778 #endif
1779 }
1780
1781 #else
1782
1783 void tlb_flush(CPUState *env, int flush_global)
1784 {
1785 }
1786
1787 void tlb_flush_page(CPUState *env, target_ulong addr)
1788 {
1789 }
1790
1791 int tlb_set_page_exec(CPUState *env, target_ulong vaddr,
1792                       target_phys_addr_t paddr, int prot,
1793                       int mmu_idx, int is_softmmu)
1794 {
1795     return 0;
1796 }
1797
1798 /* dump memory mappings */
1799 void page_dump(FILE *f)
1800 {
1801     unsigned long start, end;
1802     int i, j, prot, prot1;
1803     PageDesc *p;
1804
1805     fprintf(f, "%-8s %-8s %-8s %s\n",
1806             "start", "end", "size", "prot");
1807     start = -1;
1808     end = -1;
1809     prot = 0;
1810     for(i = 0; i <= L1_SIZE; i++) {
1811         if (i < L1_SIZE)
1812             p = l1_map[i];
1813         else
1814             p = NULL;
1815         for(j = 0;j < L2_SIZE; j++) {
1816             if (!p)
1817                 prot1 = 0;
1818             else
1819                 prot1 = p[j].flags;
1820             if (prot1 != prot) {
1821                 end = (i << (32 - L1_BITS)) | (j << TARGET_PAGE_BITS);
1822                 if (start != -1) {
1823                     fprintf(f, "%08lx-%08lx %08lx %c%c%c\n",
1824                             start, end, end - start,
1825                             prot & PAGE_READ ? 'r' : '-',
1826                             prot & PAGE_WRITE ? 'w' : '-',
1827                             prot & PAGE_EXEC ? 'x' : '-');
1828                 }
1829                 if (prot1 != 0)
1830                     start = end;
1831                 else
1832                     start = -1;
1833                 prot = prot1;
1834             }
1835             if (!p)
1836                 break;
1837         }
1838     }
1839 }
1840
1841 int page_get_flags(target_ulong address)
1842 {
1843     PageDesc *p;
1844
1845     p = page_find(address >> TARGET_PAGE_BITS);
1846     if (!p)
1847         return 0;
1848     return p->flags;
1849 }
1850
1851 /* modify the flags of a page and invalidate the code if
1852    necessary. The flag PAGE_WRITE_ORG is positionned automatically
1853    depending on PAGE_WRITE */
1854 void page_set_flags(target_ulong start, target_ulong end, int flags)
1855 {
1856     PageDesc *p;
1857     target_ulong addr;
1858
1859     start = start & TARGET_PAGE_MASK;
1860     end = TARGET_PAGE_ALIGN(end);
1861     if (flags & PAGE_WRITE)
1862         flags |= PAGE_WRITE_ORG;
1863     spin_lock(&tb_lock);
1864     for(addr = start; addr < end; addr += TARGET_PAGE_SIZE) {
1865         p = page_find_alloc(addr >> TARGET_PAGE_BITS);
1866         /* if the write protection is set, then we invalidate the code
1867            inside */
1868         if (!(p->flags & PAGE_WRITE) &&
1869             (flags & PAGE_WRITE) &&
1870             p->first_tb) {
1871             tb_invalidate_phys_page(addr, 0, NULL);
1872         }
1873         p->flags = flags;
1874     }
1875     spin_unlock(&tb_lock);
1876 }
1877
1878 int page_check_range(target_ulong start, target_ulong len, int flags)
1879 {
1880     PageDesc *p;
1881     target_ulong end;
1882     target_ulong addr;
1883
1884     end = TARGET_PAGE_ALIGN(start+len); /* must do before we loose bits in the next step */
1885     start = start & TARGET_PAGE_MASK;
1886
1887     if( end < start )
1888         /* we've wrapped around */
1889         return -1;
1890     for(addr = start; addr < end; addr += TARGET_PAGE_SIZE) {
1891         p = page_find(addr >> TARGET_PAGE_BITS);
1892         if( !p )
1893             return -1;
1894         if( !(p->flags & PAGE_VALID) )
1895             return -1;
1896
1897         if (!(p->flags & PAGE_READ) && (flags & PAGE_READ) )
1898             return -1;
1899         if (!(p->flags & PAGE_WRITE) && (flags & PAGE_WRITE) )
1900             return -1;
1901     }
1902     return 0;
1903 }
1904
1905 /* called from signal handler: invalidate the code and unprotect the
1906    page. Return TRUE if the fault was succesfully handled. */
1907 int page_unprotect(target_ulong address, unsigned long pc, void *puc)
1908 {
1909     unsigned int page_index, prot, pindex;
1910     PageDesc *p, *p1;
1911     target_ulong host_start, host_end, addr;
1912
1913     host_start = address & qemu_host_page_mask;
1914     page_index = host_start >> TARGET_PAGE_BITS;
1915     p1 = page_find(page_index);
1916     if (!p1)
1917         return 0;
1918     host_end = host_start + qemu_host_page_size;
1919     p = p1;
1920     prot = 0;
1921     for(addr = host_start;addr < host_end; addr += TARGET_PAGE_SIZE) {
1922         prot |= p->flags;
1923         p++;
1924     }
1925     /* if the page was really writable, then we change its
1926        protection back to writable */
1927     if (prot & PAGE_WRITE_ORG) {
1928         pindex = (address - host_start) >> TARGET_PAGE_BITS;
1929         if (!(p1[pindex].flags & PAGE_WRITE)) {
1930             mprotect((void *)g2h(host_start), qemu_host_page_size,
1931                      (prot & PAGE_BITS) | PAGE_WRITE);
1932             p1[pindex].flags |= PAGE_WRITE;
1933             /* and since the content will be modified, we must invalidate
1934                the corresponding translated code. */
1935             tb_invalidate_phys_page(address, pc, puc);
1936 #ifdef DEBUG_TB_CHECK
1937             tb_invalidate_check(address);
1938 #endif
1939             return 1;
1940         }
1941     }
1942     return 0;
1943 }
1944
1945 /* call this function when system calls directly modify a memory area */
1946 /* ??? This should be redundant now we have lock_user.  */
1947 void page_unprotect_range(target_ulong data, target_ulong data_size)
1948 {
1949     target_ulong start, end, addr;
1950
1951     start = data;
1952     end = start + data_size;
1953     start &= TARGET_PAGE_MASK;
1954     end = TARGET_PAGE_ALIGN(end);
1955     for(addr = start; addr < end; addr += TARGET_PAGE_SIZE) {
1956         page_unprotect(addr, 0, NULL);
1957     }
1958 }
1959
1960 static inline void tlb_set_dirty(CPUState *env,
1961                                  unsigned long addr, target_ulong vaddr)
1962 {
1963 }
1964 #endif /* defined(CONFIG_USER_ONLY) */
1965
1966 static int subpage_register (subpage_t *mmio, uint32_t start, uint32_t end,
1967                              int memory);
1968 static void *subpage_init (target_phys_addr_t base, uint32_t *phys,
1969                            int orig_memory);
1970 #define CHECK_SUBPAGE(addr, start_addr, start_addr2, end_addr, end_addr2, \
1971                       need_subpage)                                     \
1972     do {                                                                \
1973         if (addr > start_addr)                                          \
1974             start_addr2 = 0;                                            \
1975         else {                                                          \
1976             start_addr2 = start_addr & ~TARGET_PAGE_MASK;               \
1977             if (start_addr2 > 0)                                        \
1978                 need_subpage = 1;                                       \
1979         }                                                               \
1980                                                                         \
1981         if ((start_addr + orig_size) - addr >= TARGET_PAGE_SIZE)        \
1982             end_addr2 = TARGET_PAGE_SIZE - 1;                           \
1983         else {                                                          \
1984             end_addr2 = (start_addr + orig_size - 1) & ~TARGET_PAGE_MASK; \
1985             if (end_addr2 < TARGET_PAGE_SIZE - 1)                       \
1986                 need_subpage = 1;                                       \
1987         }                                                               \
1988     } while (0)
1989
1990 /* register physical memory. 'size' must be a multiple of the target
1991    page size. If (phys_offset & ~TARGET_PAGE_MASK) != 0, then it is an
1992    io memory page */
1993 void cpu_register_physical_memory(target_phys_addr_t start_addr,
1994                                   unsigned long size,
1995                                   unsigned long phys_offset)
1996 {
1997     target_phys_addr_t addr, end_addr;
1998     PhysPageDesc *p;
1999     CPUState *env;
2000     unsigned long orig_size = size;
2001     void *subpage;
2002
2003     size = (size + TARGET_PAGE_SIZE - 1) & TARGET_PAGE_MASK;
2004     end_addr = start_addr + (target_phys_addr_t)size;
2005     for(addr = start_addr; addr != end_addr; addr += TARGET_PAGE_SIZE) {
2006         p = phys_page_find(addr >> TARGET_PAGE_BITS);
2007         if (p && p->phys_offset != IO_MEM_UNASSIGNED) {
2008             unsigned long orig_memory = p->phys_offset;
2009             target_phys_addr_t start_addr2, end_addr2;
2010             int need_subpage = 0;
2011
2012             CHECK_SUBPAGE(addr, start_addr, start_addr2, end_addr, end_addr2,
2013                           need_subpage);
2014             if (need_subpage) {
2015                 if (!(orig_memory & IO_MEM_SUBPAGE)) {
2016                     subpage = subpage_init((addr & TARGET_PAGE_MASK),
2017                                            &p->phys_offset, orig_memory);
2018                 } else {
2019                     subpage = io_mem_opaque[(orig_memory & ~TARGET_PAGE_MASK)
2020                                             >> IO_MEM_SHIFT];
2021                 }
2022                 subpage_register(subpage, start_addr2, end_addr2, phys_offset);
2023             } else {
2024                 p->phys_offset = phys_offset;
2025                 if ((phys_offset & ~TARGET_PAGE_MASK) <= IO_MEM_ROM ||
2026                     (phys_offset & IO_MEM_ROMD))
2027                     phys_offset += TARGET_PAGE_SIZE;
2028             }
2029         } else {
2030             p = phys_page_find_alloc(addr >> TARGET_PAGE_BITS, 1);
2031             p->phys_offset = phys_offset;
2032             if ((phys_offset & ~TARGET_PAGE_MASK) <= IO_MEM_ROM ||
2033                 (phys_offset & IO_MEM_ROMD))
2034                 phys_offset += TARGET_PAGE_SIZE;
2035             else {
2036                 target_phys_addr_t start_addr2, end_addr2;
2037                 int need_subpage = 0;
2038
2039                 CHECK_SUBPAGE(addr, start_addr, start_addr2, end_addr,
2040                               end_addr2, need_subpage);
2041
2042                 if (need_subpage) {
2043                     subpage = subpage_init((addr & TARGET_PAGE_MASK),
2044                                            &p->phys_offset, IO_MEM_UNASSIGNED);
2045                     subpage_register(subpage, start_addr2, end_addr2,
2046                                      phys_offset);
2047                 }
2048             }
2049         }
2050     }
2051
2052     /* since each CPU stores ram addresses in its TLB cache, we must
2053        reset the modified entries */
2054     /* XXX: slow ! */
2055     for(env = first_cpu; env != NULL; env = env->next_cpu) {
2056         tlb_flush(env, 1);
2057     }
2058 }
2059
2060 /* XXX: temporary until new memory mapping API */
2061 uint32_t cpu_get_physical_page_desc(target_phys_addr_t addr)
2062 {
2063     PhysPageDesc *p;
2064
2065     p = phys_page_find(addr >> TARGET_PAGE_BITS);
2066     if (!p)
2067         return IO_MEM_UNASSIGNED;
2068     return p->phys_offset;
2069 }
2070
2071 /* XXX: better than nothing */
2072 ram_addr_t qemu_ram_alloc(unsigned int size)
2073 {
2074     ram_addr_t addr;
2075     if ((phys_ram_alloc_offset + size) >= phys_ram_size) {
2076         fprintf(stderr, "Not enough memory (requested_size = %u, max memory = %d)\n",
2077                 size, phys_ram_size);
2078         abort();
2079     }
2080     addr = phys_ram_alloc_offset;
2081     phys_ram_alloc_offset = TARGET_PAGE_ALIGN(phys_ram_alloc_offset + size);
2082     return addr;
2083 }
2084
2085 void qemu_ram_free(ram_addr_t addr)
2086 {
2087 }
2088
2089 static uint32_t unassigned_mem_readb(void *opaque, target_phys_addr_t addr)
2090 {
2091 #ifdef DEBUG_UNASSIGNED
2092     printf("Unassigned mem read " TARGET_FMT_lx "\n", addr);
2093 #endif
2094 #ifdef TARGET_SPARC
2095     do_unassigned_access(addr, 0, 0, 0);
2096 #elif TARGET_CRIS
2097     do_unassigned_access(addr, 0, 0, 0);
2098 #endif
2099     return 0;
2100 }
2101
2102 static void unassigned_mem_writeb(void *opaque, target_phys_addr_t addr, uint32_t val)
2103 {
2104 #ifdef DEBUG_UNASSIGNED
2105     printf("Unassigned mem write " TARGET_FMT_lx " = 0x%x\n", addr, val);
2106 #endif
2107 #ifdef TARGET_SPARC
2108     do_unassigned_access(addr, 1, 0, 0);
2109 #elif TARGET_CRIS
2110     do_unassigned_access(addr, 1, 0, 0);
2111 #endif
2112 }
2113
2114 static CPUReadMemoryFunc *unassigned_mem_read[3] = {
2115     unassigned_mem_readb,
2116     unassigned_mem_readb,
2117     unassigned_mem_readb,
2118 };
2119
2120 static CPUWriteMemoryFunc *unassigned_mem_write[3] = {
2121     unassigned_mem_writeb,
2122     unassigned_mem_writeb,
2123     unassigned_mem_writeb,
2124 };
2125
2126 static void notdirty_mem_writeb(void *opaque, target_phys_addr_t addr, uint32_t val)
2127 {
2128     unsigned long ram_addr;
2129     int dirty_flags;
2130     ram_addr = addr - (unsigned long)phys_ram_base;
2131     dirty_flags = phys_ram_dirty[ram_addr >> TARGET_PAGE_BITS];
2132     if (!(dirty_flags & CODE_DIRTY_FLAG)) {
2133 #if !defined(CONFIG_USER_ONLY)
2134         tb_invalidate_phys_page_fast(ram_addr, 1);
2135         dirty_flags = phys_ram_dirty[ram_addr >> TARGET_PAGE_BITS];
2136 #endif
2137     }
2138     stb_p((uint8_t *)(long)addr, val);
2139 #ifdef USE_KQEMU
2140     if (cpu_single_env->kqemu_enabled &&
2141         (dirty_flags & KQEMU_MODIFY_PAGE_MASK) != KQEMU_MODIFY_PAGE_MASK)
2142         kqemu_modify_page(cpu_single_env, ram_addr);
2143 #endif
2144     dirty_flags |= (0xff & ~CODE_DIRTY_FLAG);
2145     phys_ram_dirty[ram_addr >> TARGET_PAGE_BITS] = dirty_flags;
2146     /* we remove the notdirty callback only if the code has been
2147        flushed */
2148     if (dirty_flags == 0xff)
2149         tlb_set_dirty(cpu_single_env, addr, cpu_single_env->mem_write_vaddr);
2150 }
2151
2152 static void notdirty_mem_writew(void *opaque, target_phys_addr_t addr, uint32_t val)
2153 {
2154     unsigned long ram_addr;
2155     int dirty_flags;
2156     ram_addr = addr - (unsigned long)phys_ram_base;
2157     dirty_flags = phys_ram_dirty[ram_addr >> TARGET_PAGE_BITS];
2158     if (!(dirty_flags & CODE_DIRTY_FLAG)) {
2159 #if !defined(CONFIG_USER_ONLY)
2160         tb_invalidate_phys_page_fast(ram_addr, 2);
2161         dirty_flags = phys_ram_dirty[ram_addr >> TARGET_PAGE_BITS];
2162 #endif
2163     }
2164     stw_p((uint8_t *)(long)addr, val);
2165 #ifdef USE_KQEMU
2166     if (cpu_single_env->kqemu_enabled &&
2167         (dirty_flags & KQEMU_MODIFY_PAGE_MASK) != KQEMU_MODIFY_PAGE_MASK)
2168         kqemu_modify_page(cpu_single_env, ram_addr);
2169 #endif
2170     dirty_flags |= (0xff & ~CODE_DIRTY_FLAG);
2171     phys_ram_dirty[ram_addr >> TARGET_PAGE_BITS] = dirty_flags;
2172     /* we remove the notdirty callback only if the code has been
2173        flushed */
2174     if (dirty_flags == 0xff)
2175         tlb_set_dirty(cpu_single_env, addr, cpu_single_env->mem_write_vaddr);
2176 }
2177
2178 static void notdirty_mem_writel(void *opaque, target_phys_addr_t addr, uint32_t val)
2179 {
2180     unsigned long ram_addr;
2181     int dirty_flags;
2182     ram_addr = addr - (unsigned long)phys_ram_base;
2183     dirty_flags = phys_ram_dirty[ram_addr >> TARGET_PAGE_BITS];
2184     if (!(dirty_flags & CODE_DIRTY_FLAG)) {
2185 #if !defined(CONFIG_USER_ONLY)
2186         tb_invalidate_phys_page_fast(ram_addr, 4);
2187         dirty_flags = phys_ram_dirty[ram_addr >> TARGET_PAGE_BITS];
2188 #endif
2189     }
2190     stl_p((uint8_t *)(long)addr, val);
2191 #ifdef USE_KQEMU
2192     if (cpu_single_env->kqemu_enabled &&
2193         (dirty_flags & KQEMU_MODIFY_PAGE_MASK) != KQEMU_MODIFY_PAGE_MASK)
2194         kqemu_modify_page(cpu_single_env, ram_addr);
2195 #endif
2196     dirty_flags |= (0xff & ~CODE_DIRTY_FLAG);
2197     phys_ram_dirty[ram_addr >> TARGET_PAGE_BITS] = dirty_flags;
2198     /* we remove the notdirty callback only if the code has been
2199        flushed */
2200     if (dirty_flags == 0xff)
2201         tlb_set_dirty(cpu_single_env, addr, cpu_single_env->mem_write_vaddr);
2202 }
2203
2204 static CPUReadMemoryFunc *error_mem_read[3] = {
2205     NULL, /* never used */
2206     NULL, /* never used */
2207     NULL, /* never used */
2208 };
2209
2210 static CPUWriteMemoryFunc *notdirty_mem_write[3] = {
2211     notdirty_mem_writeb,
2212     notdirty_mem_writew,
2213     notdirty_mem_writel,
2214 };
2215
2216 #if defined(CONFIG_SOFTMMU)
2217 /* Watchpoint access routines.  Watchpoints are inserted using TLB tricks,
2218    so these check for a hit then pass through to the normal out-of-line
2219    phys routines.  */
2220 static uint32_t watch_mem_readb(void *opaque, target_phys_addr_t addr)
2221 {
2222     return ldub_phys(addr);
2223 }
2224
2225 static uint32_t watch_mem_readw(void *opaque, target_phys_addr_t addr)
2226 {
2227     return lduw_phys(addr);
2228 }
2229
2230 static uint32_t watch_mem_readl(void *opaque, target_phys_addr_t addr)
2231 {
2232     return ldl_phys(addr);
2233 }
2234
2235 /* Generate a debug exception if a watchpoint has been hit.
2236    Returns the real physical address of the access.  addr will be a host
2237    address in case of a RAM location.  */
2238 static target_ulong check_watchpoint(target_phys_addr_t addr)
2239 {
2240     CPUState *env = cpu_single_env;
2241     target_ulong watch;
2242     target_ulong retaddr;
2243     int i;
2244
2245     retaddr = addr;
2246     for (i = 0; i < env->nb_watchpoints; i++) {
2247         watch = env->watchpoint[i].vaddr;
2248         if (((env->mem_write_vaddr ^ watch) & TARGET_PAGE_MASK) == 0) {
2249             retaddr = addr - env->watchpoint[i].addend;
2250             if (((addr ^ watch) & ~TARGET_PAGE_MASK) == 0) {
2251                 cpu_single_env->watchpoint_hit = i + 1;
2252                 cpu_interrupt(cpu_single_env, CPU_INTERRUPT_DEBUG);
2253                 break;
2254             }
2255         }
2256     }
2257     return retaddr;
2258 }
2259
2260 static void watch_mem_writeb(void *opaque, target_phys_addr_t addr,
2261                              uint32_t val)
2262 {
2263     addr = check_watchpoint(addr);
2264     stb_phys(addr, val);
2265 }
2266
2267 static void watch_mem_writew(void *opaque, target_phys_addr_t addr,
2268                              uint32_t val)
2269 {
2270     addr = check_watchpoint(addr);
2271     stw_phys(addr, val);
2272 }
2273
2274 static void watch_mem_writel(void *opaque, target_phys_addr_t addr,
2275                              uint32_t val)
2276 {
2277     addr = check_watchpoint(addr);
2278     stl_phys(addr, val);
2279 }
2280
2281 static CPUReadMemoryFunc *watch_mem_read[3] = {
2282     watch_mem_readb,
2283     watch_mem_readw,
2284     watch_mem_readl,
2285 };
2286
2287 static CPUWriteMemoryFunc *watch_mem_write[3] = {
2288     watch_mem_writeb,
2289     watch_mem_writew,
2290     watch_mem_writel,
2291 };
2292 #endif
2293
2294 static inline uint32_t subpage_readlen (subpage_t *mmio, target_phys_addr_t addr,
2295                                  unsigned int len)
2296 {
2297     CPUReadMemoryFunc **mem_read;
2298     uint32_t ret;
2299     unsigned int idx;
2300
2301     idx = SUBPAGE_IDX(addr - mmio->base);
2302 #if defined(DEBUG_SUBPAGE)
2303     printf("%s: subpage %p len %d addr " TARGET_FMT_plx " idx %d\n", __func__,
2304            mmio, len, addr, idx);
2305 #endif
2306     mem_read = mmio->mem_read[idx];
2307     ret = (*mem_read[len])(mmio->opaque[idx], addr);
2308
2309     return ret;
2310 }
2311
2312 static inline void subpage_writelen (subpage_t *mmio, target_phys_addr_t addr,
2313                               uint32_t value, unsigned int len)
2314 {
2315     CPUWriteMemoryFunc **mem_write;
2316     unsigned int idx;
2317
2318     idx = SUBPAGE_IDX(addr - mmio->base);
2319 #if defined(DEBUG_SUBPAGE)
2320     printf("%s: subpage %p len %d addr " TARGET_FMT_plx " idx %d value %08x\n", __func__,
2321            mmio, len, addr, idx, value);
2322 #endif
2323     mem_write = mmio->mem_write[idx];
2324     (*mem_write[len])(mmio->opaque[idx], addr, value);
2325 }
2326
2327 static uint32_t subpage_readb (void *opaque, target_phys_addr_t addr)
2328 {
2329 #if defined(DEBUG_SUBPAGE)
2330     printf("%s: addr " TARGET_FMT_plx "\n", __func__, addr);
2331 #endif
2332
2333     return subpage_readlen(opaque, addr, 0);
2334 }
2335
2336 static void subpage_writeb (void *opaque, target_phys_addr_t addr,
2337                             uint32_t value)
2338 {
2339 #if defined(DEBUG_SUBPAGE)
2340     printf("%s: addr " TARGET_FMT_plx " val %08x\n", __func__, addr, value);
2341 #endif
2342     subpage_writelen(opaque, addr, value, 0);
2343 }
2344
2345 static uint32_t subpage_readw (void *opaque, target_phys_addr_t addr)
2346 {
2347 #if defined(DEBUG_SUBPAGE)
2348     printf("%s: addr " TARGET_FMT_plx "\n", __func__, addr);
2349 #endif
2350
2351     return subpage_readlen(opaque, addr, 1);
2352 }
2353
2354 static void subpage_writew (void *opaque, target_phys_addr_t addr,
2355                             uint32_t value)
2356 {
2357 #if defined(DEBUG_SUBPAGE)
2358     printf("%s: addr " TARGET_FMT_plx " val %08x\n", __func__, addr, value);
2359 #endif
2360     subpage_writelen(opaque, addr, value, 1);
2361 }
2362
2363 static uint32_t subpage_readl (void *opaque, target_phys_addr_t addr)
2364 {
2365 #if defined(DEBUG_SUBPAGE)
2366     printf("%s: addr " TARGET_FMT_plx "\n", __func__, addr);
2367 #endif
2368
2369     return subpage_readlen(opaque, addr, 2);
2370 }
2371
2372 static void subpage_writel (void *opaque,
2373                          target_phys_addr_t addr, uint32_t value)
2374 {
2375 #if defined(DEBUG_SUBPAGE)
2376     printf("%s: addr " TARGET_FMT_plx " val %08x\n", __func__, addr, value);
2377 #endif
2378     subpage_writelen(opaque, addr, value, 2);
2379 }
2380
2381 static CPUReadMemoryFunc *subpage_read[] = {
2382     &subpage_readb,
2383     &subpage_readw,
2384     &subpage_readl,
2385 };
2386
2387 static CPUWriteMemoryFunc *subpage_write[] = {
2388     &subpage_writeb,
2389     &subpage_writew,
2390     &subpage_writel,
2391 };
2392
2393 static int subpage_register (subpage_t *mmio, uint32_t start, uint32_t end,
2394                              int memory)
2395 {
2396     int idx, eidx;
2397
2398     if (start >= TARGET_PAGE_SIZE || end >= TARGET_PAGE_SIZE)
2399         return -1;
2400     idx = SUBPAGE_IDX(start);
2401     eidx = SUBPAGE_IDX(end);
2402 #if defined(DEBUG_SUBPAGE)
2403     printf("%s: %p start %08x end %08x idx %08x eidx %08x mem %d\n", __func__,
2404            mmio, start, end, idx, eidx, memory);
2405 #endif
2406     memory >>= IO_MEM_SHIFT;
2407     for (; idx <= eidx; idx++) {
2408         mmio->mem_read[idx] = io_mem_read[memory];
2409         mmio->mem_write[idx] = io_mem_write[memory];
2410         mmio->opaque[idx] = io_mem_opaque[memory];
2411     }
2412
2413     return 0;
2414 }
2415
2416 static void *subpage_init (target_phys_addr_t base, uint32_t *phys,
2417                            int orig_memory)
2418 {
2419     subpage_t *mmio;
2420     int subpage_memory;
2421
2422     mmio = qemu_mallocz(sizeof(subpage_t));
2423     if (mmio != NULL) {
2424         mmio->base = base;
2425         subpage_memory = cpu_register_io_memory(0, subpage_read, subpage_write, mmio);
2426 #if defined(DEBUG_SUBPAGE)
2427         printf("%s: %p base " TARGET_FMT_plx " len %08x %d\n", __func__,
2428                mmio, base, TARGET_PAGE_SIZE, subpage_memory);
2429 #endif
2430         *phys = subpage_memory | IO_MEM_SUBPAGE;
2431         subpage_register(mmio, 0, TARGET_PAGE_SIZE - 1, orig_memory);
2432     }
2433
2434     return mmio;
2435 }
2436
2437 static void io_mem_init(void)
2438 {
2439     cpu_register_io_memory(IO_MEM_ROM >> IO_MEM_SHIFT, error_mem_read, unassigned_mem_write, NULL);
2440     cpu_register_io_memory(IO_MEM_UNASSIGNED >> IO_MEM_SHIFT, unassigned_mem_read, unassigned_mem_write, NULL);
2441     cpu_register_io_memory(IO_MEM_NOTDIRTY >> IO_MEM_SHIFT, error_mem_read, notdirty_mem_write, NULL);
2442     io_mem_nb = 5;
2443
2444 #if defined(CONFIG_SOFTMMU)
2445     io_mem_watch = cpu_register_io_memory(-1, watch_mem_read,
2446                                           watch_mem_write, NULL);
2447 #endif
2448     /* alloc dirty bits array */
2449     phys_ram_dirty = qemu_vmalloc(phys_ram_size >> TARGET_PAGE_BITS);
2450     memset(phys_ram_dirty, 0xff, phys_ram_size >> TARGET_PAGE_BITS);
2451 }
2452
2453 /* mem_read and mem_write are arrays of functions containing the
2454    function to access byte (index 0), word (index 1) and dword (index
2455    2). All functions must be supplied. If io_index is non zero, the
2456    corresponding io zone is modified. If it is zero, a new io zone is
2457    allocated. The return value can be used with
2458    cpu_register_physical_memory(). (-1) is returned if error. */
2459 int cpu_register_io_memory(int io_index,
2460                            CPUReadMemoryFunc **mem_read,
2461                            CPUWriteMemoryFunc **mem_write,
2462                            void *opaque)
2463 {
2464     int i;
2465
2466     if (io_index <= 0) {
2467         if (io_mem_nb >= IO_MEM_NB_ENTRIES)
2468             return -1;
2469         io_index = io_mem_nb++;
2470     } else {
2471         if (io_index >= IO_MEM_NB_ENTRIES)
2472             return -1;
2473     }
2474
2475     for(i = 0;i < 3; i++) {
2476         io_mem_read[io_index][i] = mem_read[i];
2477         io_mem_write[io_index][i] = mem_write[i];
2478     }
2479     io_mem_opaque[io_index] = opaque;
2480     return io_index << IO_MEM_SHIFT;
2481 }
2482
2483 CPUWriteMemoryFunc **cpu_get_io_memory_write(int io_index)
2484 {
2485     return io_mem_write[io_index >> IO_MEM_SHIFT];
2486 }
2487
2488 CPUReadMemoryFunc **cpu_get_io_memory_read(int io_index)
2489 {
2490     return io_mem_read[io_index >> IO_MEM_SHIFT];
2491 }
2492
2493 /* physical memory access (slow version, mainly for debug) */
2494 #if defined(CONFIG_USER_ONLY)
2495 void cpu_physical_memory_rw(target_phys_addr_t addr, uint8_t *buf,
2496                             int len, int is_write)
2497 {
2498     int l, flags;
2499     target_ulong page;
2500     void * p;
2501
2502     while (len > 0) {
2503         page = addr & TARGET_PAGE_MASK;
2504         l = (page + TARGET_PAGE_SIZE) - addr;
2505         if (l > len)
2506             l = len;
2507         flags = page_get_flags(page);
2508         if (!(flags & PAGE_VALID))
2509             return;
2510         if (is_write) {
2511             if (!(flags & PAGE_WRITE))
2512                 return;
2513             p = lock_user(addr, len, 0);
2514             memcpy(p, buf, len);
2515             unlock_user(p, addr, len);
2516         } else {
2517             if (!(flags & PAGE_READ))
2518                 return;
2519             p = lock_user(addr, len, 1);
2520             memcpy(buf, p, len);
2521             unlock_user(p, addr, 0);
2522         }
2523         len -= l;
2524         buf += l;
2525         addr += l;
2526     }
2527 }
2528
2529 #else
2530 void cpu_physical_memory_rw(target_phys_addr_t addr, uint8_t *buf,
2531                             int len, int is_write)
2532 {
2533     int l, io_index;
2534     uint8_t *ptr;
2535     uint32_t val;
2536     target_phys_addr_t page;
2537     unsigned long pd;
2538     PhysPageDesc *p;
2539
2540     while (len > 0) {
2541         page = addr & TARGET_PAGE_MASK;
2542         l = (page + TARGET_PAGE_SIZE) - addr;
2543         if (l > len)
2544             l = len;
2545         p = phys_page_find(page >> TARGET_PAGE_BITS);
2546         if (!p) {
2547             pd = IO_MEM_UNASSIGNED;
2548         } else {
2549             pd = p->phys_offset;
2550         }
2551
2552         if (is_write) {
2553             if ((pd & ~TARGET_PAGE_MASK) != IO_MEM_RAM) {
2554                 io_index = (pd >> IO_MEM_SHIFT) & (IO_MEM_NB_ENTRIES - 1);
2555                 /* XXX: could force cpu_single_env to NULL to avoid
2556                    potential bugs */
2557                 if (l >= 4 && ((addr & 3) == 0)) {
2558                     /* 32 bit write access */
2559                     val = ldl_p(buf);
2560                     io_mem_write[io_index][2](io_mem_opaque[io_index], addr, val);
2561                     l = 4;
2562                 } else if (l >= 2 && ((addr & 1) == 0)) {
2563                     /* 16 bit write access */
2564                     val = lduw_p(buf);
2565                     io_mem_write[io_index][1](io_mem_opaque[io_index], addr, val);
2566                     l = 2;
2567                 } else {
2568                     /* 8 bit write access */
2569                     val = ldub_p(buf);
2570                     io_mem_write[io_index][0](io_mem_opaque[io_index], addr, val);
2571                     l = 1;
2572                 }
2573             } else {
2574                 unsigned long addr1;
2575                 addr1 = (pd & TARGET_PAGE_MASK) + (addr & ~TARGET_PAGE_MASK);
2576                 /* RAM case */
2577                 ptr = phys_ram_base + addr1;
2578                 memcpy(ptr, buf, l);
2579                 if (!cpu_physical_memory_is_dirty(addr1)) {
2580                     /* invalidate code */
2581                     tb_invalidate_phys_page_range(addr1, addr1 + l, 0);
2582                     /* set dirty bit */
2583                     phys_ram_dirty[addr1 >> TARGET_PAGE_BITS] |=
2584                         (0xff & ~CODE_DIRTY_FLAG);
2585                 }
2586             }
2587         } else {
2588             if ((pd & ~TARGET_PAGE_MASK) > IO_MEM_ROM &&
2589                 !(pd & IO_MEM_ROMD)) {
2590                 /* I/O case */
2591                 io_index = (pd >> IO_MEM_SHIFT) & (IO_MEM_NB_ENTRIES - 1);
2592                 if (l >= 4 && ((addr & 3) == 0)) {
2593                     /* 32 bit read access */
2594                     val = io_mem_read[io_index][2](io_mem_opaque[io_index], addr);
2595                     stl_p(buf, val);
2596                     l = 4;
2597                 } else if (l >= 2 && ((addr & 1) == 0)) {
2598                     /* 16 bit read access */
2599                     val = io_mem_read[io_index][1](io_mem_opaque[io_index], addr);
2600                     stw_p(buf, val);
2601                     l = 2;
2602                 } else {
2603                     /* 8 bit read access */
2604                     val = io_mem_read[io_index][0](io_mem_opaque[io_index], addr);
2605                     stb_p(buf, val);
2606                     l = 1;
2607                 }
2608             } else {
2609                 /* RAM case */
2610                 ptr = phys_ram_base + (pd & TARGET_PAGE_MASK) +
2611                     (addr & ~TARGET_PAGE_MASK);
2612                 memcpy(buf, ptr, l);
2613             }
2614         }
2615         len -= l;
2616         buf += l;
2617         addr += l;
2618     }
2619 }
2620
2621 /* used for ROM loading : can write in RAM and ROM */
2622 void cpu_physical_memory_write_rom(target_phys_addr_t addr,
2623                                    const uint8_t *buf, int len)
2624 {
2625     int l;
2626     uint8_t *ptr;
2627     target_phys_addr_t page;
2628     unsigned long pd;
2629     PhysPageDesc *p;
2630
2631     while (len > 0) {
2632         page = addr & TARGET_PAGE_MASK;
2633         l = (page + TARGET_PAGE_SIZE) - addr;
2634         if (l > len)
2635             l = len;
2636         p = phys_page_find(page >> TARGET_PAGE_BITS);
2637         if (!p) {
2638             pd = IO_MEM_UNASSIGNED;
2639         } else {
2640             pd = p->phys_offset;
2641         }
2642
2643         if ((pd & ~TARGET_PAGE_MASK) != IO_MEM_RAM &&
2644             (pd & ~TARGET_PAGE_MASK) != IO_MEM_ROM &&
2645             !(pd & IO_MEM_ROMD)) {
2646             /* do nothing */
2647         } else {
2648             unsigned long addr1;
2649             addr1 = (pd & TARGET_PAGE_MASK) + (addr & ~TARGET_PAGE_MASK);
2650             /* ROM/RAM case */
2651             ptr = phys_ram_base + addr1;
2652             memcpy(ptr, buf, l);
2653         }
2654         len -= l;
2655         buf += l;
2656         addr += l;
2657     }
2658 }
2659
2660
2661 /* warning: addr must be aligned */
2662 uint32_t ldl_phys(target_phys_addr_t addr)
2663 {
2664     int io_index;
2665     uint8_t *ptr;
2666     uint32_t val;
2667     unsigned long pd;
2668     PhysPageDesc *p;
2669
2670     p = phys_page_find(addr >> TARGET_PAGE_BITS);
2671     if (!p) {
2672         pd = IO_MEM_UNASSIGNED;
2673     } else {
2674         pd = p->phys_offset;
2675     }
2676
2677     if ((pd & ~TARGET_PAGE_MASK) > IO_MEM_ROM &&
2678         !(pd & IO_MEM_ROMD)) {
2679         /* I/O case */
2680         io_index = (pd >> IO_MEM_SHIFT) & (IO_MEM_NB_ENTRIES - 1);
2681         val = io_mem_read[io_index][2](io_mem_opaque[io_index], addr);
2682     } else {
2683         /* RAM case */
2684         ptr = phys_ram_base + (pd & TARGET_PAGE_MASK) +
2685             (addr & ~TARGET_PAGE_MASK);
2686         val = ldl_p(ptr);
2687     }
2688     return val;
2689 }
2690
2691 /* warning: addr must be aligned */
2692 uint64_t ldq_phys(target_phys_addr_t addr)
2693 {
2694     int io_index;
2695     uint8_t *ptr;
2696     uint64_t val;
2697     unsigned long pd;
2698     PhysPageDesc *p;
2699
2700     p = phys_page_find(addr >> TARGET_PAGE_BITS);
2701     if (!p) {
2702         pd = IO_MEM_UNASSIGNED;
2703     } else {
2704         pd = p->phys_offset;
2705     }
2706
2707     if ((pd & ~TARGET_PAGE_MASK) > IO_MEM_ROM &&
2708         !(pd & IO_MEM_ROMD)) {
2709         /* I/O case */
2710         io_index = (pd >> IO_MEM_SHIFT) & (IO_MEM_NB_ENTRIES - 1);
2711 #ifdef TARGET_WORDS_BIGENDIAN
2712         val = (uint64_t)io_mem_read[io_index][2](io_mem_opaque[io_index], addr) << 32;
2713         val |= io_mem_read[io_index][2](io_mem_opaque[io_index], addr + 4);
2714 #else
2715         val = io_mem_read[io_index][2](io_mem_opaque[io_index], addr);
2716         val |= (uint64_t)io_mem_read[io_index][2](io_mem_opaque[io_index], addr + 4) << 32;
2717 #endif
2718     } else {
2719         /* RAM case */
2720         ptr = phys_ram_base + (pd & TARGET_PAGE_MASK) +
2721             (addr & ~TARGET_PAGE_MASK);
2722         val = ldq_p(ptr);
2723     }
2724     return val;
2725 }
2726
2727 /* XXX: optimize */
2728 uint32_t ldub_phys(target_phys_addr_t addr)
2729 {
2730     uint8_t val;
2731     cpu_physical_memory_read(addr, &val, 1);
2732     return val;
2733 }
2734
2735 /* XXX: optimize */
2736 uint32_t lduw_phys(target_phys_addr_t addr)
2737 {
2738     uint16_t val;
2739     cpu_physical_memory_read(addr, (uint8_t *)&val, 2);
2740     return tswap16(val);
2741 }
2742
2743 /* warning: addr must be aligned. The ram page is not masked as dirty
2744    and the code inside is not invalidated. It is useful if the dirty
2745    bits are used to track modified PTEs */
2746 void stl_phys_notdirty(target_phys_addr_t addr, uint32_t val)
2747 {
2748     int io_index;
2749     uint8_t *ptr;
2750     unsigned long pd;
2751     PhysPageDesc *p;
2752
2753     p = phys_page_find(addr >> TARGET_PAGE_BITS);
2754     if (!p) {
2755         pd = IO_MEM_UNASSIGNED;
2756     } else {
2757         pd = p->phys_offset;
2758     }
2759
2760     if ((pd & ~TARGET_PAGE_MASK) != IO_MEM_RAM) {
2761         io_index = (pd >> IO_MEM_SHIFT) & (IO_MEM_NB_ENTRIES - 1);
2762         io_mem_write[io_index][2](io_mem_opaque[io_index], addr, val);
2763     } else {
2764         ptr = phys_ram_base + (pd & TARGET_PAGE_MASK) +
2765             (addr & ~TARGET_PAGE_MASK);
2766         stl_p(ptr, val);
2767     }
2768 }
2769
2770 void stq_phys_notdirty(target_phys_addr_t addr, uint64_t val)
2771 {
2772     int io_index;
2773     uint8_t *ptr;
2774     unsigned long pd;
2775     PhysPageDesc *p;
2776
2777     p = phys_page_find(addr >> TARGET_PAGE_BITS);
2778     if (!p) {
2779         pd = IO_MEM_UNASSIGNED;
2780     } else {
2781         pd = p->phys_offset;
2782     }
2783
2784     if ((pd & ~TARGET_PAGE_MASK) != IO_MEM_RAM) {
2785         io_index = (pd >> IO_MEM_SHIFT) & (IO_MEM_NB_ENTRIES - 1);
2786 #ifdef TARGET_WORDS_BIGENDIAN
2787         io_mem_write[io_index][2](io_mem_opaque[io_index], addr, val >> 32);
2788         io_mem_write[io_index][2](io_mem_opaque[io_index], addr + 4, val);
2789 #else
2790         io_mem_write[io_index][2](io_mem_opaque[io_index], addr, val);
2791         io_mem_write[io_index][2](io_mem_opaque[io_index], addr + 4, val >> 32);
2792 #endif
2793     } else {
2794         ptr = phys_ram_base + (pd & TARGET_PAGE_MASK) +
2795             (addr & ~TARGET_PAGE_MASK);
2796         stq_p(ptr, val);
2797     }
2798 }
2799
2800 /* warning: addr must be aligned */
2801 void stl_phys(target_phys_addr_t addr, uint32_t val)
2802 {
2803     int io_index;
2804     uint8_t *ptr;
2805     unsigned long pd;
2806     PhysPageDesc *p;
2807
2808     p = phys_page_find(addr >> TARGET_PAGE_BITS);
2809     if (!p) {
2810         pd = IO_MEM_UNASSIGNED;
2811     } else {
2812         pd = p->phys_offset;
2813     }
2814
2815     if ((pd & ~TARGET_PAGE_MASK) != IO_MEM_RAM) {
2816         io_index = (pd >> IO_MEM_SHIFT) & (IO_MEM_NB_ENTRIES - 1);
2817         io_mem_write[io_index][2](io_mem_opaque[io_index], addr, val);
2818     } else {
2819         unsigned long addr1;
2820         addr1 = (pd & TARGET_PAGE_MASK) + (addr & ~TARGET_PAGE_MASK);
2821         /* RAM case */
2822         ptr = phys_ram_base + addr1;
2823         stl_p(ptr, val);
2824         if (!cpu_physical_memory_is_dirty(addr1)) {
2825             /* invalidate code */
2826             tb_invalidate_phys_page_range(addr1, addr1 + 4, 0);
2827             /* set dirty bit */
2828             phys_ram_dirty[addr1 >> TARGET_PAGE_BITS] |=
2829                 (0xff & ~CODE_DIRTY_FLAG);
2830         }
2831     }
2832 }
2833
2834 /* XXX: optimize */
2835 void stb_phys(target_phys_addr_t addr, uint32_t val)
2836 {
2837     uint8_t v = val;
2838     cpu_physical_memory_write(addr, &v, 1);
2839 }
2840
2841 /* XXX: optimize */
2842 void stw_phys(target_phys_addr_t addr, uint32_t val)
2843 {
2844     uint16_t v = tswap16(val);
2845     cpu_physical_memory_write(addr, (const uint8_t *)&v, 2);
2846 }
2847
2848 /* XXX: optimize */
2849 void stq_phys(target_phys_addr_t addr, uint64_t val)
2850 {
2851     val = tswap64(val);
2852     cpu_physical_memory_write(addr, (const uint8_t *)&val, 8);
2853 }
2854
2855 #endif
2856
2857 /* virtual memory access for debug */
2858 int cpu_memory_rw_debug(CPUState *env, target_ulong addr,
2859                         uint8_t *buf, int len, int is_write)
2860 {
2861     int l;
2862     target_phys_addr_t phys_addr;
2863     target_ulong page;
2864
2865     while (len > 0) {
2866         page = addr & TARGET_PAGE_MASK;
2867         phys_addr = cpu_get_phys_page_debug(env, page);
2868         /* if no physical page mapped, return an error */
2869         if (phys_addr == -1)
2870             return -1;
2871         l = (page + TARGET_PAGE_SIZE) - addr;
2872         if (l > len)
2873             l = len;
2874         cpu_physical_memory_rw(phys_addr + (addr & ~TARGET_PAGE_MASK),
2875                                buf, l, is_write);
2876         len -= l;
2877         buf += l;
2878         addr += l;
2879     }
2880     return 0;
2881 }
2882
2883 void dump_exec_info(FILE *f,
2884                     int (*cpu_fprintf)(FILE *f, const char *fmt, ...))
2885 {
2886     int i, target_code_size, max_target_code_size;
2887     int direct_jmp_count, direct_jmp2_count, cross_page;
2888     TranslationBlock *tb;
2889
2890     target_code_size = 0;
2891     max_target_code_size = 0;
2892     cross_page = 0;
2893     direct_jmp_count = 0;
2894     direct_jmp2_count = 0;
2895     for(i = 0; i < nb_tbs; i++) {
2896         tb = &tbs[i];
2897         target_code_size += tb->size;
2898         if (tb->size > max_target_code_size)
2899             max_target_code_size = tb->size;
2900         if (tb->page_addr[1] != -1)
2901             cross_page++;
2902         if (tb->tb_next_offset[0] != 0xffff) {
2903             direct_jmp_count++;
2904             if (tb->tb_next_offset[1] != 0xffff) {
2905                 direct_jmp2_count++;
2906             }
2907         }
2908     }
2909     /* XXX: avoid using doubles ? */
2910     cpu_fprintf(f, "TB count            %d\n", nb_tbs);
2911     cpu_fprintf(f, "TB avg target size  %d max=%d bytes\n",
2912                 nb_tbs ? target_code_size / nb_tbs : 0,
2913                 max_target_code_size);
2914     cpu_fprintf(f, "TB avg host size    %d bytes (expansion ratio: %0.1f)\n",
2915                 nb_tbs ? (code_gen_ptr - code_gen_buffer) / nb_tbs : 0,
2916                 target_code_size ? (double) (code_gen_ptr - code_gen_buffer) / target_code_size : 0);
2917     cpu_fprintf(f, "cross page TB count %d (%d%%)\n",
2918             cross_page,
2919             nb_tbs ? (cross_page * 100) / nb_tbs : 0);
2920     cpu_fprintf(f, "direct jump count   %d (%d%%) (2 jumps=%d %d%%)\n",
2921                 direct_jmp_count,
2922                 nb_tbs ? (direct_jmp_count * 100) / nb_tbs : 0,
2923                 direct_jmp2_count,
2924                 nb_tbs ? (direct_jmp2_count * 100) / nb_tbs : 0);
2925     cpu_fprintf(f, "TB flush count      %d\n", tb_flush_count);
2926     cpu_fprintf(f, "TB invalidate count %d\n", tb_phys_invalidate_count);
2927     cpu_fprintf(f, "TLB flush count     %d\n", tlb_flush_count);
2928 }
2929
2930 #if !defined(CONFIG_USER_ONLY)
2931
2932 #define MMUSUFFIX _cmmu
2933 #define GETPC() NULL
2934 #define env cpu_single_env
2935 #define SOFTMMU_CODE_ACCESS
2936
2937 #define SHIFT 0
2938 #include "softmmu_template.h"
2939
2940 #define SHIFT 1
2941 #include "softmmu_template.h"
2942
2943 #define SHIFT 2
2944 #include "softmmu_template.h"
2945
2946 #define SHIFT 3
2947 #include "softmmu_template.h"
2948
2949 #undef env
2950
2951 #endif