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, see <http://www.gnu.org/licenses/>.
  18  */
  19 #include "config.h"
  20 #ifdef _WIN32
  21 #include <windows.h>
  22 #else
  23 #include <sys/types.h>
  24 #include <sys/mman.h>
  25 #endif
  26
  27 #include "qemu-common.h"
  28 #include "cpu.h"
  29 #include "exec-all.h"
  30 #include "tcg.h"
  31 #include "hw/hw.h"
  32 #include "hw/qdev.h"
  33 #include "osdep.h"
  34 #include "kvm.h"
  35 #include "qemu-timer.h"
  36 #if defined(CONFIG_USER_ONLY)
  37 #include <qemu.h>
  38 #include <signal.h>
  39 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
  40 #include <sys/param.h>
  41 #if __FreeBSD_version >= 700104
  42 #define HAVE_KINFO_GETVMMAP
  43 #define sigqueue sigqueue_freebsd  /* avoid redefinition */
  44 #include <sys/time.h>
  45 #include <sys/proc.h>
  46 #include <machine/profile.h>
  47 #define _KERNEL
  48 #include <sys/user.h>
  49 #undef _KERNEL
  50 #undef sigqueue
  51 #include <libutil.h>
  52 #endif
  53 #endif
  54 #endif
  55
  56 //#define DEBUG_TB_INVALIDATE
  57 //#define DEBUG_FLUSH
  58 //#define DEBUG_TLB
  59 //#define DEBUG_UNASSIGNED
  60
  61 /* make various TB consistency checks */
  62 //#define DEBUG_TB_CHECK
  63 //#define DEBUG_TLB_CHECK
  64
  65 //#define DEBUG_IOPORT
  66 //#define DEBUG_SUBPAGE
  67
  68 #if !defined(CONFIG_USER_ONLY)
  69 /* TB consistency checks only implemented for usermode emulation.  */
  70 #undef DEBUG_TB_CHECK
  71 #endif
  72
  73 #define SMC_BITMAP_USE_THRESHOLD 10
  74
  75 static TranslationBlock *tbs;
  76 static int code_gen_max_blocks;
  77 TranslationBlock *tb_phys_hash[CODE_GEN_PHYS_HASH_SIZE];
  78 static int nb_tbs;
  79 /* any access to the tbs or the page table must use this lock */
  80 spinlock_t tb_lock = SPIN_LOCK_UNLOCKED;
  81
  82 #if defined(__arm__) || defined(__sparc_v9__)
  83 /* The prologue must be reachable with a direct jump. ARM and Sparc64
  84  have limited branch ranges (possibly also PPC) so place it in a
  85  section close to code segment. */
  86 #define code_gen_section                                \
  87     __attribute__((__section__(".gen_code")))           \
  88     __attribute__((aligned (32)))
  89 #elif defined(_WIN32)
  90 /* Maximum alignment for Win32 is 16. */
  91 #define code_gen_section                                \
  92     __attribute__((aligned (16)))
  93 #else
  94 #define code_gen_section                                \
  95     __attribute__((aligned (32)))
  96 #endif
  97
  98 uint8_t code_gen_prologue[1024] code_gen_section;
  99 static uint8_t *code_gen_buffer;
 100 static unsigned long code_gen_buffer_size;
 101 /* threshold to flush the translated code buffer */
 102 static unsigned long code_gen_buffer_max_size;
 103 static uint8_t *code_gen_ptr;
 104
 105 #if !defined(CONFIG_USER_ONLY)
 106 int phys_ram_fd;
 107 static int in_migration;
 108
 109 RAMList ram_list = { .blocks = QLIST_HEAD_INITIALIZER(ram_list) };
 110 #endif
 111
 112 CPUState *first_cpu;
 113 /* current CPU in the current thread. It is only valid inside
 114    cpu_exec() */
 115 CPUState *cpu_single_env;
 116 /* 0 = Do not count executed instructions.
 117    1 = Precise instruction counting.
 118    2 = Adaptive rate instruction counting.  */
 119 int use_icount = 0;
 120 /* Current instruction counter.  While executing translated code this may
 121    include some instructions that have not yet been executed.  */
 122 int64_t qemu_icount;
 123
 124 typedef struct PageDesc {
 125     /* list of TBs intersecting this ram page */
 126     TranslationBlock *first_tb;
 127     /* in order to optimize self modifying code, we count the number
 128        of lookups we do to a given page to use a bitmap */
 129     unsigned int code_write_count;
 130     uint8_t *code_bitmap;
 131 #if defined(CONFIG_USER_ONLY)
 132     unsigned long flags;
 133 #endif
 134 } PageDesc;
 135
 136 /* In system mode we want L1_MAP to be based on ram offsets,
 137    while in user mode we want it to be based on virtual addresses.  */
 138 #if !defined(CONFIG_USER_ONLY)
 139 #if HOST_LONG_BITS < TARGET_PHYS_ADDR_SPACE_BITS
 140 # define L1_MAP_ADDR_SPACE_BITS  HOST_LONG_BITS
 141 #else
 142 # define L1_MAP_ADDR_SPACE_BITS  TARGET_PHYS_ADDR_SPACE_BITS
 143 #endif
 144 #else
 145 # define L1_MAP_ADDR_SPACE_BITS  TARGET_VIRT_ADDR_SPACE_BITS
 146 #endif
 147
 148 /* Size of the L2 (and L3, etc) page tables.  */
 149 #define L2_BITS 10
 150 #define L2_SIZE (1 << L2_BITS)
 151
 152 /* The bits remaining after N lower levels of page tables.  */
 153 #define P_L1_BITS_REM \
 154     ((TARGET_PHYS_ADDR_SPACE_BITS - TARGET_PAGE_BITS) % L2_BITS)
 155 #define V_L1_BITS_REM \
 156     ((L1_MAP_ADDR_SPACE_BITS - TARGET_PAGE_BITS) % L2_BITS)
 157
 158 /* Size of the L1 page table.  Avoid silly small sizes.  */
 159 #if P_L1_BITS_REM < 4
 160 #define P_L1_BITS  (P_L1_BITS_REM + L2_BITS)
 161 #else
 162 #define P_L1_BITS  P_L1_BITS_REM
 163 #endif
 164
 165 #if V_L1_BITS_REM < 4
 166 #define V_L1_BITS  (V_L1_BITS_REM + L2_BITS)
 167 #else
 168 #define V_L1_BITS  V_L1_BITS_REM
 169 #endif
 170
 171 #define P_L1_SIZE  ((target_phys_addr_t)1 << P_L1_BITS)
 172 #define V_L1_SIZE  ((target_ulong)1 << V_L1_BITS)
 173
 174 #define P_L1_SHIFT (TARGET_PHYS_ADDR_SPACE_BITS - TARGET_PAGE_BITS - P_L1_BITS)
 175 #define V_L1_SHIFT (L1_MAP_ADDR_SPACE_BITS - TARGET_PAGE_BITS - V_L1_BITS)
 176
 177 unsigned long qemu_real_host_page_size;
 178 unsigned long qemu_host_page_bits;
 179 unsigned long qemu_host_page_size;
 180 unsigned long qemu_host_page_mask;
 181
 182 /* This is a multi-level map on the virtual address space.
 183    The bottom level has pointers to PageDesc.  */
 184 static void *l1_map[V_L1_SIZE];
 185
 186 #if !defined(CONFIG_USER_ONLY)
 187 typedef struct PhysPageDesc {
 188     /* offset in host memory of the page + io_index in the low bits */
 189     ram_addr_t phys_offset;
 190     ram_addr_t region_offset;
 191 } PhysPageDesc;
 192
 193 /* This is a multi-level map on the physical address space.
 194    The bottom level has pointers to PhysPageDesc.  */
 195 static void *l1_phys_map[P_L1_SIZE];
 196
 197 static void io_mem_init(void);
 198
 199 /* io memory support */
 200 CPUWriteMemoryFunc *io_mem_write[IO_MEM_NB_ENTRIES][4];
 201 CPUReadMemoryFunc *io_mem_read[IO_MEM_NB_ENTRIES][4];
 202 void *io_mem_opaque[IO_MEM_NB_ENTRIES];
 203 static char io_mem_used[IO_MEM_NB_ENTRIES];
 204 static int io_mem_watch;
 205 #endif
 206
 207 /* log support */
 208 #ifdef WIN32
 209 static const char *logfilename = "qemu.log";
 210 #else
 211 static const char *logfilename = "/tmp/qemu.log";
 212 #endif
 213 FILE *logfile;
 214 int loglevel;
 215 static int log_append = 0;
 216
 217 /* statistics */
 218 #if !defined(CONFIG_USER_ONLY)
 219 static int tlb_flush_count;
 220 #endif
 221 static int tb_flush_count;
 222 static int tb_phys_invalidate_count;
 223
 224 #ifdef _WIN32
 225 static void map_exec(void *addr, long size)
 226 {
 227     DWORD old_protect;
 228     VirtualProtect(addr, size,
 229                    PAGE_EXECUTE_READWRITE, &old_protect);
 230
 231 }
 232 #else
 233 static void map_exec(void *addr, long size)
 234 {
 235     unsigned long start, end, page_size;
 236
 237     page_size = getpagesize();
 238     start = (unsigned long)addr;
 239     start &= ~(page_size - 1);
 240
 241     end = (unsigned long)addr + size;
 242     end += page_size - 1;
 243     end &= ~(page_size - 1);
 244
 245     mprotect((void *)start, end - start,
 246              PROT_READ | PROT_WRITE | PROT_EXEC);
 247 }
 248 #endif
 249
 250 static void page_init(void)
 251 {
 252     /* NOTE: we can always suppose that qemu_host_page_size >=
 253        TARGET_PAGE_SIZE */
 254 #ifdef _WIN32
 255     {
 256         SYSTEM_INFO system_info;
 257
 258         GetSystemInfo(&system_info);
 259         qemu_real_host_page_size = system_info.dwPageSize;
 260     }
 261 #else
 262     qemu_real_host_page_size = getpagesize();
 263 #endif
 264     if (qemu_host_page_size == 0)
 265         qemu_host_page_size = qemu_real_host_page_size;
 266     if (qemu_host_page_size < TARGET_PAGE_SIZE)
 267         qemu_host_page_size = TARGET_PAGE_SIZE;
 268     qemu_host_page_bits = 0;
 269     while ((1 << qemu_host_page_bits) < qemu_host_page_size)
 270         qemu_host_page_bits++;
 271     qemu_host_page_mask = ~(qemu_host_page_size - 1);
 272
 273 #if defined(CONFIG_BSD) && defined(CONFIG_USER_ONLY)
 274     {
 275 #ifdef HAVE_KINFO_GETVMMAP
 276         struct kinfo_vmentry *freep;
 277         int i, cnt;
 278
 279         freep = kinfo_getvmmap(getpid(), &cnt);
 280         if (freep) {
 281             mmap_lock();
 282             for (i = 0; i < cnt; i++) {
 283                 unsigned long startaddr, endaddr;
 284
 285                 startaddr = freep[i].kve_start;
 286                 endaddr = freep[i].kve_end;
 287                 if (h2g_valid(startaddr)) {
 288                     startaddr = h2g(startaddr) & TARGET_PAGE_MASK;
 289
 290                     if (h2g_valid(endaddr)) {
 291                         endaddr = h2g(endaddr);
 292                         page_set_flags(startaddr, endaddr, PAGE_RESERVED);
 293                     } else {
 294 #if TARGET_ABI_BITS <= L1_MAP_ADDR_SPACE_BITS
 295                         endaddr = ~0ul;
 296                         page_set_flags(startaddr, endaddr, PAGE_RESERVED);
 297 #endif
 298                     }
 299                 }
 300             }
 301             free(freep);
 302             mmap_unlock();
 303         }
 304 #else
 305         FILE *f;
 306
 307         last_brk = (unsigned long)sbrk(0);
 308
 309         f = fopen("/compat/linux/proc/self/maps", "r");
 310         if (f) {
 311             mmap_lock();
 312
 313             do {
 314                 unsigned long startaddr, endaddr;
 315                 int n;
 316
 317                 n = fscanf (f, "%lx-%lx %*[^\n]\n", &startaddr, &endaddr);
 318
 319                 if (n == 2 && h2g_valid(startaddr)) {
 320                     startaddr = h2g(startaddr) & TARGET_PAGE_MASK;
 321
 322                     if (h2g_valid(endaddr)) {
 323                         endaddr = h2g(endaddr);
 324                     } else {
 325                         endaddr = ~0ul;
 326                     }
 327                     page_set_flags(startaddr, endaddr, PAGE_RESERVED);
 328                 }
 329             } while (!feof(f));
 330
 331             fclose(f);
 332             mmap_unlock();
 333         }
 334 #endif
 335     }
 336 #endif
 337 }
 338
 339 static PageDesc *page_find_alloc(tb_page_addr_t index, int alloc)
 340 {
 341     PageDesc *pd;
 342     void **lp;
 343     int i;
 344
 345 #if defined(CONFIG_USER_ONLY)
 346     /* We can't use qemu_malloc because it may recurse into a locked mutex. */
 347 # define ALLOC(P, SIZE)                                 \
 348     do {                                                \
 349         P = mmap(NULL, SIZE, PROT_READ | PROT_WRITE,    \
 350                  MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);   \
 351     } while (0)
 352 #else
 353 # define ALLOC(P, SIZE) \
 354     do { P = qemu_mallocz(SIZE); } while (0)
 355 #endif
 356
 357     /* Level 1.  Always allocated.  */
 358     lp = l1_map + ((index >> V_L1_SHIFT) & (V_L1_SIZE - 1));
 359
 360     /* Level 2..N-1.  */
 361     for (i = V_L1_SHIFT / L2_BITS - 1; i > 0; i--) {
 362         void **p = *lp;
 363
 364         if (p == NULL) {
 365             if (!alloc) {
 366                 return NULL;
 367             }
 368             ALLOC(p, sizeof(void *) * L2_SIZE);
 369             *lp = p;
 370         }
 371
 372         lp = p + ((index >> (i * L2_BITS)) & (L2_SIZE - 1));
 373     }
 374
 375     pd = *lp;
 376     if (pd == NULL) {
 377         if (!alloc) {
 378             return NULL;
 379         }
 380         ALLOC(pd, sizeof(PageDesc) * L2_SIZE);
 381         *lp = pd;
 382     }
 383
 384 #undef ALLOC
 385
 386     return pd + (index & (L2_SIZE - 1));
 387 }
 388
 389 static inline PageDesc *page_find(tb_page_addr_t index)
 390 {
 391     return page_find_alloc(index, 0);
 392 }
 393
 394 #if !defined(CONFIG_USER_ONLY)
 395 static PhysPageDesc *phys_page_find_alloc(target_phys_addr_t index, int alloc)
 396 {
 397     PhysPageDesc *pd;
 398     void **lp;
 399     int i;
 400
 401     /* Level 1.  Always allocated.  */
 402     lp = l1_phys_map + ((index >> P_L1_SHIFT) & (P_L1_SIZE - 1));
 403
 404     /* Level 2..N-1.  */
 405     for (i = P_L1_SHIFT / L2_BITS - 1; i > 0; i--) {
 406         void **p = *lp;
 407         if (p == NULL) {
 408             if (!alloc) {
 409                 return NULL;
 410             }
 411             *lp = p = qemu_mallocz(sizeof(void *) * L2_SIZE);
 412         }
 413         lp = p + ((index >> (i * L2_BITS)) & (L2_SIZE - 1));
 414     }
 415
 416     pd = *lp;
 417     if (pd == NULL) {
 418         int i;
 419
 420         if (!alloc) {
 421             return NULL;
 422         }
 423
 424         *lp = pd = qemu_malloc(sizeof(PhysPageDesc) * L2_SIZE);
 425
 426         for (i = 0; i < L2_SIZE; i++) {
 427             pd[i].phys_offset = IO_MEM_UNASSIGNED;
 428             pd[i].region_offset = (index + i) << TARGET_PAGE_BITS;
 429         }
 430     }
 431
 432     return pd + (index & (L2_SIZE - 1));
 433 }
 434
 435 static inline PhysPageDesc *phys_page_find(target_phys_addr_t index)
 436 {
 437     return phys_page_find_alloc(index, 0);
 438 }
 439
 440 static void tlb_protect_code(ram_addr_t ram_addr);
 441 static void tlb_unprotect_code_phys(CPUState *env, ram_addr_t ram_addr,
 442                                     target_ulong vaddr);
 443 #define mmap_lock() do { } while(0)
 444 #define mmap_unlock() do { } while(0)
 445 #endif
 446
 447 #define DEFAULT_CODE_GEN_BUFFER_SIZE (32 * 1024 * 1024)
 448
 449 #if defined(CONFIG_USER_ONLY)
 450 /* Currently it is not recommended to allocate big chunks of data in
 451    user mode. It will change when a dedicated libc will be used */
 452 #define USE_STATIC_CODE_GEN_BUFFER
 453 #endif
 454
 455 #ifdef USE_STATIC_CODE_GEN_BUFFER
 456 static uint8_t static_code_gen_buffer[DEFAULT_CODE_GEN_BUFFER_SIZE]
 457                __attribute__((aligned (CODE_GEN_ALIGN)));
 458 #endif
 459
 460 static void code_gen_alloc(unsigned long tb_size)
 461 {
 462 #ifdef USE_STATIC_CODE_GEN_BUFFER
 463     code_gen_buffer = static_code_gen_buffer;
 464     code_gen_buffer_size = DEFAULT_CODE_GEN_BUFFER_SIZE;
 465     map_exec(code_gen_buffer, code_gen_buffer_size);
 466 #else
 467     code_gen_buffer_size = tb_size;
 468     if (code_gen_buffer_size == 0) {
 469 #if defined(CONFIG_USER_ONLY)
 470         /* in user mode, phys_ram_size is not meaningful */
 471         code_gen_buffer_size = DEFAULT_CODE_GEN_BUFFER_SIZE;
 472 #else
 473         /* XXX: needs adjustments */
 474         code_gen_buffer_size = (unsigned long)(ram_size / 4);
 475 #endif
 476     }
 477     if (code_gen_buffer_size < MIN_CODE_GEN_BUFFER_SIZE)
 478         code_gen_buffer_size = MIN_CODE_GEN_BUFFER_SIZE;
 479     /* The code gen buffer location may have constraints depending on
 480        the host cpu and OS */
 481 #if defined(__linux__)
 482     {
 483         int flags;
 484         void *start = NULL;
 485
 486         flags = MAP_PRIVATE | MAP_ANONYMOUS;
 487 #if defined(__x86_64__)
 488         flags |= MAP_32BIT;
 489         /* Cannot map more than that */
 490         if (code_gen_buffer_size > (800 * 1024 * 1024))
 491             code_gen_buffer_size = (800 * 1024 * 1024);
 492 #elif defined(__sparc_v9__)
 493         // Map the buffer below 2G, so we can use direct calls and branches
 494         flags |= MAP_FIXED;
 495         start = (void *) 0x60000000UL;
 496         if (code_gen_buffer_size > (512 * 1024 * 1024))
 497             code_gen_buffer_size = (512 * 1024 * 1024);
 498 #elif defined(__arm__)
 499         /* Map the buffer below 32M, so we can use direct calls and branches */
 500         flags |= MAP_FIXED;
 501         start = (void *) 0x01000000UL;
 502         if (code_gen_buffer_size > 16 * 1024 * 1024)
 503             code_gen_buffer_size = 16 * 1024 * 1024;
 504 #elif defined(__s390x__)
 505         /* Map the buffer so that we can use direct calls and branches.  */
 506         /* We have a +- 4GB range on the branches; leave some slop.  */
 507         if (code_gen_buffer_size > (3ul * 1024 * 1024 * 1024)) {
 508             code_gen_buffer_size = 3ul * 1024 * 1024 * 1024;
 509         }
 510         start = (void *)0x90000000UL;
 511 #endif
 512         code_gen_buffer = mmap(start, code_gen_buffer_size,
 513                                PROT_WRITE | PROT_READ | PROT_EXEC,
 514                                flags, -1, 0);
 515         if (code_gen_buffer == MAP_FAILED) {
 516             fprintf(stderr, "Could not allocate dynamic translator buffer\n");
 517             exit(1);
 518         }
 519     }
 520 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) \
 521     || defined(__DragonFly__) || defined(__OpenBSD__)
 522     {
 523         int flags;
 524         void *addr = NULL;
 525         flags = MAP_PRIVATE | MAP_ANONYMOUS;
 526 #if defined(__x86_64__)
 527         /* FreeBSD doesn't have MAP_32BIT, use MAP_FIXED and assume
 528          * 0x40000000 is free */
 529         flags |= MAP_FIXED;
 530         addr = (void *)0x40000000;
 531         /* Cannot map more than that */
 532         if (code_gen_buffer_size > (800 * 1024 * 1024))
 533             code_gen_buffer_size = (800 * 1024 * 1024);
 534 #elif defined(__sparc_v9__)
 535         // Map the buffer below 2G, so we can use direct calls and branches
 536         flags |= MAP_FIXED;
 537         addr = (void *) 0x60000000UL;
 538         if (code_gen_buffer_size > (512 * 1024 * 1024)) {
 539             code_gen_buffer_size = (512 * 1024 * 1024);
 540         }
 541 #endif
 542         code_gen_buffer = mmap(addr, code_gen_buffer_size,
 543                                PROT_WRITE | PROT_READ | PROT_EXEC,
 544                                flags, -1, 0);
 545         if (code_gen_buffer == MAP_FAILED) {
 546             fprintf(stderr, "Could not allocate dynamic translator buffer\n");
 547             exit(1);
 548         }
 549     }
 550 #else
 551     code_gen_buffer = qemu_malloc(code_gen_buffer_size);
 552     map_exec(code_gen_buffer, code_gen_buffer_size);
 553 #endif
 554 #endif /* !USE_STATIC_CODE_GEN_BUFFER */
 555     map_exec(code_gen_prologue, sizeof(code_gen_prologue));
 556     code_gen_buffer_max_size = code_gen_buffer_size -
 557         (TCG_MAX_OP_SIZE * OPC_MAX_SIZE);
 558     code_gen_max_blocks = code_gen_buffer_size / CODE_GEN_AVG_BLOCK_SIZE;
 559     tbs = qemu_malloc(code_gen_max_blocks * sizeof(TranslationBlock));
 560 }
 561
 562 /* Must be called before using the QEMU cpus. 'tb_size' is the size
 563    (in bytes) allocated to the translation buffer. Zero means default
 564    size. */
 565 void cpu_exec_init_all(unsigned long tb_size)
 566 {
 567     cpu_gen_init();
 568     code_gen_alloc(tb_size);
 569     code_gen_ptr = code_gen_buffer;
 570     page_init();
 571 #if !defined(CONFIG_USER_ONLY)
 572     io_mem_init();
 573 #endif
 574 #if !defined(CONFIG_USER_ONLY) || !defined(CONFIG_USE_GUEST_BASE)
 575     /* There's no guest base to take into account, so go ahead and
 576        initialize the prologue now.  */
 577     tcg_prologue_init(&tcg_ctx);
 578 #endif
 579 }
 580
 581 #if defined(CPU_SAVE_VERSION) && !defined(CONFIG_USER_ONLY)
 582
 583 static int cpu_common_post_load(void *opaque, int version_id)
 584 {
 585     CPUState *env = opaque;
 586
 587     /* 0x01 was CPU_INTERRUPT_EXIT. This line can be removed when the
 588        version_id is increased. */
 589     env->interrupt_request &= ~0x01;
 590     tlb_flush(env, 1);
 591
 592     return 0;
 593 }
 594
 595 static const VMStateDescription vmstate_cpu_common = {
 596     .name = "cpu_common",
 597     .version_id = 1,
 598     .minimum_version_id = 1,
 599     .minimum_version_id_old = 1,
 600     .post_load = cpu_common_post_load,
 601     .fields      = (VMStateField []) {
 602         VMSTATE_UINT32(halted, CPUState),
 603         VMSTATE_UINT32(interrupt_request, CPUState),
 604         VMSTATE_END_OF_LIST()
 605     }
 606 };
 607 #endif
 608
 609 CPUState *qemu_get_cpu(int cpu)
 610 {
 611     CPUState *env = first_cpu;
 612
 613     while (env) {
 614         if (env->cpu_index == cpu)
 615             break;
 616         env = env->next_cpu;
 617     }
 618
 619     return env;
 620 }
 621
 622 void cpu_exec_init(CPUState *env)
 623 {
 624     CPUState **penv;
 625     int cpu_index;
 626
 627 #if defined(CONFIG_USER_ONLY)
 628     cpu_list_lock();
 629 #endif
 630     env->next_cpu = NULL;
 631     penv = &first_cpu;
 632     cpu_index = 0;
 633     while (*penv != NULL) {
 634         penv = &(*penv)->next_cpu;
 635         cpu_index++;
 636     }
 637     env->cpu_index = cpu_index;
 638     env->numa_node = 0;
 639     QTAILQ_INIT(&env->breakpoints);
 640     QTAILQ_INIT(&env->watchpoints);
 641 #ifndef CONFIG_USER_ONLY
 642     env->thread_id = qemu_get_thread_id();
 643 #endif
 644     *penv = env;
 645 #if defined(CONFIG_USER_ONLY)
 646     cpu_list_unlock();
 647 #endif
 648 #if defined(CPU_SAVE_VERSION) && !defined(CONFIG_USER_ONLY)
 649     vmstate_register(NULL, cpu_index, &vmstate_cpu_common, env);
 650     register_savevm(NULL, "cpu", cpu_index, CPU_SAVE_VERSION,
 651                     cpu_save, cpu_load, env);
 652 #endif
 653 }
 654
 655 /* Allocate a new translation block. Flush the translation buffer if
 656    too many translation blocks or too much generated code. */
 657 static TranslationBlock *tb_alloc(target_ulong pc)
 658 {
 659     TranslationBlock *tb;
 660
 661     if (nb_tbs >= code_gen_max_blocks ||
 662         (code_gen_ptr - code_gen_buffer) >= code_gen_buffer_max_size)
 663         return NULL;
 664     tb = &tbs[nb_tbs++];
 665     tb->pc = pc;
 666     tb->cflags = 0;
 667     return tb;
 668 }
 669
 670 void tb_free(TranslationBlock *tb)
 671 {
 672     /* In practice this is mostly used for single use temporary TB
 673        Ignore the hard cases and just back up if this TB happens to
 674        be the last one generated.  */
 675     if (nb_tbs > 0 && tb == &tbs[nb_tbs - 1]) {
 676         code_gen_ptr = tb->tc_ptr;
 677         nb_tbs--;
 678     }
 679 }
 680
 681 static inline void invalidate_page_bitmap(PageDesc *p)
 682 {
 683     if (p->code_bitmap) {
 684         qemu_free(p->code_bitmap);
 685         p->code_bitmap = NULL;
 686     }
 687     p->code_write_count = 0;
 688 }
 689
 690 /* Set to NULL all the 'first_tb' fields in all PageDescs. */
 691
 692 static void page_flush_tb_1 (int level, void **lp)
 693 {
 694     int i;
 695
 696     if (*lp == NULL) {
 697         return;
 698     }
 699     if (level == 0) {
 700         PageDesc *pd = *lp;
 701         for (i = 0; i < L2_SIZE; ++i) {
 702             pd[i].first_tb = NULL;
 703             invalidate_page_bitmap(pd + i);
 704         }
 705     } else {
 706         void **pp = *lp;
 707         for (i = 0; i < L2_SIZE; ++i) {
 708             page_flush_tb_1 (level - 1, pp + i);
 709         }
 710     }
 711 }
 712
 713 static void page_flush_tb(void)
 714 {
 715     int i;
 716     for (i = 0; i < V_L1_SIZE; i++) {
 717         page_flush_tb_1(V_L1_SHIFT / L2_BITS - 1, l1_map + i);
 718     }
 719 }
 720
 721 /* flush all the translation blocks */
 722 /* XXX: tb_flush is currently not thread safe */
 723 void tb_flush(CPUState *env1)
 724 {
 725     CPUState *env;
 726 #if defined(DEBUG_FLUSH)
 727     printf("qemu: flush code_size=%ld nb_tbs=%d avg_tb_size=%ld\n",
 728            (unsigned long)(code_gen_ptr - code_gen_buffer),
 729            nb_tbs, nb_tbs > 0 ?
 730            ((unsigned long)(code_gen_ptr - code_gen_buffer)) / nb_tbs : 0);
 731 #endif
 732     if ((unsigned long)(code_gen_ptr - code_gen_buffer) > code_gen_buffer_size)
 733         cpu_abort(env1, "Internal error: code buffer overflow\n");
 734
 735     nb_tbs = 0;
 736
 737     for(env = first_cpu; env != NULL; env = env->next_cpu) {
 738         memset (env->tb_jmp_cache, 0, TB_JMP_CACHE_SIZE * sizeof (void *));
 739     }
 740
 741     memset (tb_phys_hash, 0, CODE_GEN_PHYS_HASH_SIZE * sizeof (void *));
 742     page_flush_tb();
 743
 744     code_gen_ptr = code_gen_buffer;
 745     /* XXX: flush processor icache at this point if cache flush is
 746        expensive */
 747     tb_flush_count++;
 748 }
 749
 750 #ifdef DEBUG_TB_CHECK
 751
 752 static void tb_invalidate_check(target_ulong address)
 753 {
 754     TranslationBlock *tb;
 755     int i;
 756     address &= TARGET_PAGE_MASK;
 757     for(i = 0;i < CODE_GEN_PHYS_HASH_SIZE; i++) {
 758         for(tb = tb_phys_hash[i]; tb != NULL; tb = tb->phys_hash_next) {
 759             if (!(address + TARGET_PAGE_SIZE <= tb->pc ||
 760                   address >= tb->pc + tb->size)) {
 761                 printf("ERROR invalidate: address=" TARGET_FMT_lx
 762                        " PC=%08lx size=%04x\n",
 763                        address, (long)tb->pc, tb->size);
 764             }
 765         }
 766     }
 767 }
 768
 769 /* verify that all the pages have correct rights for code */
 770 static void tb_page_check(void)
 771 {
 772     TranslationBlock *tb;
 773     int i, flags1, flags2;
 774
 775     for(i = 0;i < CODE_GEN_PHYS_HASH_SIZE; i++) {
 776         for(tb = tb_phys_hash[i]; tb != NULL; tb = tb->phys_hash_next) {
 777             flags1 = page_get_flags(tb->pc);
 778             flags2 = page_get_flags(tb->pc + tb->size - 1);
 779             if ((flags1 & PAGE_WRITE) || (flags2 & PAGE_WRITE)) {
 780                 printf("ERROR page flags: PC=%08lx size=%04x f1=%x f2=%x\n",
 781                        (long)tb->pc, tb->size, flags1, flags2);
 782             }
 783         }
 784     }
 785 }
 786
 787 #endif
 788
 789 /* invalidate one TB */
 790 static inline void tb_remove(TranslationBlock **ptb, TranslationBlock *tb,
 791                              int next_offset)
 792 {
 793     TranslationBlock *tb1;
 794     for(;;) {
 795         tb1 = *ptb;
 796         if (tb1 == tb) {
 797             *ptb = *(TranslationBlock **)((char *)tb1 + next_offset);
 798             break;
 799         }
 800         ptb = (TranslationBlock **)((char *)tb1 + next_offset);
 801     }
 802 }
 803
 804 static inline void tb_page_remove(TranslationBlock **ptb, TranslationBlock *tb)
 805 {
 806     TranslationBlock *tb1;
 807     unsigned int n1;
 808
 809     for(;;) {
 810         tb1 = *ptb;
 811         n1 = (long)tb1 & 3;
 812         tb1 = (TranslationBlock *)((long)tb1 & ~3);
 813         if (tb1 == tb) {
 814             *ptb = tb1->page_next[n1];
 815             break;
 816         }
 817         ptb = &tb1->page_next[n1];
 818     }
 819 }
 820
 821 static inline void tb_jmp_remove(TranslationBlock *tb, int n)
 822 {
 823     TranslationBlock *tb1, **ptb;
 824     unsigned int n1;
 825
 826     ptb = &tb->jmp_next[n];
 827     tb1 = *ptb;
 828     if (tb1) {
 829         /* find tb(n) in circular list */
 830         for(;;) {
 831             tb1 = *ptb;
 832             n1 = (long)tb1 & 3;
 833             tb1 = (TranslationBlock *)((long)tb1 & ~3);
 834             if (n1 == n && tb1 == tb)
 835                 break;
 836             if (n1 == 2) {
 837                 ptb = &tb1->jmp_first;
 838             } else {
 839                 ptb = &tb1->jmp_next[n1];
 840             }
 841         }
 842         /* now we can suppress tb(n) from the list */
 843         *ptb = tb->jmp_next[n];
 844
 845         tb->jmp_next[n] = NULL;
 846     }
 847 }
 848
 849 /* reset the jump entry 'n' of a TB so that it is not chained to
 850    another TB */
 851 static inline void tb_reset_jump(TranslationBlock *tb, int n)
 852 {
 853     tb_set_jmp_target(tb, n, (unsigned long)(tb->tc_ptr + tb->tb_next_offset[n]));
 854 }
 855
 856 void tb_phys_invalidate(TranslationBlock *tb, tb_page_addr_t page_addr)
 857 {
 858     CPUState *env;
 859     PageDesc *p;
 860     unsigned int h, n1;
 861     tb_page_addr_t phys_pc;
 862     TranslationBlock *tb1, *tb2;
 863
 864     /* remove the TB from the hash list */
 865     phys_pc = tb->page_addr[0] + (tb->pc & ~TARGET_PAGE_MASK);
 866     h = tb_phys_hash_func(phys_pc);
 867     tb_remove(&tb_phys_hash[h], tb,
 868               offsetof(TranslationBlock, phys_hash_next));
 869
 870     /* remove the TB from the page list */
 871     if (tb->page_addr[0] != page_addr) {
 872         p = page_find(tb->page_addr[0] >> TARGET_PAGE_BITS);
 873         tb_page_remove(&p->first_tb, tb);
 874         invalidate_page_bitmap(p);
 875     }
 876     if (tb->page_addr[1] != -1 && tb->page_addr[1] != page_addr) {
 877         p = page_find(tb->page_addr[1] >> TARGET_PAGE_BITS);
 878         tb_page_remove(&p->first_tb, tb);
 879         invalidate_page_bitmap(p);
 880     }
 881
 882     tb_invalidated_flag = 1;
 883
 884     /* remove the TB from the hash list */
 885     h = tb_jmp_cache_hash_func(tb->pc);
 886     for(env = first_cpu; env != NULL; env = env->next_cpu) {
 887         if (env->tb_jmp_cache[h] == tb)
 888             env->tb_jmp_cache[h] = NULL;
 889     }
 890
 891     /* suppress this TB from the two jump lists */
 892     tb_jmp_remove(tb, 0);
 893     tb_jmp_remove(tb, 1);
 894
 895     /* suppress any remaining jumps to this TB */
 896     tb1 = tb->jmp_first;
 897     for(;;) {
 898         n1 = (long)tb1 & 3;
 899         if (n1 == 2)
 900             break;
 901         tb1 = (TranslationBlock *)((long)tb1 & ~3);
 902         tb2 = tb1->jmp_next[n1];
 903         tb_reset_jump(tb1, n1);
 904         tb1->jmp_next[n1] = NULL;
 905         tb1 = tb2;
 906     }
 907     tb->jmp_first = (TranslationBlock *)((long)tb | 2); /* fail safe */
 908
 909     tb_phys_invalidate_count++;
 910 }
 911
 912 static inline void set_bits(uint8_t *tab, int start, int len)
 913 {
 914     int end, mask, end1;
 915
 916     end = start + len;
 917     tab += start >> 3;
 918     mask = 0xff << (start & 7);
 919     if ((start & ~7) == (end & ~7)) {
 920         if (start < end) {
 921             mask &= ~(0xff << (end & 7));
 922             *tab |= mask;
 923         }
 924     } else {
 925         *tab++ |= mask;
 926         start = (start + 8) & ~7;
 927         end1 = end & ~7;
 928         while (start < end1) {
 929             *tab++ = 0xff;
 930             start += 8;
 931         }
 932         if (start < end) {
 933             mask = ~(0xff << (end & 7));
 934             *tab |= mask;
 935         }
 936     }
 937 }
 938
 939 static void build_page_bitmap(PageDesc *p)
 940 {
 941     int n, tb_start, tb_end;
 942     TranslationBlock *tb;
 943
 944     p->code_bitmap = qemu_mallocz(TARGET_PAGE_SIZE / 8);
 945
 946     tb = p->first_tb;
 947     while (tb != NULL) {
 948         n = (long)tb & 3;
 949         tb = (TranslationBlock *)((long)tb & ~3);
 950         /* NOTE: this is subtle as a TB may span two physical pages */
 951         if (n == 0) {
 952             /* NOTE: tb_end may be after the end of the page, but
 953                it is not a problem */
 954             tb_start = tb->pc & ~TARGET_PAGE_MASK;
 955             tb_end = tb_start + tb->size;
 956             if (tb_end > TARGET_PAGE_SIZE)
 957                 tb_end = TARGET_PAGE_SIZE;
 958         } else {
 959             tb_start = 0;
 960             tb_end = ((tb->pc + tb->size) & ~TARGET_PAGE_MASK);
 961         }
 962         set_bits(p->code_bitmap, tb_start, tb_end - tb_start);
 963         tb = tb->page_next[n];
 964     }
 965 }
 966
 967 TranslationBlock *tb_gen_code(CPUState *env,
 968                               target_ulong pc, target_ulong cs_base,
 969                               int flags, int cflags)
 970 {
 971     TranslationBlock *tb;
 972     uint8_t *tc_ptr;
 973     tb_page_addr_t phys_pc, phys_page2;
 974     target_ulong virt_page2;
 975     int code_gen_size;
 976
 977     phys_pc = get_page_addr_code(env, pc);
 978     tb = tb_alloc(pc);
 979     if (!tb) {
 980         /* flush must be done */
 981         tb_flush(env);
 982         /* cannot fail at this point */
 983         tb = tb_alloc(pc);
 984         /* Don't forget to invalidate previous TB info.  */
 985         tb_invalidated_flag = 1;
 986     }
 987     tc_ptr = code_gen_ptr;
 988     tb->tc_ptr = tc_ptr;
 989     tb->cs_base = cs_base;
 990     tb->flags = flags;
 991     tb->cflags = cflags;
 992     cpu_gen_code(env, tb, &code_gen_size);
 993     code_gen_ptr = (void *)(((unsigned long)code_gen_ptr + code_gen_size + CODE_GEN_ALIGN - 1) & ~(CODE_GEN_ALIGN - 1));
 994
 995     /* check next page if needed */
 996     virt_page2 = (pc + tb->size - 1) & TARGET_PAGE_MASK;
 997     phys_page2 = -1;
 998     if ((pc & TARGET_PAGE_MASK) != virt_page2) {
 999         phys_page2 = get_page_addr_code(env, virt_page2);
1000     }
1001     tb_link_page(tb, phys_pc, phys_page2);
1002     return tb;
1003 }
1004
1005 /* invalidate all TBs which intersect with the target physical page
1006    starting in range [start;end[. NOTE: start and end must refer to
1007    the same physical page. 'is_cpu_write_access' should be true if called
1008    from a real cpu write access: the virtual CPU will exit the current
1009    TB if code is modified inside this TB. */
1010 void tb_invalidate_phys_page_range(tb_page_addr_t start, tb_page_addr_t end,
1011                                    int is_cpu_write_access)
1012 {
1013     TranslationBlock *tb, *tb_next, *saved_tb;
1014     CPUState *env = cpu_single_env;
1015     tb_page_addr_t tb_start, tb_end;
1016     PageDesc *p;
1017     int n;
1018 #ifdef TARGET_HAS_PRECISE_SMC
1019     int current_tb_not_found = is_cpu_write_access;
1020     TranslationBlock *current_tb = NULL;
1021     int current_tb_modified = 0;
1022     target_ulong current_pc = 0;
1023     target_ulong current_cs_base = 0;
1024     int current_flags = 0;
1025 #endif /* TARGET_HAS_PRECISE_SMC */
1026
1027     p = page_find(start >> TARGET_PAGE_BITS);
1028     if (!p)
1029         return;
1030     if (!p->code_bitmap &&
1031         ++p->code_write_count >= SMC_BITMAP_USE_THRESHOLD &&
1032         is_cpu_write_access) {
1033         /* build code bitmap */
1034         build_page_bitmap(p);
1035     }
1036
1037     /* we remove all the TBs in the range [start, end[ */
1038     /* XXX: see if in some cases it could be faster to invalidate all the code */
1039     tb = p->first_tb;
1040     while (tb != NULL) {
1041         n = (long)tb & 3;
1042         tb = (TranslationBlock *)((long)tb & ~3);
1043         tb_next = tb->page_next[n];
1044         /* NOTE: this is subtle as a TB may span two physical pages */
1045         if (n == 0) {
1046             /* NOTE: tb_end may be after the end of the page, but
1047                it is not a problem */
1048             tb_start = tb->page_addr[0] + (tb->pc & ~TARGET_PAGE_MASK);
1049             tb_end = tb_start + tb->size;
1050         } else {
1051             tb_start = tb->page_addr[1];
1052             tb_end = tb_start + ((tb->pc + tb->size) & ~TARGET_PAGE_MASK);
1053         }
1054         if (!(tb_end <= start || tb_start >= end)) {
1055 #ifdef TARGET_HAS_PRECISE_SMC
1056             if (current_tb_not_found) {
1057                 current_tb_not_found = 0;
1058                 current_tb = NULL;
1059                 if (env->mem_io_pc) {
1060                     /* now we have a real cpu fault */
1061                     current_tb = tb_find_pc(env->mem_io_pc);
1062                 }
1063             }
1064             if (current_tb == tb &&
1065                 (current_tb->cflags & CF_COUNT_MASK) != 1) {
1066                 /* If we are modifying the current TB, we must stop
1067                 its execution. We could be more precise by checking
1068                 that the modification is after the current PC, but it
1069                 would require a specialized function to partially
1070                 restore the CPU state */
1071
1072                 current_tb_modified = 1;
1073                 cpu_restore_state(current_tb, env,
1074                                   env->mem_io_pc, NULL);
1075                 cpu_get_tb_cpu_state(env, &current_pc, &current_cs_base,
1076                                      &current_flags);
1077             }
1078 #endif /* TARGET_HAS_PRECISE_SMC */
1079             /* we need to do that to handle the case where a signal
1080                occurs while doing tb_phys_invalidate() */
1081             saved_tb = NULL;
1082             if (env) {
1083                 saved_tb = env->current_tb;
1084                 env->current_tb = NULL;
1085             }
1086             tb_phys_invalidate(tb, -1);
1087             if (env) {
1088                 env->current_tb = saved_tb;
1089                 if (env->interrupt_request && env->current_tb)
1090                     cpu_interrupt(env, env->interrupt_request);
1091             }
1092         }
1093         tb = tb_next;
1094     }
1095 #if !defined(CONFIG_USER_ONLY)
1096     /* if no code remaining, no need to continue to use slow writes */
1097     if (!p->first_tb) {
1098         invalidate_page_bitmap(p);
1099         if (is_cpu_write_access) {
1100             tlb_unprotect_code_phys(env, start, env->mem_io_vaddr);
1101         }
1102     }
1103 #endif
1104 #ifdef TARGET_HAS_PRECISE_SMC
1105     if (current_tb_modified) {
1106         /* we generate a block containing just the instruction
1107            modifying the memory. It will ensure that it cannot modify
1108            itself */
1109         env->current_tb = NULL;
1110         tb_gen_code(env, current_pc, current_cs_base, current_flags, 1);
1111         cpu_resume_from_signal(env, NULL);
1112     }
1113 #endif
1114 }
1115
1116 /* len must be <= 8 and start must be a multiple of len */
1117 static inline void tb_invalidate_phys_page_fast(tb_page_addr_t start, int len)
1118 {
1119     PageDesc *p;
1120     int offset, b;
1121 #if 0
1122     if (1) {
1123         qemu_log("modifying code at 0x%x size=%d EIP=%x PC=%08x\n",
1124                   cpu_single_env->mem_io_vaddr, len,
1125                   cpu_single_env->eip,
1126                   cpu_single_env->eip + (long)cpu_single_env->segs[R_CS].base);
1127     }
1128 #endif
1129     p = page_find(start >> TARGET_PAGE_BITS);
1130     if (!p)
1131         return;
1132     if (p->code_bitmap) {
1133         offset = start & ~TARGET_PAGE_MASK;
1134         b = p->code_bitmap[offset >> 3] >> (offset & 7);
1135         if (b & ((1 << len) - 1))
1136             goto do_invalidate;
1137     } else {
1138     do_invalidate:
1139         tb_invalidate_phys_page_range(start, start + len, 1);
1140     }
1141 }
1142
1143 #if !defined(CONFIG_SOFTMMU)
1144 static void tb_invalidate_phys_page(tb_page_addr_t addr,
1145                                     unsigned long pc, void *puc)
1146 {
1147     TranslationBlock *tb;
1148     PageDesc *p;
1149     int n;
1150 #ifdef TARGET_HAS_PRECISE_SMC
1151     TranslationBlock *current_tb = NULL;
1152     CPUState *env = cpu_single_env;
1153     int current_tb_modified = 0;
1154     target_ulong current_pc = 0;
1155     target_ulong current_cs_base = 0;
1156     int current_flags = 0;
1157 #endif
1158
1159     addr &= TARGET_PAGE_MASK;
1160     p = page_find(addr >> TARGET_PAGE_BITS);
1161     if (!p)
1162         return;
1163     tb = p->first_tb;
1164 #ifdef TARGET_HAS_PRECISE_SMC
1165     if (tb && pc != 0) {
1166         current_tb = tb_find_pc(pc);
1167     }
1168 #endif
1169     while (tb != NULL) {
1170         n = (long)tb & 3;
1171         tb = (TranslationBlock *)((long)tb & ~3);
1172 #ifdef TARGET_HAS_PRECISE_SMC
1173         if (current_tb == tb &&
1174             (current_tb->cflags & CF_COUNT_MASK) != 1) {
1175                 /* If we are modifying the current TB, we must stop
1176                    its execution. We could be more precise by checking
1177                    that the modification is after the current PC, but it
1178                    would require a specialized function to partially
1179                    restore the CPU state */
1180
1181             current_tb_modified = 1;
1182             cpu_restore_state(current_tb, env, pc, puc);
1183             cpu_get_tb_cpu_state(env, &current_pc, &current_cs_base,
1184                                  &current_flags);
1185         }
1186 #endif /* TARGET_HAS_PRECISE_SMC */
1187         tb_phys_invalidate(tb, addr);
1188         tb = tb->page_next[n];
1189     }
1190     p->first_tb = NULL;
1191 #ifdef TARGET_HAS_PRECISE_SMC
1192     if (current_tb_modified) {
1193         /* we generate a block containing just the instruction
1194            modifying the memory. It will ensure that it cannot modify
1195            itself */
1196         env->current_tb = NULL;
1197         tb_gen_code(env, current_pc, current_cs_base, current_flags, 1);
1198         cpu_resume_from_signal(env, puc);
1199     }
1200 #endif
1201 }
1202 #endif
1203
1204 /* add the tb in the target page and protect it if necessary */
1205 static inline void tb_alloc_page(TranslationBlock *tb,
1206                                  unsigned int n, tb_page_addr_t page_addr)
1207 {
1208     PageDesc *p;
1209     TranslationBlock *last_first_tb;
1210
1211     tb->page_addr[n] = page_addr;
1212     p = page_find_alloc(page_addr >> TARGET_PAGE_BITS, 1);
1213     tb->page_next[n] = p->first_tb;
1214     last_first_tb = p->first_tb;
1215     p->first_tb = (TranslationBlock *)((long)tb | n);
1216     invalidate_page_bitmap(p);
1217
1218 #if defined(TARGET_HAS_SMC) || 1
1219
1220 #if defined(CONFIG_USER_ONLY)
1221     if (p->flags & PAGE_WRITE) {
1222         target_ulong addr;
1223         PageDesc *p2;
1224         int prot;
1225
1226         /* force the host page as non writable (writes will have a
1227            page fault + mprotect overhead) */
1228         page_addr &= qemu_host_page_mask;
1229         prot = 0;
1230         for(addr = page_addr; addr < page_addr + qemu_host_page_size;
1231             addr += TARGET_PAGE_SIZE) {
1232
1233             p2 = page_find (addr >> TARGET_PAGE_BITS);
1234             if (!p2)
1235                 continue;
1236             prot |= p2->flags;
1237             p2->flags &= ~PAGE_WRITE;
1238           }
1239         mprotect(g2h(page_addr), qemu_host_page_size,
1240                  (prot & PAGE_BITS) & ~PAGE_WRITE);
1241 #ifdef DEBUG_TB_INVALIDATE
1242         printf("protecting code page: 0x" TARGET_FMT_lx "\n",
1243                page_addr);
1244 #endif
1245     }
1246 #else
1247     /* if some code is already present, then the pages are already
1248        protected. So we handle the case where only the first TB is
1249        allocated in a physical page */
1250     if (!last_first_tb) {
1251         tlb_protect_code(page_addr);
1252     }
1253 #endif
1254
1255 #endif /* TARGET_HAS_SMC */
1256 }
1257
1258 /* add a new TB and link it to the physical page tables. phys_page2 is
1259    (-1) to indicate that only one page contains the TB. */
1260 void tb_link_page(TranslationBlock *tb,
1261                   tb_page_addr_t phys_pc, tb_page_addr_t phys_page2)
1262 {
1263     unsigned int h;
1264     TranslationBlock **ptb;
1265
1266     /* Grab the mmap lock to stop another thread invalidating this TB
1267        before we are done.  */
1268     mmap_lock();
1269     /* add in the physical hash table */
1270     h = tb_phys_hash_func(phys_pc);
1271     ptb = &tb_phys_hash[h];
1272     tb->phys_hash_next = *ptb;
1273     *ptb = tb;
1274
1275     /* add in the page list */
1276     tb_alloc_page(tb, 0, phys_pc & TARGET_PAGE_MASK);
1277     if (phys_page2 != -1)
1278         tb_alloc_page(tb, 1, phys_page2);
1279     else
1280         tb->page_addr[1] = -1;
1281
1282     tb->jmp_first = (TranslationBlock *)((long)tb | 2);
1283     tb->jmp_next[0] = NULL;
1284     tb->jmp_next[1] = NULL;
1285
1286     /* init original jump addresses */
1287     if (tb->tb_next_offset[0] != 0xffff)
1288         tb_reset_jump(tb, 0);
1289     if (tb->tb_next_offset[1] != 0xffff)
1290         tb_reset_jump(tb, 1);
1291
1292 #ifdef DEBUG_TB_CHECK
1293     tb_page_check();
1294 #endif
1295     mmap_unlock();
1296 }
1297
1298 /* find the TB 'tb' such that tb[0].tc_ptr <= tc_ptr <
1299    tb[1].tc_ptr. Return NULL if not found */
1300 TranslationBlock *tb_find_pc(unsigned long tc_ptr)
1301 {
1302     int m_min, m_max, m;
1303     unsigned long v;
1304     TranslationBlock *tb;
1305
1306     if (nb_tbs <= 0)
1307         return NULL;
1308     if (tc_ptr < (unsigned long)code_gen_buffer ||
1309         tc_ptr >= (unsigned long)code_gen_ptr)
1310         return NULL;
1311     /* binary search (cf Knuth) */
1312     m_min = 0;
1313     m_max = nb_tbs - 1;
1314     while (m_min <= m_max) {
1315         m = (m_min + m_max) >> 1;
1316         tb = &tbs[m];
1317         v = (unsigned long)tb->tc_ptr;
1318         if (v == tc_ptr)
1319             return tb;
1320         else if (tc_ptr < v) {
1321             m_max = m - 1;
1322         } else {
1323             m_min = m + 1;
1324         }
1325     }
1326     return &tbs[m_max];
1327 }
1328
1329 static void tb_reset_jump_recursive(TranslationBlock *tb);
1330
1331 static inline void tb_reset_jump_recursive2(TranslationBlock *tb, int n)
1332 {
1333     TranslationBlock *tb1, *tb_next, **ptb;
1334     unsigned int n1;
1335
1336     tb1 = tb->jmp_next[n];
1337     if (tb1 != NULL) {
1338         /* find head of list */
1339         for(;;) {
1340             n1 = (long)tb1 & 3;
1341             tb1 = (TranslationBlock *)((long)tb1 & ~3);
1342             if (n1 == 2)
1343                 break;
1344             tb1 = tb1->jmp_next[n1];
1345         }
1346         /* we are now sure now that tb jumps to tb1 */
1347         tb_next = tb1;
1348
1349         /* remove tb from the jmp_first list */
1350         ptb = &tb_next->jmp_first;
1351         for(;;) {
1352             tb1 = *ptb;
1353             n1 = (long)tb1 & 3;
1354             tb1 = (TranslationBlock *)((long)tb1 & ~3);
1355             if (n1 == n && tb1 == tb)
1356                 break;
1357             ptb = &tb1->jmp_next[n1];
1358         }
1359         *ptb = tb->jmp_next[n];
1360         tb->jmp_next[n] = NULL;
1361
1362         /* suppress the jump to next tb in generated code */
1363         tb_reset_jump(tb, n);
1364
1365         /* suppress jumps in the tb on which we could have jumped */
1366         tb_reset_jump_recursive(tb_next);
1367     }
1368 }
1369
1370 static void tb_reset_jump_recursive(TranslationBlock *tb)
1371 {
1372     tb_reset_jump_recursive2(tb, 0);
1373     tb_reset_jump_recursive2(tb, 1);
1374 }
1375
1376 #if defined(TARGET_HAS_ICE)
1377 #if defined(CONFIG_USER_ONLY)
1378 static void breakpoint_invalidate(CPUState *env, target_ulong pc)
1379 {
1380     tb_invalidate_phys_page_range(pc, pc + 1, 0);
1381 }
1382 #else
1383 static void breakpoint_invalidate(CPUState *env, target_ulong pc)
1384 {
1385     target_phys_addr_t addr;
1386     target_ulong pd;
1387     ram_addr_t ram_addr;
1388     PhysPageDesc *p;
1389
1390     addr = cpu_get_phys_page_debug(env, pc);
1391     p = phys_page_find(addr >> TARGET_PAGE_BITS);
1392     if (!p) {
1393         pd = IO_MEM_UNASSIGNED;
1394     } else {
1395         pd = p->phys_offset;
1396     }
1397     ram_addr = (pd & TARGET_PAGE_MASK) | (pc & ~TARGET_PAGE_MASK);
1398     tb_invalidate_phys_page_range(ram_addr, ram_addr + 1, 0);
1399 }
1400 #endif
1401 #endif /* TARGET_HAS_ICE */
1402
1403 #if defined(CONFIG_USER_ONLY)
1404 void cpu_watchpoint_remove_all(CPUState *env, int mask)
1405
1406 {
1407 }
1408
1409 int cpu_watchpoint_insert(CPUState *env, target_ulong addr, target_ulong len,
1410                           int flags, CPUWatchpoint **watchpoint)
1411 {
1412     return -ENOSYS;
1413 }
1414 #else
1415 /* Add a watchpoint.  */
1416 int cpu_watchpoint_insert(CPUState *env, target_ulong addr, target_ulong len,
1417                           int flags, CPUWatchpoint **watchpoint)
1418 {
1419     target_ulong len_mask = ~(len - 1);
1420     CPUWatchpoint *wp;
1421
1422     /* sanity checks: allow power-of-2 lengths, deny unaligned watchpoints */
1423     if ((len != 1 && len != 2 && len != 4 && len != 8) || (addr & ~len_mask)) {
1424         fprintf(stderr, "qemu: tried to set invalid watchpoint at "
1425                 TARGET_FMT_lx ", len=" TARGET_FMT_lu "\n", addr, len);
1426         return -EINVAL;
1427     }
1428     wp = qemu_malloc(sizeof(*wp));
1429
1430     wp->vaddr = addr;
1431     wp->len_mask = len_mask;
1432     wp->flags = flags;
1433
1434     /* keep all GDB-injected watchpoints in front */
1435     if (flags & BP_GDB)
1436         QTAILQ_INSERT_HEAD(&env->watchpoints, wp, entry);
1437     else
1438         QTAILQ_INSERT_TAIL(&env->watchpoints, wp, entry);
1439
1440     tlb_flush_page(env, addr);
1441
1442     if (watchpoint)
1443         *watchpoint = wp;
1444     return 0;
1445 }
1446
1447 /* Remove a specific watchpoint.  */
1448 int cpu_watchpoint_remove(CPUState *env, target_ulong addr, target_ulong len,
1449                           int flags)
1450 {
1451     target_ulong len_mask = ~(len - 1);
1452     CPUWatchpoint *wp;
1453
1454     QTAILQ_FOREACH(wp, &env->watchpoints, entry) {
1455         if (addr == wp->vaddr && len_mask == wp->len_mask
1456                 && flags == (wp->flags & ~BP_WATCHPOINT_HIT)) {
1457             cpu_watchpoint_remove_by_ref(env, wp);
1458             return 0;
1459         }
1460     }
1461     return -ENOENT;
1462 }
1463
1464 /* Remove a specific watchpoint by reference.  */
1465 void cpu_watchpoint_remove_by_ref(CPUState *env, CPUWatchpoint *watchpoint)
1466 {
1467     QTAILQ_REMOVE(&env->watchpoints, watchpoint, entry);
1468
1469     tlb_flush_page(env, watchpoint->vaddr);
1470
1471     qemu_free(watchpoint);
1472 }
1473
1474 /* Remove all matching watchpoints.  */
1475 void cpu_watchpoint_remove_all(CPUState *env, int mask)
1476 {
1477     CPUWatchpoint *wp, *next;
1478
1479     QTAILQ_FOREACH_SAFE(wp, &env->watchpoints, entry, next) {
1480         if (wp->flags & mask)
1481             cpu_watchpoint_remove_by_ref(env, wp);
1482     }
1483 }
1484 #endif
1485
1486 /* Add a breakpoint.  */
1487 int cpu_breakpoint_insert(CPUState *env, target_ulong pc, int flags,
1488                           CPUBreakpoint **breakpoint)
1489 {
1490 #if defined(TARGET_HAS_ICE)
1491     CPUBreakpoint *bp;
1492
1493     bp = qemu_malloc(sizeof(*bp));
1494
1495     bp->pc = pc;
1496     bp->flags = flags;
1497
1498     /* keep all GDB-injected breakpoints in front */
1499     if (flags & BP_GDB)
1500         QTAILQ_INSERT_HEAD(&env->breakpoints, bp, entry);
1501     else
1502         QTAILQ_INSERT_TAIL(&env->breakpoints, bp, entry);
1503
1504     breakpoint_invalidate(env, pc);
1505
1506     if (breakpoint)
1507         *breakpoint = bp;
1508     return 0;
1509 #else
1510     return -ENOSYS;
1511 #endif
1512 }
1513
1514 /* Remove a specific breakpoint.  */
1515 int cpu_breakpoint_remove(CPUState *env, target_ulong pc, int flags)
1516 {
1517 #if defined(TARGET_HAS_ICE)
1518     CPUBreakpoint *bp;
1519
1520     QTAILQ_FOREACH(bp, &env->breakpoints, entry) {
1521         if (bp->pc == pc && bp->flags == flags) {
1522             cpu_breakpoint_remove_by_ref(env, bp);
1523             return 0;
1524         }
1525     }
1526     return -ENOENT;
1527 #else
1528     return -ENOSYS;
1529 #endif
1530 }
1531
1532 /* Remove a specific breakpoint by reference.  */
1533 void cpu_breakpoint_remove_by_ref(CPUState *env, CPUBreakpoint *breakpoint)
1534 {
1535 #if defined(TARGET_HAS_ICE)
1536     QTAILQ_REMOVE(&env->breakpoints, breakpoint, entry);
1537
1538     breakpoint_invalidate(env, breakpoint->pc);
1539
1540     qemu_free(breakpoint);
1541 #endif
1542 }
1543
1544 /* Remove all matching breakpoints. */
1545 void cpu_breakpoint_remove_all(CPUState *env, int mask)
1546 {
1547 #if defined(TARGET_HAS_ICE)
1548     CPUBreakpoint *bp, *next;
1549
1550     QTAILQ_FOREACH_SAFE(bp, &env->breakpoints, entry, next) {
1551         if (bp->flags & mask)
1552             cpu_breakpoint_remove_by_ref(env, bp);
1553     }
1554 #endif
1555 }
1556
1557 /* enable or disable single step mode. EXCP_DEBUG is returned by the
1558    CPU loop after each instruction */
1559 void cpu_single_step(CPUState *env, int enabled)
1560 {
1561 #if defined(TARGET_HAS_ICE)
1562     if (env->singlestep_enabled != enabled) {
1563         env->singlestep_enabled = enabled;
1564         if (kvm_enabled())
1565             kvm_update_guest_debug(env, 0);
1566         else {
1567             /* must flush all the translated code to avoid inconsistencies */
1568             /* XXX: only flush what is necessary */
1569             tb_flush(env);
1570         }
1571     }
1572 #endif
1573 }
1574
1575 /* enable or disable low levels log */
1576 void cpu_set_log(int log_flags)
1577 {
1578     loglevel = log_flags;
1579     if (loglevel && !logfile) {
1580         logfile = fopen(logfilename, log_append ? "a" : "w");
1581         if (!logfile) {
1582             perror(logfilename);
1583             _exit(1);
1584         }
1585 #if !defined(CONFIG_SOFTMMU)
1586         /* must avoid mmap() usage of glibc by setting a buffer "by hand" */
1587         {
1588             static char logfile_buf[4096];
1589             setvbuf(logfile, logfile_buf, _IOLBF, sizeof(logfile_buf));
1590         }
1591 #elif !defined(_WIN32)
1592         /* Win32 doesn't support line-buffering and requires size >= 2 */
1593         setvbuf(logfile, NULL, _IOLBF, 0);
1594 #endif
1595         log_append = 1;
1596     }
1597     if (!loglevel && logfile) {
1598         fclose(logfile);
1599         logfile = NULL;
1600     }
1601 }
1602
1603 void cpu_set_log_filename(const char *filename)
1604 {
1605     logfilename = strdup(filename);
1606     if (logfile) {
1607         fclose(logfile);
1608         logfile = NULL;
1609     }
1610     cpu_set_log(loglevel);
1611 }
1612
1613 static void cpu_unlink_tb(CPUState *env)
1614 {
1615     /* FIXME: TB unchaining isn't SMP safe.  For now just ignore the
1616        problem and hope the cpu will stop of its own accord.  For userspace
1617        emulation this often isn't actually as bad as it sounds.  Often
1618        signals are used primarily to interrupt blocking syscalls.  */
1619     TranslationBlock *tb;
1620     static spinlock_t interrupt_lock = SPIN_LOCK_UNLOCKED;
1621
1622     spin_lock(&interrupt_lock);
1623     tb = env->current_tb;
1624     /* if the cpu is currently executing code, we must unlink it and
1625        all the potentially executing TB */
1626     if (tb) {
1627         env->current_tb = NULL;
1628         tb_reset_jump_recursive(tb);
1629     }
1630     spin_unlock(&interrupt_lock);
1631 }
1632
1633 /* mask must never be zero, except for A20 change call */
1634 void cpu_interrupt(CPUState *env, int mask)
1635 {
1636     int old_mask;
1637
1638     old_mask = env->interrupt_request;
1639     env->interrupt_request |= mask;
1640
1641 #ifndef CONFIG_USER_ONLY
1642     /*
1643      * If called from iothread context, wake the target cpu in
1644      * case its halted.
1645      */
1646     if (!qemu_cpu_is_self(env)) {
1647         qemu_cpu_kick(env);
1648         return;
1649     }
1650 #endif
1651
1652     if (use_icount) {
1653         env->icount_decr.u16.high = 0xffff;
1654 #ifndef CONFIG_USER_ONLY
1655         if (!can_do_io(env)
1656             && (mask & ~old_mask) != 0) {
1657             cpu_abort(env, "Raised interrupt while not in I/O function");
1658         }
1659 #endif
1660     } else {
1661         cpu_unlink_tb(env);
1662     }
1663 }
1664
1665 void cpu_reset_interrupt(CPUState *env, int mask)
1666 {
1667     env->interrupt_request &= ~mask;
1668 }
1669
1670 void cpu_exit(CPUState *env)
1671 {
1672     env->exit_request = 1;
1673     cpu_unlink_tb(env);
1674 }
1675
1676 const CPULogItem cpu_log_items[] = {
1677     { CPU_LOG_TB_OUT_ASM, "out_asm",
1678       "show generated host assembly code for each compiled TB" },
1679     { CPU_LOG_TB_IN_ASM, "in_asm",
1680       "show target assembly code for each compiled TB" },
1681     { CPU_LOG_TB_OP, "op",
1682       "show micro ops for each compiled TB" },
1683     { CPU_LOG_TB_OP_OPT, "op_opt",
1684       "show micro ops "
1685 #ifdef TARGET_I386
1686       "before eflags optimization and "
1687 #endif
1688       "after liveness analysis" },
1689     { CPU_LOG_INT, "int",
1690       "show interrupts/exceptions in short format" },
1691     { CPU_LOG_EXEC, "exec",
1692       "show trace before each executed TB (lots of logs)" },
1693     { CPU_LOG_TB_CPU, "cpu",
1694       "show CPU state before block translation" },
1695 #ifdef TARGET_I386
1696     { CPU_LOG_PCALL, "pcall",
1697       "show protected mode far calls/returns/exceptions" },
1698     { CPU_LOG_RESET, "cpu_reset",
1699       "show CPU state before CPU resets" },
1700 #endif
1701 #ifdef DEBUG_IOPORT
1702     { CPU_LOG_IOPORT, "ioport",
1703       "show all i/o ports accesses" },
1704 #endif
1705     { 0, NULL, NULL },
1706 };
1707
1708 #ifndef CONFIG_USER_ONLY
1709 static QLIST_HEAD(memory_client_list, CPUPhysMemoryClient) memory_client_list
1710     = QLIST_HEAD_INITIALIZER(memory_client_list);
1711
1712 static void cpu_notify_set_memory(target_phys_addr_t start_addr,
1713                                   ram_addr_t size,
1714                                   ram_addr_t phys_offset)
1715 {
1716     CPUPhysMemoryClient *client;
1717     QLIST_FOREACH(client, &memory_client_list, list) {
1718         client->set_memory(client, start_addr, size, phys_offset);
1719     }
1720 }
1721
1722 static int cpu_notify_sync_dirty_bitmap(target_phys_addr_t start,
1723                                         target_phys_addr_t end)
1724 {
1725     CPUPhysMemoryClient *client;
1726     QLIST_FOREACH(client, &memory_client_list, list) {
1727         int r = client->sync_dirty_bitmap(client, start, end);
1728         if (r < 0)
1729             return r;
1730     }
1731     return 0;
1732 }
1733
1734 static int cpu_notify_migration_log(int enable)
1735 {
1736     CPUPhysMemoryClient *client;
1737     QLIST_FOREACH(client, &memory_client_list, list) {
1738         int r = client->migration_log(client, enable);
1739         if (r < 0)
1740             return r;
1741     }
1742     return 0;
1743 }
1744
1745 static void phys_page_for_each_1(CPUPhysMemoryClient *client,
1746                                  int level, void **lp)
1747 {
1748     int i;
1749
1750     if (*lp == NULL) {
1751         return;
1752     }
1753     if (level == 0) {
1754         PhysPageDesc *pd = *lp;
1755         for (i = 0; i < L2_SIZE; ++i) {
1756             if (pd[i].phys_offset != IO_MEM_UNASSIGNED) {
1757                 client->set_memory(client, pd[i].region_offset,
1758                                    TARGET_PAGE_SIZE, pd[i].phys_offset);
1759             }
1760         }
1761     } else {
1762         void **pp = *lp;
1763         for (i = 0; i < L2_SIZE; ++i) {
1764             phys_page_for_each_1(client, level - 1, pp + i);
1765         }
1766     }
1767 }
1768
1769 static void phys_page_for_each(CPUPhysMemoryClient *client)
1770 {
1771     int i;
1772     for (i = 0; i < P_L1_SIZE; ++i) {
1773         phys_page_for_each_1(client, P_L1_SHIFT / L2_BITS - 1,
1774                              l1_phys_map + 1);
1775     }
1776 }
1777
1778 void cpu_register_phys_memory_client(CPUPhysMemoryClient *client)
1779 {
1780     QLIST_INSERT_HEAD(&memory_client_list, client, list);
1781     phys_page_for_each(client);
1782 }
1783
1784 void cpu_unregister_phys_memory_client(CPUPhysMemoryClient *client)
1785 {
1786     QLIST_REMOVE(client, list);
1787 }
1788 #endif
1789
1790 static int cmp1(const char *s1, int n, const char *s2)
1791 {
1792     if (strlen(s2) != n)
1793         return 0;
1794     return memcmp(s1, s2, n) == 0;
1795 }
1796
1797 /* takes a comma separated list of log masks. Return 0 if error. */
1798 int cpu_str_to_log_mask(const char *str)
1799 {
1800     const CPULogItem *item;
1801     int mask;
1802     const char *p, *p1;
1803
1804     p = str;
1805     mask = 0;
1806     for(;;) {
1807         p1 = strchr(p, ',');
1808         if (!p1)
1809             p1 = p + strlen(p);
1810         if(cmp1(p,p1-p,"all")) {
1811             for(item = cpu_log_items; item->mask != 0; item++) {
1812                 mask |= item->mask;
1813             }
1814         } else {
1815             for(item = cpu_log_items; item->mask != 0; item++) {
1816                 if (cmp1(p, p1 - p, item->name))
1817                     goto found;
1818             }
1819             return 0;
1820         }
1821     found:
1822         mask |= item->mask;
1823         if (*p1 != ',')
1824             break;
1825         p = p1 + 1;
1826     }
1827     return mask;
1828 }
1829
1830 void cpu_abort(CPUState *env, const char *fmt, ...)
1831 {
1832     va_list ap;
1833     va_list ap2;
1834
1835     va_start(ap, fmt);
1836     va_copy(ap2, ap);
1837     fprintf(stderr, "qemu: fatal: ");
1838     vfprintf(stderr, fmt, ap);
1839     fprintf(stderr, "\n");
1840 #ifdef TARGET_I386
1841     cpu_dump_state(env, stderr, fprintf, X86_DUMP_FPU | X86_DUMP_CCOP);
1842 #else
1843     cpu_dump_state(env, stderr, fprintf, 0);
1844 #endif
1845     if (qemu_log_enabled()) {
1846         qemu_log("qemu: fatal: ");
1847         qemu_log_vprintf(fmt, ap2);
1848         qemu_log("\n");
1849 #ifdef TARGET_I386
1850         log_cpu_state(env, X86_DUMP_FPU | X86_DUMP_CCOP);
1851 #else
1852         log_cpu_state(env, 0);
1853 #endif
1854         qemu_log_flush();
1855         qemu_log_close();
1856     }
1857     va_end(ap2);
1858     va_end(ap);
1859 #if defined(CONFIG_USER_ONLY)
1860     {
1861         struct sigaction act;
1862         sigfillset(&act.sa_mask);
1863         act.sa_handler = SIG_DFL;
1864         sigaction(SIGABRT, &act, NULL);
1865     }
1866 #endif
1867     abort();
1868 }
1869
1870 CPUState *cpu_copy(CPUState *env)
1871 {
1872     CPUState *new_env = cpu_init(env->cpu_model_str);
1873     CPUState *next_cpu = new_env->next_cpu;
1874     int cpu_index = new_env->cpu_index;
1875 #if defined(TARGET_HAS_ICE)
1876     CPUBreakpoint *bp;
1877     CPUWatchpoint *wp;
1878 #endif
1879
1880     memcpy(new_env, env, sizeof(CPUState));
1881
1882     /* Preserve chaining and index. */
1883     new_env->next_cpu = next_cpu;
1884     new_env->cpu_index = cpu_index;
1885
1886     /* Clone all break/watchpoints.
1887        Note: Once we support ptrace with hw-debug register access, make sure
1888        BP_CPU break/watchpoints are handled correctly on clone. */
1889     QTAILQ_INIT(&env->breakpoints);
1890     QTAILQ_INIT(&env->watchpoints);
1891 #if defined(TARGET_HAS_ICE)
1892     QTAILQ_FOREACH(bp, &env->breakpoints, entry) {
1893         cpu_breakpoint_insert(new_env, bp->pc, bp->flags, NULL);
1894     }
1895     QTAILQ_FOREACH(wp, &env->watchpoints, entry) {
1896         cpu_watchpoint_insert(new_env, wp->vaddr, (~wp->len_mask) + 1,
1897                               wp->flags, NULL);
1898     }
1899 #endif
1900
1901     return new_env;
1902 }
1903
1904 #if !defined(CONFIG_USER_ONLY)
1905
1906 static inline void tlb_flush_jmp_cache(CPUState *env, target_ulong addr)
1907 {
1908     unsigned int i;
1909
1910     /* Discard jump cache entries for any tb which might potentially
1911        overlap the flushed page.  */
1912     i = tb_jmp_cache_hash_page(addr - TARGET_PAGE_SIZE);
1913     memset (&env->tb_jmp_cache[i], 0,
1914             TB_JMP_PAGE_SIZE * sizeof(TranslationBlock *));
1915
1916     i = tb_jmp_cache_hash_page(addr);
1917     memset (&env->tb_jmp_cache[i], 0,
1918             TB_JMP_PAGE_SIZE * sizeof(TranslationBlock *));
1919 }
1920
1921 static CPUTLBEntry s_cputlb_empty_entry = {
1922     .addr_read  = -1,
1923     .addr_write = -1,
1924     .addr_code  = -1,
1925     .addend     = -1,
1926 };
1927
1928 /* NOTE: if flush_global is true, also flush global entries (not
1929    implemented yet) */
1930 void tlb_flush(CPUState *env, int flush_global)
1931 {
1932     int i;
1933
1934 #if defined(DEBUG_TLB)
1935     printf("tlb_flush:\n");
1936 #endif
1937     /* must reset current TB so that interrupts cannot modify the
1938        links while we are modifying them */
1939     env->current_tb = NULL;
1940
1941     for(i = 0; i < CPU_TLB_SIZE; i++) {
1942         int mmu_idx;
1943         for (mmu_idx = 0; mmu_idx < NB_MMU_MODES; mmu_idx++) {
1944             env->tlb_table[mmu_idx][i] = s_cputlb_empty_entry;
1945         }
1946     }
1947
1948     memset (env->tb_jmp_cache, 0, TB_JMP_CACHE_SIZE * sizeof (void *));
1949
1950     env->tlb_flush_addr = -1;
1951     env->tlb_flush_mask = 0;
1952     tlb_flush_count++;
1953 }
1954
1955 static inline void tlb_flush_entry(CPUTLBEntry *tlb_entry, target_ulong addr)
1956 {
1957     if (addr == (tlb_entry->addr_read &
1958                  (TARGET_PAGE_MASK | TLB_INVALID_MASK)) ||
1959         addr == (tlb_entry->addr_write &
1960                  (TARGET_PAGE_MASK | TLB_INVALID_MASK)) ||
1961         addr == (tlb_entry->addr_code &
1962                  (TARGET_PAGE_MASK | TLB_INVALID_MASK))) {
1963         *tlb_entry = s_cputlb_empty_entry;
1964     }
1965 }
1966
1967 void tlb_flush_page(CPUState *env, target_ulong addr)
1968 {
1969     int i;
1970     int mmu_idx;
1971
1972 #if defined(DEBUG_TLB)
1973     printf("tlb_flush_page: " TARGET_FMT_lx "\n", addr);
1974 #endif
1975     /* Check if we need to flush due to large pages.  */
1976     if ((addr & env->tlb_flush_mask) == env->tlb_flush_addr) {
1977 #if defined(DEBUG_TLB)
1978         printf("tlb_flush_page: forced full flush ("
1979                TARGET_FMT_lx "/" TARGET_FMT_lx ")\n",
1980                env->tlb_flush_addr, env->tlb_flush_mask);
1981 #endif
1982         tlb_flush(env, 1);
1983         return;
1984     }
1985     /* must reset current TB so that interrupts cannot modify the
1986        links while we are modifying them */
1987     env->current_tb = NULL;
1988
1989     addr &= TARGET_PAGE_MASK;
1990     i = (addr >> TARGET_PAGE_BITS) & (CPU_TLB_SIZE - 1);
1991     for (mmu_idx = 0; mmu_idx < NB_MMU_MODES; mmu_idx++)
1992         tlb_flush_entry(&env->tlb_table[mmu_idx][i], addr);
1993
1994     tlb_flush_jmp_cache(env, addr);
1995 }
1996
1997 /* update the TLBs so that writes to code in the virtual page 'addr'
1998    can be detected */
1999 static void tlb_protect_code(ram_addr_t ram_addr)
2000 {
2001     cpu_physical_memory_reset_dirty(ram_addr,
2002                                     ram_addr + TARGET_PAGE_SIZE,
2003                                     CODE_DIRTY_FLAG);
2004 }
2005
2006 /* update the TLB so that writes in physical page 'phys_addr' are no longer
2007    tested for self modifying code */
2008 static void tlb_unprotect_code_phys(CPUState *env, ram_addr_t ram_addr,
2009                                     target_ulong vaddr)
2010 {
2011     cpu_physical_memory_set_dirty_flags(ram_addr, CODE_DIRTY_FLAG);
2012 }
2013
2014 static inline void tlb_reset_dirty_range(CPUTLBEntry *tlb_entry,
2015                                          unsigned long start, unsigned long length)
2016 {
2017     unsigned long addr;
2018     if ((tlb_entry->addr_write & ~TARGET_PAGE_MASK) == IO_MEM_RAM) {
2019         addr = (tlb_entry->addr_write & TARGET_PAGE_MASK) + tlb_entry->addend;
2020         if ((addr - start) < length) {
2021             tlb_entry->addr_write = (tlb_entry->addr_write & TARGET_PAGE_MASK) | TLB_NOTDIRTY;
2022         }
2023     }
2024 }
2025
2026 /* Note: start and end must be within the same ram block.  */
2027 void cpu_physical_memory_reset_dirty(ram_addr_t start, ram_addr_t end,
2028                                      int dirty_flags)
2029 {
2030     CPUState *env;
2031     unsigned long length, start1;
2032     int i;
2033
2034     start &= TARGET_PAGE_MASK;
2035     end = TARGET_PAGE_ALIGN(end);
2036
2037     length = end - start;
2038     if (length == 0)
2039         return;
2040     cpu_physical_memory_mask_dirty_range(start, length, dirty_flags);
2041
2042     /* we modify the TLB cache so that the dirty bit will be set again
2043        when accessing the range */
2044     start1 = (unsigned long)qemu_safe_ram_ptr(start);
2045     /* Chek that we don't span multiple blocks - this breaks the
2046        address comparisons below.  */
2047     if ((unsigned long)qemu_safe_ram_ptr(end - 1) - start1
2048             != (end - 1) - start) {
2049         abort();
2050     }
2051
2052     for(env = first_cpu; env != NULL; env = env->next_cpu) {
2053         int mmu_idx;
2054         for (mmu_idx = 0; mmu_idx < NB_MMU_MODES; mmu_idx++) {
2055             for(i = 0; i < CPU_TLB_SIZE; i++)
2056                 tlb_reset_dirty_range(&env->tlb_table[mmu_idx][i],
2057                                       start1, length);
2058         }
2059     }
2060 }
2061
2062 int cpu_physical_memory_set_dirty_tracking(int enable)
2063 {
2064     int ret = 0;
2065     in_migration = enable;
2066     ret = cpu_notify_migration_log(!!enable);
2067     return ret;
2068 }
2069
2070 int cpu_physical_memory_get_dirty_tracking(void)
2071 {
2072     return in_migration;
2073 }
2074
2075 int cpu_physical_sync_dirty_bitmap(target_phys_addr_t start_addr,
2076                                    target_phys_addr_t end_addr)
2077 {
2078     int ret;
2079
2080     ret = cpu_notify_sync_dirty_bitmap(start_addr, end_addr);
2081     return ret;
2082 }
2083
2084 int cpu_physical_log_start(target_phys_addr_t start_addr,
2085                            ram_addr_t size)
2086 {
2087     CPUPhysMemoryClient *client;
2088     QLIST_FOREACH(client, &memory_client_list, list) {
2089         if (client->log_start) {
2090             int r = client->log_start(client, start_addr, size);
2091             if (r < 0) {
2092                 return r;
2093             }
2094         }
2095     }
2096     return 0;
2097 }
2098
2099 int cpu_physical_log_stop(target_phys_addr_t start_addr,
2100                           ram_addr_t size)
2101 {
2102     CPUPhysMemoryClient *client;
2103     QLIST_FOREACH(client, &memory_client_list, list) {
2104         if (client->log_stop) {
2105             int r = client->log_stop(client, start_addr, size);
2106             if (r < 0) {
2107                 return r;
2108             }
2109         }
2110     }
2111     return 0;
2112 }
2113
2114 static inline void tlb_update_dirty(CPUTLBEntry *tlb_entry)
2115 {
2116     ram_addr_t ram_addr;
2117     void *p;
2118
2119     if ((tlb_entry->addr_write & ~TARGET_PAGE_MASK) == IO_MEM_RAM) {
2120         p = (void *)(unsigned long)((tlb_entry->addr_write & TARGET_PAGE_MASK)
2121             + tlb_entry->addend);
2122         ram_addr = qemu_ram_addr_from_host_nofail(p);
2123         if (!cpu_physical_memory_is_dirty(ram_addr)) {
2124             tlb_entry->addr_write |= TLB_NOTDIRTY;
2125         }
2126     }
2127 }
2128
2129 /* update the TLB according to the current state of the dirty bits */
2130 void cpu_tlb_update_dirty(CPUState *env)
2131 {
2132     int i;
2133     int mmu_idx;
2134     for (mmu_idx = 0; mmu_idx < NB_MMU_MODES; mmu_idx++) {
2135         for(i = 0; i < CPU_TLB_SIZE; i++)
2136             tlb_update_dirty(&env->tlb_table[mmu_idx][i]);
2137     }
2138 }
2139
2140 static inline void tlb_set_dirty1(CPUTLBEntry *tlb_entry, target_ulong vaddr)
2141 {
2142     if (tlb_entry->addr_write == (vaddr | TLB_NOTDIRTY))
2143         tlb_entry->addr_write = vaddr;
2144 }
2145
2146 /* update the TLB corresponding to virtual page vaddr
2147    so that it is no longer dirty */
2148 static inline void tlb_set_dirty(CPUState *env, target_ulong vaddr)
2149 {
2150     int i;
2151     int mmu_idx;
2152
2153     vaddr &= TARGET_PAGE_MASK;
2154     i = (vaddr >> TARGET_PAGE_BITS) & (CPU_TLB_SIZE - 1);
2155     for (mmu_idx = 0; mmu_idx < NB_MMU_MODES; mmu_idx++)
2156         tlb_set_dirty1(&env->tlb_table[mmu_idx][i], vaddr);
2157 }
2158
2159 /* Our TLB does not support large pages, so remember the area covered by
2160    large pages and trigger a full TLB flush if these are invalidated.  */
2161 static void tlb_add_large_page(CPUState *env, target_ulong vaddr,
2162                                target_ulong size)
2163 {
2164     target_ulong mask = ~(size - 1);
2165
2166     if (env->tlb_flush_addr == (target_ulong)-1) {
2167         env->tlb_flush_addr = vaddr & mask;
2168         env->tlb_flush_mask = mask;
2169         return;
2170     }
2171     /* Extend the existing region to include the new page.
2172        This is a compromise between unnecessary flushes and the cost
2173        of maintaining a full variable size TLB.  */
2174     mask &= env->tlb_flush_mask;
2175     while (((env->tlb_flush_addr ^ vaddr) & mask) != 0) {
2176         mask <<= 1;
2177     }
2178     env->tlb_flush_addr &= mask;
2179     env->tlb_flush_mask = mask;
2180 }
2181
2182 /* Add a new TLB entry. At most one entry for a given virtual address
2183    is permitted. Only a single TARGET_PAGE_SIZE region is mapped, the
2184    supplied size is only used by tlb_flush_page.  */
2185 void tlb_set_page(CPUState *env, target_ulong vaddr,
2186                   target_phys_addr_t paddr, int prot,
2187                   int mmu_idx, target_ulong size)
2188 {
2189     PhysPageDesc *p;
2190     unsigned long pd;
2191     unsigned int index;
2192     target_ulong address;
2193     target_ulong code_address;
2194     unsigned long addend;
2195     CPUTLBEntry *te;
2196     CPUWatchpoint *wp;
2197     target_phys_addr_t iotlb;
2198
2199     assert(size >= TARGET_PAGE_SIZE);
2200     if (size != TARGET_PAGE_SIZE) {
2201         tlb_add_large_page(env, vaddr, size);
2202     }
2203     p = phys_page_find(paddr >> TARGET_PAGE_BITS);
2204     if (!p) {
2205         pd = IO_MEM_UNASSIGNED;
2206     } else {
2207         pd = p->phys_offset;
2208     }
2209 #if defined(DEBUG_TLB)
2210     printf("tlb_set_page: vaddr=" TARGET_FMT_lx " paddr=0x" TARGET_FMT_plx
2211            " prot=%x idx=%d pd=0x%08lx\n",
2212            vaddr, paddr, prot, mmu_idx, pd);
2213 #endif
2214
2215     address = vaddr;
2216     if ((pd & ~TARGET_PAGE_MASK) > IO_MEM_ROM && !(pd & IO_MEM_ROMD)) {
2217         /* IO memory case (romd handled later) */
2218         address |= TLB_MMIO;
2219     }
2220     addend = (unsigned long)qemu_get_ram_ptr(pd & TARGET_PAGE_MASK);
2221     if ((pd & ~TARGET_PAGE_MASK) <= IO_MEM_ROM) {
2222         /* Normal RAM.  */
2223         iotlb = pd & TARGET_PAGE_MASK;
2224         if ((pd & ~TARGET_PAGE_MASK) == IO_MEM_RAM)
2225             iotlb |= IO_MEM_NOTDIRTY;
2226         else
2227             iotlb |= IO_MEM_ROM;
2228     } else {
2229         /* IO handlers are currently passed a physical address.
2230            It would be nice to pass an offset from the base address
2231            of that region.  This would avoid having to special case RAM,
2232            and avoid full address decoding in every device.
2233            We can't use the high bits of pd for this because
2234            IO_MEM_ROMD uses these as a ram address.  */
2235         iotlb = (pd & ~TARGET_PAGE_MASK);
2236         if (p) {
2237             iotlb += p->region_offset;
2238         } else {
2239             iotlb += paddr;
2240         }
2241     }
2242
2243     code_address = address;
2244     /* Make accesses to pages with watchpoints go via the
2245        watchpoint trap routines.  */
2246     QTAILQ_FOREACH(wp, &env->watchpoints, entry) {
2247         if (vaddr == (wp->vaddr & TARGET_PAGE_MASK)) {
2248             /* Avoid trapping reads of pages with a write breakpoint. */
2249             if ((prot & PAGE_WRITE) || (wp->flags & BP_MEM_READ)) {
2250                 iotlb = io_mem_watch + paddr;
2251                 address |= TLB_MMIO;
2252                 break;
2253             }
2254         }
2255     }
2256
2257     index = (vaddr >> TARGET_PAGE_BITS) & (CPU_TLB_SIZE - 1);
2258     env->iotlb[mmu_idx][index] = iotlb - vaddr;
2259     te = &env->tlb_table[mmu_idx][index];
2260     te->addend = addend - vaddr;
2261     if (prot & PAGE_READ) {
2262         te->addr_read = address;
2263     } else {
2264         te->addr_read = -1;
2265     }
2266
2267     if (prot & PAGE_EXEC) {
2268         te->addr_code = code_address;
2269     } else {
2270         te->addr_code = -1;
2271     }
2272     if (prot & PAGE_WRITE) {
2273         if ((pd & ~TARGET_PAGE_MASK) == IO_MEM_ROM ||
2274             (pd & IO_MEM_ROMD)) {
2275             /* Write access calls the I/O callback.  */
2276             te->addr_write = address | TLB_MMIO;
2277         } else if ((pd & ~TARGET_PAGE_MASK) == IO_MEM_RAM &&
2278                    !cpu_physical_memory_is_dirty(pd)) {
2279             te->addr_write = address | TLB_NOTDIRTY;
2280         } else {
2281             te->addr_write = address;
2282         }
2283     } else {
2284         te->addr_write = -1;
2285     }
2286 }
2287
2288 #else
2289
2290 void tlb_flush(CPUState *env, int flush_global)
2291 {
2292 }
2293
2294 void tlb_flush_page(CPUState *env, target_ulong addr)
2295 {
2296 }
2297
2298 /*
2299  * Walks guest process memory "regions" one by one
2300  * and calls callback function 'fn' for each region.
2301  */
2302
2303 struct walk_memory_regions_data
2304 {
2305     walk_memory_regions_fn fn;
2306     void *priv;
2307     unsigned long start;
2308     int prot;
2309 };
2310
2311 static int walk_memory_regions_end(struct walk_memory_regions_data *data,
2312                                    abi_ulong end, int new_prot)
2313 {
2314     if (data->start != -1ul) {
2315         int rc = data->fn(data->priv, data->start, end, data->prot);
2316         if (rc != 0) {
2317             return rc;
2318         }
2319     }
2320
2321     data->start = (new_prot ? end : -1ul);
2322     data->prot = new_prot;
2323
2324     return 0;
2325 }
2326
2327 static int walk_memory_regions_1(struct walk_memory_regions_data *data,
2328                                  abi_ulong base, int level, void **lp)
2329 {
2330     abi_ulong pa;
2331     int i, rc;
2332
2333     if (*lp == NULL) {
2334         return walk_memory_regions_end(data, base, 0);
2335     }
2336
2337     if (level == 0) {
2338         PageDesc *pd = *lp;
2339         for (i = 0; i < L2_SIZE; ++i) {
2340             int prot = pd[i].flags;
2341
2342             pa = base | (i << TARGET_PAGE_BITS);
2343             if (prot != data->prot) {
2344                 rc = walk_memory_regions_end(data, pa, prot);
2345                 if (rc != 0) {
2346                     return rc;
2347                 }
2348             }
2349         }
2350     } else {
2351         void **pp = *lp;
2352         for (i = 0; i < L2_SIZE; ++i) {
2353             pa = base | ((abi_ulong)i <<
2354                 (TARGET_PAGE_BITS + L2_BITS * level));
2355             rc = walk_memory_regions_1(data, pa, level - 1, pp + i);
2356             if (rc != 0) {
2357                 return rc;
2358             }
2359         }
2360     }
2361
2362     return 0;
2363 }
2364
2365 int walk_memory_regions(void *priv, walk_memory_regions_fn fn)
2366 {
2367     struct walk_memory_regions_data data;
2368     unsigned long i;
2369
2370     data.fn = fn;
2371     data.priv = priv;
2372     data.start = -1ul;
2373     data.prot = 0;
2374
2375     for (i = 0; i < V_L1_SIZE; i++) {
2376         int rc = walk_memory_regions_1(&data, (abi_ulong)i << V_L1_SHIFT,
2377                                        V_L1_SHIFT / L2_BITS - 1, l1_map + i);
2378         if (rc != 0) {
2379             return rc;
2380         }
2381     }
2382
2383     return walk_memory_regions_end(&data, 0, 0);
2384 }
2385
2386 static int dump_region(void *priv, abi_ulong start,
2387     abi_ulong end, unsigned long prot)
2388 {
2389     FILE *f = (FILE *)priv;
2390
2391     (void) fprintf(f, TARGET_ABI_FMT_lx"-"TARGET_ABI_FMT_lx
2392         " "TARGET_ABI_FMT_lx" %c%c%c\n",
2393         start, end, end - start,
2394         ((prot & PAGE_READ) ? 'r' : '-'),
2395         ((prot & PAGE_WRITE) ? 'w' : '-'),
2396         ((prot & PAGE_EXEC) ? 'x' : '-'));
2397
2398     return (0);
2399 }
2400
2401 /* dump memory mappings */
2402 void page_dump(FILE *f)
2403 {
2404     (void) fprintf(f, "%-8s %-8s %-8s %s\n",
2405             "start", "end", "size", "prot");
2406     walk_memory_regions(f, dump_region);
2407 }
2408
2409 int page_get_flags(target_ulong address)
2410 {
2411     PageDesc *p;
2412
2413     p = page_find(address >> TARGET_PAGE_BITS);
2414     if (!p)
2415         return 0;
2416     return p->flags;
2417 }
2418
2419 /* Modify the flags of a page and invalidate the code if necessary.
2420    The flag PAGE_WRITE_ORG is positioned automatically depending
2421    on PAGE_WRITE.  The mmap_lock should already be held.  */
2422 void page_set_flags(target_ulong start, target_ulong end, int flags)
2423 {
2424     target_ulong addr, len;
2425
2426     /* This function should never be called with addresses outside the
2427        guest address space.  If this assert fires, it probably indicates
2428        a missing call to h2g_valid.  */
2429 #if TARGET_ABI_BITS > L1_MAP_ADDR_SPACE_BITS
2430     assert(end < ((abi_ulong)1 << L1_MAP_ADDR_SPACE_BITS));
2431 #endif
2432     assert(start < end);
2433
2434     start = start & TARGET_PAGE_MASK;
2435     end = TARGET_PAGE_ALIGN(end);
2436
2437     if (flags & PAGE_WRITE) {
2438         flags |= PAGE_WRITE_ORG;
2439     }
2440
2441     for (addr = start, len = end - start;
2442          len != 0;
2443          len -= TARGET_PAGE_SIZE, addr += TARGET_PAGE_SIZE) {
2444         PageDesc *p = page_find_alloc(addr >> TARGET_PAGE_BITS, 1);
2445
2446         /* If the write protection bit is set, then we invalidate
2447            the code inside.  */
2448         if (!(p->flags & PAGE_WRITE) &&
2449             (flags & PAGE_WRITE) &&
2450             p->first_tb) {
2451             tb_invalidate_phys_page(addr, 0, NULL);
2452         }
2453         p->flags = flags;
2454     }
2455 }
2456
2457 int page_check_range(target_ulong start, target_ulong len, int flags)
2458 {
2459     PageDesc *p;
2460     target_ulong end;
2461     target_ulong addr;
2462
2463     /* This function should never be called with addresses outside the
2464        guest address space.  If this assert fires, it probably indicates
2465        a missing call to h2g_valid.  */
2466 #if TARGET_ABI_BITS > L1_MAP_ADDR_SPACE_BITS
2467     assert(start < ((abi_ulong)1 << L1_MAP_ADDR_SPACE_BITS));
2468 #endif
2469
2470     if (len == 0) {
2471         return 0;
2472     }
2473     if (start + len - 1 < start) {
2474         /* We've wrapped around.  */
2475         return -1;
2476     }
2477
2478     end = TARGET_PAGE_ALIGN(start+len); /* must do before we loose bits in the next step */
2479     start = start & TARGET_PAGE_MASK;
2480
2481     for (addr = start, len = end - start;
2482          len != 0;
2483          len -= TARGET_PAGE_SIZE, addr += TARGET_PAGE_SIZE) {
2484         p = page_find(addr >> TARGET_PAGE_BITS);
2485         if( !p )
2486             return -1;
2487         if( !(p->flags & PAGE_VALID) )
2488             return -1;
2489
2490         if ((flags & PAGE_READ) && !(p->flags & PAGE_READ))
2491             return -1;
2492         if (flags & PAGE_WRITE) {
2493             if (!(p->flags & PAGE_WRITE_ORG))
2494                 return -1;
2495             /* unprotect the page if it was put read-only because it
2496                contains translated code */
2497             if (!(p->flags & PAGE_WRITE)) {
2498                 if (!page_unprotect(addr, 0, NULL))
2499                     return -1;
2500             }
2501             return 0;
2502         }
2503     }
2504     return 0;
2505 }
2506
2507 /* called from signal handler: invalidate the code and unprotect the
2508    page. Return TRUE if the fault was successfully handled. */
2509 int page_unprotect(target_ulong address, unsigned long pc, void *puc)
2510 {
2511     unsigned int prot;
2512     PageDesc *p;
2513     target_ulong host_start, host_end, addr;
2514
2515     /* Technically this isn't safe inside a signal handler.  However we
2516        know this only ever happens in a synchronous SEGV handler, so in
2517        practice it seems to be ok.  */
2518     mmap_lock();
2519
2520     p = page_find(address >> TARGET_PAGE_BITS);
2521     if (!p) {
2522         mmap_unlock();
2523         return 0;
2524     }
2525
2526     /* if the page was really writable, then we change its
2527        protection back to writable */
2528     if ((p->flags & PAGE_WRITE_ORG) && !(p->flags & PAGE_WRITE)) {
2529         host_start = address & qemu_host_page_mask;
2530         host_end = host_start + qemu_host_page_size;
2531
2532         prot = 0;
2533         for (addr = host_start ; addr < host_end ; addr += TARGET_PAGE_SIZE) {
2534             p = page_find(addr >> TARGET_PAGE_BITS);
2535             p->flags |= PAGE_WRITE;
2536             prot |= p->flags;
2537
2538             /* and since the content will be modified, we must invalidate
2539                the corresponding translated code. */
2540             tb_invalidate_phys_page(addr, pc, puc);
2541 #ifdef DEBUG_TB_CHECK
2542             tb_invalidate_check(addr);
2543 #endif
2544         }
2545         mprotect((void *)g2h(host_start), qemu_host_page_size,
2546                  prot & PAGE_BITS);
2547
2548         mmap_unlock();
2549         return 1;
2550     }
2551     mmap_unlock();
2552     return 0;
2553 }
2554
2555 static inline void tlb_set_dirty(CPUState *env,
2556                                  unsigned long addr, target_ulong vaddr)
2557 {
2558 }
2559 #endif /* defined(CONFIG_USER_ONLY) */
2560
2561 #if !defined(CONFIG_USER_ONLY)
2562
2563 #define SUBPAGE_IDX(addr) ((addr) & ~TARGET_PAGE_MASK)
2564 typedef struct subpage_t {
2565     target_phys_addr_t base;
2566     ram_addr_t sub_io_index[TARGET_PAGE_SIZE];
2567     ram_addr_t region_offset[TARGET_PAGE_SIZE];
2568 } subpage_t;
2569
2570 static int subpage_register (subpage_t *mmio, uint32_t start, uint32_t end,
2571                              ram_addr_t memory, ram_addr_t region_offset);
2572 static subpage_t *subpage_init (target_phys_addr_t base, ram_addr_t *phys,
2573                                 ram_addr_t orig_memory,
2574                                 ram_addr_t region_offset);
2575 #define CHECK_SUBPAGE(addr, start_addr, start_addr2, end_addr, end_addr2, \
2576                       need_subpage)                                     \
2577     do {                                                                \
2578         if (addr > start_addr)                                          \
2579             start_addr2 = 0;                                            \
2580         else {                                                          \
2581             start_addr2 = start_addr & ~TARGET_PAGE_MASK;               \
2582             if (start_addr2 > 0)                                        \
2583                 need_subpage = 1;                                       \
2584         }                                                               \
2585                                                                         \
2586         if ((start_addr + orig_size) - addr >= TARGET_PAGE_SIZE)        \
2587             end_addr2 = TARGET_PAGE_SIZE - 1;                           \
2588         else {                                                          \
2589             end_addr2 = (start_addr + orig_size - 1) & ~TARGET_PAGE_MASK; \
2590             if (end_addr2 < TARGET_PAGE_SIZE - 1)                       \
2591                 need_subpage = 1;                                       \
2592         }                                                               \
2593     } while (0)
2594
2595 /* register physical memory.
2596    For RAM, 'size' must be a multiple of the target page size.
2597    If (phys_offset & ~TARGET_PAGE_MASK) != 0, then it is an
2598    io memory page.  The address used when calling the IO function is
2599    the offset from the start of the region, plus region_offset.  Both
2600    start_addr and region_offset are rounded down to a page boundary
2601    before calculating this offset.  This should not be a problem unless
2602    the low bits of start_addr and region_offset differ.  */
2603 void cpu_register_physical_memory_offset(target_phys_addr_t start_addr,
2604                                          ram_addr_t size,
2605                                          ram_addr_t phys_offset,
2606                                          ram_addr_t region_offset)
2607 {
2608     target_phys_addr_t addr, end_addr;
2609     PhysPageDesc *p;
2610     CPUState *env;
2611     ram_addr_t orig_size = size;
2612     subpage_t *subpage;
2613
2614     cpu_notify_set_memory(start_addr, size, phys_offset);
2615
2616     if (phys_offset == IO_MEM_UNASSIGNED) {
2617         region_offset = start_addr;
2618     }
2619     region_offset &= TARGET_PAGE_MASK;
2620     size = (size + TARGET_PAGE_SIZE - 1) & TARGET_PAGE_MASK;
2621     end_addr = start_addr + (target_phys_addr_t)size;
2622     for(addr = start_addr; addr != end_addr; addr += TARGET_PAGE_SIZE) {
2623         p = phys_page_find(addr >> TARGET_PAGE_BITS);
2624         if (p && p->phys_offset != IO_MEM_UNASSIGNED) {
2625             ram_addr_t orig_memory = p->phys_offset;
2626             target_phys_addr_t start_addr2, end_addr2;
2627             int need_subpage = 0;
2628
2629             CHECK_SUBPAGE(addr, start_addr, start_addr2, end_addr, end_addr2,
2630                           need_subpage);
2631             if (need_subpage) {
2632                 if (!(orig_memory & IO_MEM_SUBPAGE)) {
2633                     subpage = subpage_init((addr & TARGET_PAGE_MASK),
2634                                            &p->phys_offset, orig_memory,
2635                                            p->region_offset);
2636                 } else {
2637                     subpage = io_mem_opaque[(orig_memory & ~TARGET_PAGE_MASK)
2638                                             >> IO_MEM_SHIFT];
2639                 }
2640                 subpage_register(subpage, start_addr2, end_addr2, phys_offset,
2641                                  region_offset);
2642                 p->region_offset = 0;
2643             } else {
2644                 p->phys_offset = phys_offset;
2645                 if ((phys_offset & ~TARGET_PAGE_MASK) <= IO_MEM_ROM ||
2646                     (phys_offset & IO_MEM_ROMD))
2647                     phys_offset += TARGET_PAGE_SIZE;
2648             }
2649         } else {
2650             p = phys_page_find_alloc(addr >> TARGET_PAGE_BITS, 1);
2651             p->phys_offset = phys_offset;
2652             p->region_offset = region_offset;
2653             if ((phys_offset & ~TARGET_PAGE_MASK) <= IO_MEM_ROM ||
2654                 (phys_offset & IO_MEM_ROMD)) {
2655                 phys_offset += TARGET_PAGE_SIZE;
2656             } else {
2657                 target_phys_addr_t start_addr2, end_addr2;
2658                 int need_subpage = 0;
2659
2660                 CHECK_SUBPAGE(addr, start_addr, start_addr2, end_addr,
2661                               end_addr2, need_subpage);
2662
2663                 if (need_subpage) {
2664                     subpage = subpage_init((addr & TARGET_PAGE_MASK),
2665                                            &p->phys_offset, IO_MEM_UNASSIGNED,
2666                                            addr & TARGET_PAGE_MASK);
2667                     subpage_register(subpage, start_addr2, end_addr2,
2668                                      phys_offset, region_offset);
2669                     p->region_offset = 0;
2670                 }
2671             }
2672         }
2673         region_offset += TARGET_PAGE_SIZE;
2674     }
2675
2676     /* since each CPU stores ram addresses in its TLB cache, we must
2677        reset the modified entries */
2678     /* XXX: slow ! */
2679     for(env = first_cpu; env != NULL; env = env->next_cpu) {
2680         tlb_flush(env, 1);
2681     }
2682 }
2683
2684 /* XXX: temporary until new memory mapping API */
2685 ram_addr_t cpu_get_physical_page_desc(target_phys_addr_t addr)
2686 {
2687     PhysPageDesc *p;
2688
2689     p = phys_page_find(addr >> TARGET_PAGE_BITS);
2690     if (!p)
2691         return IO_MEM_UNASSIGNED;
2692     return p->phys_offset;
2693 }
2694
2695 void qemu_register_coalesced_mmio(target_phys_addr_t addr, ram_addr_t size)
2696 {
2697     if (kvm_enabled())
2698         kvm_coalesce_mmio_region(addr, size);
2699 }
2700
2701 void qemu_unregister_coalesced_mmio(target_phys_addr_t addr, ram_addr_t size)
2702 {
2703     if (kvm_enabled())
2704         kvm_uncoalesce_mmio_region(addr, size);
2705 }
2706
2707 void qemu_flush_coalesced_mmio_buffer(void)
2708 {
2709     if (kvm_enabled())
2710         kvm_flush_coalesced_mmio_buffer();
2711 }
2712
2713 #if defined(__linux__) && !defined(TARGET_S390X)
2714
2715 #include <sys/vfs.h>
2716
2717 #define HUGETLBFS_MAGIC       0x958458f6
2718
2719 static long gethugepagesize(const char *path)
2720 {
2721     struct statfs fs;
2722     int ret;
2723
2724     do {
2725         ret = statfs(path, &fs);
2726     } while (ret != 0 && errno == EINTR);
2727
2728     if (ret != 0) {
2729         perror(path);
2730         return 0;
2731     }
2732
2733     if (fs.f_type != HUGETLBFS_MAGIC)
2734         fprintf(stderr, "Warning: path not on HugeTLBFS: %s\n", path);
2735
2736     return fs.f_bsize;
2737 }
2738
2739 static void *file_ram_alloc(RAMBlock *block,
2740                             ram_addr_t memory,
2741                             const char *path)
2742 {
2743     char *filename;
2744     void *area;
2745     int fd;
2746 #ifdef MAP_POPULATE
2747     int flags;
2748 #endif
2749     unsigned long hpagesize;
2750
2751     hpagesize = gethugepagesize(path);
2752     if (!hpagesize) {
2753         return NULL;
2754     }
2755
2756     if (memory < hpagesize) {
2757         return NULL;
2758     }
2759
2760     if (kvm_enabled() && !kvm_has_sync_mmu()) {
2761         fprintf(stderr, "host lacks kvm mmu notifiers, -mem-path unsupported\n");
2762         return NULL;
2763     }
2764
2765     if (asprintf(&filename, "%s/qemu_back_mem.XXXXXX", path) == -1) {
2766         return NULL;
2767     }
2768
2769     fd = mkstemp(filename);
2770     if (fd < 0) {
2771         perror("unable to create backing store for hugepages");
2772         free(filename);
2773         return NULL;
2774     }
2775     unlink(filename);
2776     free(filename);
2777
2778     memory = (memory+hpagesize-1) & ~(hpagesize-1);
2779
2780     /*
2781      * ftruncate is not supported by hugetlbfs in older
2782      * hosts, so don't bother bailing out on errors.
2783      * If anything goes wrong with it under other filesystems,
2784      * mmap will fail.
2785      */
2786     if (ftruncate(fd, memory))
2787         perror("ftruncate");
2788
2789 #ifdef MAP_POPULATE
2790     /* NB: MAP_POPULATE won't exhaustively alloc all phys pages in the case
2791      * MAP_PRIVATE is requested.  For mem_prealloc we mmap as MAP_SHARED
2792      * to sidestep this quirk.
2793      */
2794     flags = mem_prealloc ? MAP_POPULATE | MAP_SHARED : MAP_PRIVATE;
2795     area = mmap(0, memory, PROT_READ | PROT_WRITE, flags, fd, 0);
2796 #else
2797     area = mmap(0, memory, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
2798 #endif
2799     if (area == MAP_FAILED) {
2800         perror("file_ram_alloc: can't mmap RAM pages");
2801         close(fd);
2802         return (NULL);
2803     }
2804     block->fd = fd;
2805     return area;
2806 }
2807 #endif
2808
2809 static ram_addr_t find_ram_offset(ram_addr_t size)
2810 {
2811     RAMBlock *block, *next_block;
2812     ram_addr_t offset = 0, mingap = ULONG_MAX;
2813
2814     if (QLIST_EMPTY(&ram_list.blocks))
2815         return 0;
2816
2817     QLIST_FOREACH(block, &ram_list.blocks, next) {
2818         ram_addr_t end, next = ULONG_MAX;
2819
2820         end = block->offset + block->length;
2821
2822         QLIST_FOREACH(next_block, &ram_list.blocks, next) {
2823             if (next_block->offset >= end) {
2824                 next = MIN(next, next_block->offset);
2825             }
2826         }
2827         if (next - end >= size && next - end < mingap) {
2828             offset =  end;
2829             mingap = next - end;
2830         }
2831     }
2832     return offset;
2833 }
2834
2835 static ram_addr_t last_ram_offset(void)
2836 {
2837     RAMBlock *block;
2838     ram_addr_t last = 0;
2839
2840     QLIST_FOREACH(block, &ram_list.blocks, next)
2841         last = MAX(last, block->offset + block->length);
2842
2843     return last;
2844 }
2845
2846 ram_addr_t qemu_ram_alloc_from_ptr(DeviceState *dev, const char *name,
2847                                    ram_addr_t size, void *host)
2848 {
2849     RAMBlock *new_block, *block;
2850
2851     size = TARGET_PAGE_ALIGN(size);
2852     new_block = qemu_mallocz(sizeof(*new_block));
2853
2854     if (dev && dev->parent_bus && dev->parent_bus->info->get_dev_path) {
2855         char *id = dev->parent_bus->info->get_dev_path(dev);
2856         if (id) {
2857             snprintf(new_block->idstr, sizeof(new_block->idstr), "%s/", id);
2858             qemu_free(id);
2859         }
2860     }
2861     pstrcat(new_block->idstr, sizeof(new_block->idstr), name);
2862
2863     QLIST_FOREACH(block, &ram_list.blocks, next) {
2864         if (!strcmp(block->idstr, new_block->idstr)) {
2865             fprintf(stderr, "RAMBlock \"%s\" already registered, abort!\n",
2866                     new_block->idstr);
2867             abort();
2868         }
2869     }
2870
2871     if (host) {
2872         new_block->host = host;
2873         new_block->flags |= RAM_PREALLOC_MASK;
2874     } else {
2875         if (mem_path) {
2876 #if defined (__linux__) && !defined(TARGET_S390X)
2877             new_block->host = file_ram_alloc(new_block, size, mem_path);
2878             if (!new_block->host) {
2879                 new_block->host = qemu_vmalloc(size);
2880                 qemu_madvise(new_block->host, size, QEMU_MADV_MERGEABLE);
2881             }
2882 #else
2883             fprintf(stderr, "-mem-path option unsupported\n");
2884             exit(1);
2885 #endif
2886         } else {
2887 #if defined(TARGET_S390X) && defined(CONFIG_KVM)
2888             /* XXX S390 KVM requires the topmost vma of the RAM to be < 256GB */
2889             new_block->host = mmap((void*)0x1000000, size,
2890                                    PROT_EXEC|PROT_READ|PROT_WRITE,
2891                                    MAP_SHARED | MAP_ANONYMOUS, -1, 0);
2892 #else
2893             new_block->host = qemu_vmalloc(size);
2894 #endif
2895             qemu_madvise(new_block->host, size, QEMU_MADV_MERGEABLE);
2896         }
2897     }
2898
2899     new_block->offset = find_ram_offset(size);
2900     new_block->length = size;
2901
2902     QLIST_INSERT_HEAD(&ram_list.blocks, new_block, next);
2903
2904     ram_list.phys_dirty = qemu_realloc(ram_list.phys_dirty,
2905                                        last_ram_offset() >> TARGET_PAGE_BITS);
2906     memset(ram_list.phys_dirty + (new_block->offset >> TARGET_PAGE_BITS),
2907            0xff, size >> TARGET_PAGE_BITS);
2908
2909     if (kvm_enabled())
2910         kvm_setup_guest_memory(new_block->host, size);
2911
2912     return new_block->offset;
2913 }
2914
2915 ram_addr_t qemu_ram_alloc(DeviceState *dev, const char *name, ram_addr_t size)
2916 {
2917     return qemu_ram_alloc_from_ptr(dev, name, size, NULL);
2918 }
2919
2920 void qemu_ram_free(ram_addr_t addr)
2921 {
2922     RAMBlock *block;
2923
2924     QLIST_FOREACH(block, &ram_list.blocks, next) {
2925         if (addr == block->offset) {
2926             QLIST_REMOVE(block, next);
2927             if (block->flags & RAM_PREALLOC_MASK) {
2928                 ;
2929             } else if (mem_path) {
2930 #if defined (__linux__) && !defined(TARGET_S390X)
2931                 if (block->fd) {
2932                     munmap(block->host, block->length);
2933                     close(block->fd);
2934                 } else {
2935                     qemu_vfree(block->host);
2936                 }
2937 #else
2938                 abort();
2939 #endif
2940             } else {
2941 #if defined(TARGET_S390X) && defined(CONFIG_KVM)
2942                 munmap(block->host, block->length);
2943 #else
2944                 qemu_vfree(block->host);
2945 #endif
2946             }
2947             qemu_free(block);
2948             return;
2949         }
2950     }
2951
2952 }
2953
2954 #ifndef _WIN32
2955 void qemu_ram_remap(ram_addr_t addr, ram_addr_t length)
2956 {
2957     RAMBlock *block;
2958     ram_addr_t offset;
2959     int flags;
2960     void *area, *vaddr;
2961
2962     QLIST_FOREACH(block, &ram_list.blocks, next) {
2963         offset = addr - block->offset;
2964         if (offset < block->length) {
2965             vaddr = block->host + offset;
2966             if (block->flags & RAM_PREALLOC_MASK) {
2967                 ;
2968             } else {
2969                 flags = MAP_FIXED;
2970                 munmap(vaddr, length);
2971                 if (mem_path) {
2972 #if defined(__linux__) && !defined(TARGET_S390X)
2973                     if (block->fd) {
2974 #ifdef MAP_POPULATE
2975                         flags |= mem_prealloc ? MAP_POPULATE | MAP_SHARED :
2976                             MAP_PRIVATE;
2977 #else
2978                         flags |= MAP_PRIVATE;
2979 #endif
2980                         area = mmap(vaddr, length, PROT_READ | PROT_WRITE,
2981                                     flags, block->fd, offset);
2982                     } else {
2983                         flags |= MAP_PRIVATE | MAP_ANONYMOUS;
2984                         area = mmap(vaddr, length, PROT_READ | PROT_WRITE,
2985                                     flags, -1, 0);
2986                     }
2987 #else
2988                     abort();
2989 #endif
2990                 } else {
2991 #if defined(TARGET_S390X) && defined(CONFIG_KVM)
2992                     flags |= MAP_SHARED | MAP_ANONYMOUS;
2993                     area = mmap(vaddr, length, PROT_EXEC|PROT_READ|PROT_WRITE,
2994                                 flags, -1, 0);
2995 #else
2996                     flags |= MAP_PRIVATE | MAP_ANONYMOUS;
2997                     area = mmap(vaddr, length, PROT_READ | PROT_WRITE,
2998                                 flags, -1, 0);
2999 #endif
3000                 }
3001                 if (area != vaddr) {
3002                     fprintf(stderr, "Could not remap addr: %lx@%lx\n",
3003                             length, addr);
3004                     exit(1);
3005                 }
3006                 qemu_madvise(vaddr, length, QEMU_MADV_MERGEABLE);
3007             }
3008             return;
3009         }
3010     }
3011 }
3012 #endif /* !_WIN32 */
3013
3014 /* Return a host pointer to ram allocated with qemu_ram_alloc.
3015    With the exception of the softmmu code in this file, this should
3016    only be used for local memory (e.g. video ram) that the device owns,
3017    and knows it isn't going to access beyond the end of the block.
3018
3019    It should not be used for general purpose DMA.
3020    Use cpu_physical_memory_map/cpu_physical_memory_rw instead.
3021  */
3022 void *qemu_get_ram_ptr(ram_addr_t addr)
3023 {
3024     RAMBlock *block;
3025
3026     QLIST_FOREACH(block, &ram_list.blocks, next) {
3027         if (addr - block->offset < block->length) {
3028             /* Move this entry to to start of the list.  */
3029             if (block != QLIST_FIRST(&ram_list.blocks)) {
3030                 QLIST_REMOVE(block, next);
3031                 QLIST_INSERT_HEAD(&ram_list.blocks, block, next);
3032             }
3033             return block->host + (addr - block->offset);
3034         }
3035     }
3036
3037     fprintf(stderr, "Bad ram offset %" PRIx64 "\n", (uint64_t)addr);
3038     abort();
3039
3040     return NULL;
3041 }
3042
3043 /* Return a host pointer to ram allocated with qemu_ram_alloc.
3044  * Same as qemu_get_ram_ptr but avoid reordering ramblocks.
3045  */
3046 void *qemu_safe_ram_ptr(ram_addr_t addr)
3047 {
3048     RAMBlock *block;
3049
3050     QLIST_FOREACH(block, &ram_list.blocks, next) {
3051         if (addr - block->offset < block->length) {
3052             return block->host + (addr - block->offset);
3053         }
3054     }
3055
3056     fprintf(stderr, "Bad ram offset %" PRIx64 "\n", (uint64_t)addr);
3057     abort();
3058
3059     return NULL;
3060 }
3061
3062 int qemu_ram_addr_from_host(void *ptr, ram_addr_t *ram_addr)
3063 {
3064     RAMBlock *block;
3065     uint8_t *host = ptr;
3066
3067     QLIST_FOREACH(block, &ram_list.blocks, next) {
3068         if (host - block->host < block->length) {
3069             *ram_addr = block->offset + (host - block->host);
3070             return 0;
3071         }
3072     }
3073     return -1;
3074 }
3075
3076 /* Some of the softmmu routines need to translate from a host pointer
3077    (typically a TLB entry) back to a ram offset.  */
3078 ram_addr_t qemu_ram_addr_from_host_nofail(void *ptr)
3079 {
3080     ram_addr_t ram_addr;
3081
3082     if (qemu_ram_addr_from_host(ptr, &ram_addr)) {
3083         fprintf(stderr, "Bad ram pointer %p\n", ptr);
3084         abort();
3085     }
3086     return ram_addr;
3087 }
3088
3089 static uint32_t unassigned_mem_readb(void *opaque, target_phys_addr_t addr)
3090 {
3091 #ifdef DEBUG_UNASSIGNED
3092     printf("Unassigned mem read " TARGET_FMT_plx "\n", addr);
3093 #endif
3094 #if defined(TARGET_SPARC) || defined(TARGET_MICROBLAZE)
3095     do_unassigned_access(addr, 0, 0, 0, 1);
3096 #endif
3097     return 0;
3098 }
3099
3100 static uint32_t unassigned_mem_readw(void *opaque, target_phys_addr_t addr)
3101 {
3102 #ifdef DEBUG_UNASSIGNED
3103     printf("Unassigned mem read " TARGET_FMT_plx "\n", addr);
3104 #endif
3105 #if defined(TARGET_SPARC) || defined(TARGET_MICROBLAZE)
3106     do_unassigned_access(addr, 0, 0, 0, 2);
3107 #endif
3108     return 0;
3109 }
3110
3111 static uint32_t unassigned_mem_readl(void *opaque, target_phys_addr_t addr)
3112 {
3113 #ifdef DEBUG_UNASSIGNED
3114     printf("Unassigned mem read " TARGET_FMT_plx "\n", addr);
3115 #endif
3116 #if defined(TARGET_SPARC) || defined(TARGET_MICROBLAZE)
3117     do_unassigned_access(addr, 0, 0, 0, 4);
3118 #endif
3119     return 0;
3120 }
3121
3122 static void unassigned_mem_writeb(void *opaque, target_phys_addr_t addr, uint32_t val)
3123 {
3124 #ifdef DEBUG_UNASSIGNED
3125     printf("Unassigned mem write " TARGET_FMT_plx " = 0x%x\n", addr, val);
3126 #endif
3127 #if defined(TARGET_SPARC) || defined(TARGET_MICROBLAZE)
3128     do_unassigned_access(addr, 1, 0, 0, 1);
3129 #endif
3130 }
3131
3132 static void unassigned_mem_writew(void *opaque, target_phys_addr_t addr, uint32_t val)
3133 {
3134 #ifdef DEBUG_UNASSIGNED
3135     printf("Unassigned mem write " TARGET_FMT_plx " = 0x%x\n", addr, val);
3136 #endif
3137 #if defined(TARGET_SPARC) || defined(TARGET_MICROBLAZE)
3138     do_unassigned_access(addr, 1, 0, 0, 2);
3139 #endif
3140 }
3141
3142 static void unassigned_mem_writel(void *opaque, target_phys_addr_t addr, uint32_t val)
3143 {
3144 #ifdef DEBUG_UNASSIGNED
3145     printf("Unassigned mem write " TARGET_FMT_plx " = 0x%x\n", addr, val);
3146 #endif
3147 #if defined(TARGET_SPARC) || defined(TARGET_MICROBLAZE)
3148     do_unassigned_access(addr, 1, 0, 0, 4);
3149 #endif
3150 }
3151
3152 static CPUReadMemoryFunc * const unassigned_mem_read[3] = {
3153     unassigned_mem_readb,
3154     unassigned_mem_readw,
3155     unassigned_mem_readl,
3156 };
3157
3158 static CPUWriteMemoryFunc * const unassigned_mem_write[3] = {
3159     unassigned_mem_writeb,
3160     unassigned_mem_writew,
3161     unassigned_mem_writel,
3162 };
3163
3164 static void notdirty_mem_writeb(void *opaque, target_phys_addr_t ram_addr,
3165                                 uint32_t val)
3166 {
3167     int dirty_flags;
3168     dirty_flags = cpu_physical_memory_get_dirty_flags(ram_addr);
3169     if (!(dirty_flags & CODE_DIRTY_FLAG)) {
3170 #if !defined(CONFIG_USER_ONLY)
3171         tb_invalidate_phys_page_fast(ram_addr, 1);
3172         dirty_flags = cpu_physical_memory_get_dirty_flags(ram_addr);
3173 #endif
3174     }
3175     stb_p(qemu_get_ram_ptr(ram_addr), val);
3176     dirty_flags |= (0xff & ~CODE_DIRTY_FLAG);
3177     cpu_physical_memory_set_dirty_flags(ram_addr, dirty_flags);
3178     /* we remove the notdirty callback only if the code has been
3179        flushed */
3180     if (dirty_flags == 0xff)
3181         tlb_set_dirty(cpu_single_env, cpu_single_env->mem_io_vaddr);
3182 }
3183
3184 static void notdirty_mem_writew(void *opaque, target_phys_addr_t ram_addr,
3185                                 uint32_t val)
3186 {
3187     int dirty_flags;
3188     dirty_flags = cpu_physical_memory_get_dirty_flags(ram_addr);
3189     if (!(dirty_flags & CODE_DIRTY_FLAG)) {
3190 #if !defined(CONFIG_USER_ONLY)
3191         tb_invalidate_phys_page_fast(ram_addr, 2);
3192         dirty_flags = cpu_physical_memory_get_dirty_flags(ram_addr);
3193 #endif
3194     }
3195     stw_p(qemu_get_ram_ptr(ram_addr), val);
3196     dirty_flags |= (0xff & ~CODE_DIRTY_FLAG);
3197     cpu_physical_memory_set_dirty_flags(ram_addr, dirty_flags);
3198     /* we remove the notdirty callback only if the code has been
3199        flushed */
3200     if (dirty_flags == 0xff)
3201         tlb_set_dirty(cpu_single_env, cpu_single_env->mem_io_vaddr);
3202 }
3203
3204 static void notdirty_mem_writel(void *opaque, target_phys_addr_t ram_addr,
3205                                 uint32_t val)
3206 {
3207     int dirty_flags;
3208     dirty_flags = cpu_physical_memory_get_dirty_flags(ram_addr);
3209     if (!(dirty_flags & CODE_DIRTY_FLAG)) {
3210 #if !defined(CONFIG_USER_ONLY)
3211         tb_invalidate_phys_page_fast(ram_addr, 4);
3212         dirty_flags = cpu_physical_memory_get_dirty_flags(ram_addr);
3213 #endif
3214     }
3215     stl_p(qemu_get_ram_ptr(ram_addr), val);
3216     dirty_flags |= (0xff & ~CODE_DIRTY_FLAG);
3217     cpu_physical_memory_set_dirty_flags(ram_addr, dirty_flags);
3218     /* we remove the notdirty callback only if the code has been
3219        flushed */
3220     if (dirty_flags == 0xff)
3221         tlb_set_dirty(cpu_single_env, cpu_single_env->mem_io_vaddr);
3222 }
3223
3224 static CPUReadMemoryFunc * const error_mem_read[3] = {
3225     NULL, /* never used */
3226     NULL, /* never used */
3227     NULL, /* never used */
3228 };
3229
3230 static CPUWriteMemoryFunc * const notdirty_mem_write[3] = {
3231     notdirty_mem_writeb,
3232     notdirty_mem_writew,
3233     notdirty_mem_writel,
3234 };
3235
3236 /* Generate a debug exception if a watchpoint has been hit.  */
3237 static void check_watchpoint(int offset, int len_mask, int flags)
3238 {
3239     CPUState *env = cpu_single_env;
3240     target_ulong pc, cs_base;
3241     TranslationBlock *tb;
3242     target_ulong vaddr;
3243     CPUWatchpoint *wp;
3244     int cpu_flags;
3245
3246     if (env->watchpoint_hit) {
3247         /* We re-entered the check after replacing the TB. Now raise
3248          * the debug interrupt so that is will trigger after the
3249          * current instruction. */
3250         cpu_interrupt(env, CPU_INTERRUPT_DEBUG);
3251         return;
3252     }
3253     vaddr = (env->mem_io_vaddr & TARGET_PAGE_MASK) + offset;
3254     QTAILQ_FOREACH(wp, &env->watchpoints, entry) {
3255         if ((vaddr == (wp->vaddr & len_mask) ||
3256              (vaddr & wp->len_mask) == wp->vaddr) && (wp->flags & flags)) {
3257             wp->flags |= BP_WATCHPOINT_HIT;
3258             if (!env->watchpoint_hit) {
3259                 env->watchpoint_hit = wp;
3260                 tb = tb_find_pc(env->mem_io_pc);
3261                 if (!tb) {
3262                     cpu_abort(env, "check_watchpoint: could not find TB for "
3263                               "pc=%p", (void *)env->mem_io_pc);
3264                 }
3265                 cpu_restore_state(tb, env, env->mem_io_pc, NULL);
3266                 tb_phys_invalidate(tb, -1);
3267                 if (wp->flags & BP_STOP_BEFORE_ACCESS) {
3268                     env->exception_index = EXCP_DEBUG;
3269                 } else {
3270                     cpu_get_tb_cpu_state(env, &pc, &cs_base, &cpu_flags);
3271                     tb_gen_code(env, pc, cs_base, cpu_flags, 1);
3272                 }
3273                 cpu_resume_from_signal(env, NULL);
3274             }
3275         } else {
3276             wp->flags &= ~BP_WATCHPOINT_HIT;
3277         }
3278     }
3279 }
3280
3281 /* Watchpoint access routines.  Watchpoints are inserted using TLB tricks,
3282    so these check for a hit then pass through to the normal out-of-line
3283    phys routines.  */
3284 static uint32_t watch_mem_readb(void *opaque, target_phys_addr_t addr)
3285 {
3286     check_watchpoint(addr & ~TARGET_PAGE_MASK, ~0x0, BP_MEM_READ);
3287     return ldub_phys(addr);
3288 }
3289
3290 static uint32_t watch_mem_readw(void *opaque, target_phys_addr_t addr)
3291 {
3292     check_watchpoint(addr & ~TARGET_PAGE_MASK, ~0x1, BP_MEM_READ);
3293     return lduw_phys(addr);
3294 }
3295
3296 static uint32_t watch_mem_readl(void *opaque, target_phys_addr_t addr)
3297 {
3298     check_watchpoint(addr & ~TARGET_PAGE_MASK, ~0x3, BP_MEM_READ);
3299     return ldl_phys(addr);
3300 }
3301
3302 static void watch_mem_writeb(void *opaque, target_phys_addr_t addr,
3303                              uint32_t val)
3304 {
3305     check_watchpoint(addr & ~TARGET_PAGE_MASK, ~0x0, BP_MEM_WRITE);
3306     stb_phys(addr, val);
3307 }
3308
3309 static void watch_mem_writew(void *opaque, target_phys_addr_t addr,
3310                              uint32_t val)
3311 {
3312     check_watchpoint(addr & ~TARGET_PAGE_MASK, ~0x1, BP_MEM_WRITE);
3313     stw_phys(addr, val);
3314 }
3315
3316 static void watch_mem_writel(void *opaque, target_phys_addr_t addr,
3317                              uint32_t val)
3318 {
3319     check_watchpoint(addr & ~TARGET_PAGE_MASK, ~0x3, BP_MEM_WRITE);
3320     stl_phys(addr, val);
3321 }
3322
3323 static CPUReadMemoryFunc * const watch_mem_read[3] = {
3324     watch_mem_readb,
3325     watch_mem_readw,
3326     watch_mem_readl,
3327 };
3328
3329 static CPUWriteMemoryFunc * const watch_mem_write[3] = {
3330     watch_mem_writeb,
3331     watch_mem_writew,
3332     watch_mem_writel,
3333 };
3334
3335 static inline uint32_t subpage_readlen (subpage_t *mmio,
3336                                         target_phys_addr_t addr,
3337                                         unsigned int len)
3338 {
3339     unsigned int idx = SUBPAGE_IDX(addr);
3340 #if defined(DEBUG_SUBPAGE)
3341     printf("%s: subpage %p len %d addr " TARGET_FMT_plx " idx %d\n", __func__,
3342            mmio, len, addr, idx);
3343 #endif
3344
3345     addr += mmio->region_offset[idx];
3346     idx = mmio->sub_io_index[idx];
3347     return io_mem_read[idx][len](io_mem_opaque[idx], addr);
3348 }
3349
3350 static inline void subpage_writelen (subpage_t *mmio, target_phys_addr_t addr,
3351                                      uint32_t value, unsigned int len)
3352 {
3353     unsigned int idx = SUBPAGE_IDX(addr);
3354 #if defined(DEBUG_SUBPAGE)
3355     printf("%s: subpage %p len %d addr " TARGET_FMT_plx " idx %d value %08x\n",
3356            __func__, mmio, len, addr, idx, value);
3357 #endif
3358
3359     addr += mmio->region_offset[idx];
3360     idx = mmio->sub_io_index[idx];
3361     io_mem_write[idx][len](io_mem_opaque[idx], addr, value);
3362 }
3363
3364 static uint32_t subpage_readb (void *opaque, target_phys_addr_t addr)
3365 {
3366     return subpage_readlen(opaque, addr, 0);
3367 }
3368
3369 static void subpage_writeb (void *opaque, target_phys_addr_t addr,
3370                             uint32_t value)
3371 {
3372     subpage_writelen(opaque, addr, value, 0);
3373 }
3374
3375 static uint32_t subpage_readw (void *opaque, target_phys_addr_t addr)
3376 {
3377     return subpage_readlen(opaque, addr, 1);
3378 }
3379
3380 static void subpage_writew (void *opaque, target_phys_addr_t addr,
3381                             uint32_t value)
3382 {
3383     subpage_writelen(opaque, addr, value, 1);
3384 }
3385
3386 static uint32_t subpage_readl (void *opaque, target_phys_addr_t addr)
3387 {
3388     return subpage_readlen(opaque, addr, 2);
3389 }
3390
3391 static void subpage_writel (void *opaque, target_phys_addr_t addr,
3392                             uint32_t value)
3393 {
3394     subpage_writelen(opaque, addr, value, 2);
3395 }
3396
3397 static CPUReadMemoryFunc * const subpage_read[] = {
3398     &subpage_readb,
3399     &subpage_readw,
3400     &subpage_readl,
3401 };
3402
3403 static CPUWriteMemoryFunc * const subpage_write[] = {
3404     &subpage_writeb,
3405     &subpage_writew,
3406     &subpage_writel,
3407 };
3408
3409 static int subpage_register (subpage_t *mmio, uint32_t start, uint32_t end,
3410                              ram_addr_t memory, ram_addr_t region_offset)
3411 {
3412     int idx, eidx;
3413
3414     if (start >= TARGET_PAGE_SIZE || end >= TARGET_PAGE_SIZE)
3415         return -1;
3416     idx = SUBPAGE_IDX(start);
3417     eidx = SUBPAGE_IDX(end);
3418 #if defined(DEBUG_SUBPAGE)
3419     printf("%s: %p start %08x end %08x idx %08x eidx %08x mem %ld\n", __func__,
3420            mmio, start, end, idx, eidx, memory);
3421 #endif
3422     if ((memory & ~TARGET_PAGE_MASK) == IO_MEM_RAM)
3423         memory = IO_MEM_UNASSIGNED;
3424     memory = (memory >> IO_MEM_SHIFT) & (IO_MEM_NB_ENTRIES - 1);
3425     for (; idx <= eidx; idx++) {
3426         mmio->sub_io_index[idx] = memory;
3427         mmio->region_offset[idx] = region_offset;
3428     }
3429
3430     return 0;
3431 }
3432
3433 static subpage_t *subpage_init (target_phys_addr_t base, ram_addr_t *phys,
3434                                 ram_addr_t orig_memory,
3435                                 ram_addr_t region_offset)
3436 {
3437     subpage_t *mmio;
3438     int subpage_memory;
3439
3440     mmio = qemu_mallocz(sizeof(subpage_t));
3441
3442     mmio->base = base;
3443     subpage_memory = cpu_register_io_memory(subpage_read, subpage_write, mmio,
3444                                             DEVICE_NATIVE_ENDIAN);
3445 #if defined(DEBUG_SUBPAGE)
3446     printf("%s: %p base " TARGET_FMT_plx " len %08x %d\n", __func__,
3447            mmio, base, TARGET_PAGE_SIZE, subpage_memory);
3448 #endif
3449     *phys = subpage_memory | IO_MEM_SUBPAGE;
3450     subpage_register(mmio, 0, TARGET_PAGE_SIZE-1, orig_memory, region_offset);
3451
3452     return mmio;
3453 }
3454
3455 static int get_free_io_mem_idx(void)
3456 {
3457     int i;
3458
3459     for (i = 0; i<IO_MEM_NB_ENTRIES; i++)
3460         if (!io_mem_used[i]) {
3461             io_mem_used[i] = 1;
3462             return i;
3463         }
3464     fprintf(stderr, "RAN out out io_mem_idx, max %d !\n", IO_MEM_NB_ENTRIES);
3465     return -1;
3466 }
3467
3468 /*
3469  * Usually, devices operate in little endian mode. There are devices out
3470  * there that operate in big endian too. Each device gets byte swapped
3471  * mmio if plugged onto a CPU that does the other endianness.
3472  *
3473  * CPU          Device           swap?
3474  *
3475  * little       little           no
3476  * little       big              yes
3477  * big          little           yes
3478  * big          big              no
3479  */
3480
3481 typedef struct SwapEndianContainer {
3482     CPUReadMemoryFunc *read[3];
3483     CPUWriteMemoryFunc *write[3];
3484     void *opaque;
3485 } SwapEndianContainer;
3486
3487 static uint32_t swapendian_mem_readb (void *opaque, target_phys_addr_t addr)
3488 {
3489     uint32_t val;
3490     SwapEndianContainer *c = opaque;
3491     val = c->read[0](c->opaque, addr);
3492     return val;
3493 }
3494
3495 static uint32_t swapendian_mem_readw(void *opaque, target_phys_addr_t addr)
3496 {
3497     uint32_t val;
3498     SwapEndianContainer *c = opaque;
3499     val = bswap16(c->read[1](c->opaque, addr));
3500     return val;
3501 }
3502
3503 static uint32_t swapendian_mem_readl(void *opaque, target_phys_addr_t addr)
3504 {
3505     uint32_t val;
3506     SwapEndianContainer *c = opaque;
3507     val = bswap32(c->read[2](c->opaque, addr));
3508     return val;
3509 }
3510
3511 static CPUReadMemoryFunc * const swapendian_readfn[3]={
3512     swapendian_mem_readb,
3513     swapendian_mem_readw,
3514     swapendian_mem_readl
3515 };
3516
3517 static void swapendian_mem_writeb(void *opaque, target_phys_addr_t addr,
3518                                   uint32_t val)
3519 {
3520     SwapEndianContainer *c = opaque;
3521     c->write[0](c->opaque, addr, val);
3522 }
3523
3524 static void swapendian_mem_writew(void *opaque, target_phys_addr_t addr,
3525                                   uint32_t val)
3526 {
3527     SwapEndianContainer *c = opaque;
3528     c->write[1](c->opaque, addr, bswap16(val));
3529 }
3530
3531 static void swapendian_mem_writel(void *opaque, target_phys_addr_t addr,
3532                                   uint32_t val)
3533 {
3534     SwapEndianContainer *c = opaque;
3535     c->write[2](c->opaque, addr, bswap32(val));
3536 }
3537
3538 static CPUWriteMemoryFunc * const swapendian_writefn[3]={
3539     swapendian_mem_writeb,
3540     swapendian_mem_writew,
3541     swapendian_mem_writel
3542 };
3543
3544 static void swapendian_init(int io_index)
3545 {
3546     SwapEndianContainer *c = qemu_malloc(sizeof(SwapEndianContainer));
3547     int i;
3548
3549     /* Swap mmio for big endian targets */
3550     c->opaque = io_mem_opaque[io_index];
3551     for (i = 0; i < 3; i++) {
3552         c->read[i] = io_mem_read[io_index][i];
3553         c->write[i] = io_mem_write[io_index][i];
3554
3555         io_mem_read[io_index][i] = swapendian_readfn[i];
3556         io_mem_write[io_index][i] = swapendian_writefn[i];
3557     }
3558     io_mem_opaque[io_index] = c;
3559 }
3560
3561 static void swapendian_del(int io_index)
3562 {
3563     if (io_mem_read[io_index][0] == swapendian_readfn[0]) {
3564         qemu_free(io_mem_opaque[io_index]);
3565     }
3566 }
3567
3568 /* mem_read and mem_write are arrays of functions containing the
3569    function to access byte (index 0), word (index 1) and dword (index
3570    2). Functions can be omitted with a NULL function pointer.
3571    If io_index is non zero, the corresponding io zone is
3572    modified. If it is zero, a new io zone is allocated. The return
3573    value can be used with cpu_register_physical_memory(). (-1) is
3574    returned if error. */
3575 static int cpu_register_io_memory_fixed(int io_index,
3576                                         CPUReadMemoryFunc * const *mem_read,
3577                                         CPUWriteMemoryFunc * const *mem_write,
3578                                         void *opaque, enum device_endian endian)
3579 {
3580     int i;
3581
3582     if (io_index <= 0) {
3583         io_index = get_free_io_mem_idx();
3584         if (io_index == -1)
3585             return io_index;
3586     } else {
3587         io_index >>= IO_MEM_SHIFT;
3588         if (io_index >= IO_MEM_NB_ENTRIES)
3589             return -1;
3590     }
3591
3592     for (i = 0; i < 3; ++i) {
3593         io_mem_read[io_index][i]
3594             = (mem_read[i] ? mem_read[i] : unassigned_mem_read[i]);
3595     }
3596     for (i = 0; i < 3; ++i) {
3597         io_mem_write[io_index][i]
3598             = (mem_write[i] ? mem_write[i] : unassigned_mem_write[i]);
3599     }
3600     io_mem_opaque[io_index] = opaque;
3601
3602     switch (endian) {
3603     case DEVICE_BIG_ENDIAN:
3604 #ifndef TARGET_WORDS_BIGENDIAN
3605         swapendian_init(io_index);
3606 #endif
3607         break;
3608     case DEVICE_LITTLE_ENDIAN:
3609 #ifdef TARGET_WORDS_BIGENDIAN
3610         swapendian_init(io_index);
3611 #endif
3612         break;
3613     case DEVICE_NATIVE_ENDIAN:
3614     default:
3615         break;
3616     }
3617
3618     return (io_index << IO_MEM_SHIFT);
3619 }
3620
3621 int cpu_register_io_memory(CPUReadMemoryFunc * const *mem_read,
3622                            CPUWriteMemoryFunc * const *mem_write,
3623                            void *opaque, enum device_endian endian)
3624 {
3625     return cpu_register_io_memory_fixed(0, mem_read, mem_write, opaque, endian);
3626 }
3627
3628 void cpu_unregister_io_memory(int io_table_address)
3629 {
3630     int i;
3631     int io_index = io_table_address >> IO_MEM_SHIFT;
3632
3633     swapendian_del(io_index);
3634
3635     for (i=0;i < 3; i++) {
3636         io_mem_read[io_index][i] = unassigned_mem_read[i];
3637         io_mem_write[io_index][i] = unassigned_mem_write[i];
3638     }
3639     io_mem_opaque[io_index] = NULL;
3640     io_mem_used[io_index] = 0;
3641 }
3642
3643 static void io_mem_init(void)
3644 {
3645     int i;
3646
3647     cpu_register_io_memory_fixed(IO_MEM_ROM, error_mem_read,
3648                                  unassigned_mem_write, NULL,
3649                                  DEVICE_NATIVE_ENDIAN);
3650     cpu_register_io_memory_fixed(IO_MEM_UNASSIGNED, unassigned_mem_read,
3651                                  unassigned_mem_write, NULL,
3652                                  DEVICE_NATIVE_ENDIAN);
3653     cpu_register_io_memory_fixed(IO_MEM_NOTDIRTY, error_mem_read,
3654                                  notdirty_mem_write, NULL,
3655                                  DEVICE_NATIVE_ENDIAN);
3656     for (i=0; i<5; i++)
3657         io_mem_used[i] = 1;
3658
3659     io_mem_watch = cpu_register_io_memory(watch_mem_read,
3660                                           watch_mem_write, NULL,
3661                                           DEVICE_NATIVE_ENDIAN);
3662 }
3663
3664 #endif /* !defined(CONFIG_USER_ONLY) */
3665
3666 /* physical memory access (slow version, mainly for debug) */
3667 #if defined(CONFIG_USER_ONLY)
3668 int cpu_memory_rw_debug(CPUState *env, target_ulong addr,
3669                         uint8_t *buf, int len, int is_write)
3670 {
3671     int l, flags;
3672     target_ulong page;
3673     void * p;
3674
3675     while (len > 0) {
3676         page = addr & TARGET_PAGE_MASK;
3677         l = (page + TARGET_PAGE_SIZE) - addr;
3678         if (l > len)
3679             l = len;
3680         flags = page_get_flags(page);
3681         if (!(flags & PAGE_VALID))
3682             return -1;
3683         if (is_write) {
3684             if (!(flags & PAGE_WRITE))
3685                 return -1;
3686             /* XXX: this code should not depend on lock_user */
3687             if (!(p = lock_user(VERIFY_WRITE, addr, l, 0)))
3688                 return -1;
3689             memcpy(p, buf, l);
3690             unlock_user(p, addr, l);
3691         } else {
3692             if (!(flags & PAGE_READ))
3693                 return -1;
3694             /* XXX: this code should not depend on lock_user */
3695             if (!(p = lock_user(VERIFY_READ, addr, l, 1)))
3696                 return -1;
3697             memcpy(buf, p, l);
3698             unlock_user(p, addr, 0);
3699         }
3700         len -= l;
3701         buf += l;
3702         addr += l;
3703     }
3704     return 0;
3705 }
3706
3707 #else
3708 void cpu_physical_memory_rw(target_phys_addr_t addr, uint8_t *buf,
3709                             int len, int is_write)
3710 {
3711     int l, io_index;
3712     uint8_t *ptr;
3713     uint32_t val;
3714     target_phys_addr_t page;
3715     unsigned long pd;
3716     PhysPageDesc *p;
3717
3718     while (len > 0) {
3719         page = addr & TARGET_PAGE_MASK;
3720         l = (page + TARGET_PAGE_SIZE) - addr;
3721         if (l > len)
3722             l = len;
3723         p = phys_page_find(page >> TARGET_PAGE_BITS);
3724         if (!p) {
3725             pd = IO_MEM_UNASSIGNED;
3726         } else {
3727             pd = p->phys_offset;
3728         }
3729
3730         if (is_write) {
3731             if ((pd & ~TARGET_PAGE_MASK) != IO_MEM_RAM) {
3732                 target_phys_addr_t addr1 = addr;
3733                 io_index = (pd >> IO_MEM_SHIFT) & (IO_MEM_NB_ENTRIES - 1);
3734                 if (p)
3735                     addr1 = (addr & ~TARGET_PAGE_MASK) + p->region_offset;
3736                 /* XXX: could force cpu_single_env to NULL to avoid
3737                    potential bugs */
3738                 if (l >= 4 && ((addr1 & 3) == 0)) {
3739                     /* 32 bit write access */
3740                     val = ldl_p(buf);
3741                     io_mem_write[io_index][2](io_mem_opaque[io_index], addr1, val);
3742                     l = 4;
3743                 } else if (l >= 2 && ((addr1 & 1) == 0)) {
3744                     /* 16 bit write access */
3745                     val = lduw_p(buf);
3746                     io_mem_write[io_index][1](io_mem_opaque[io_index], addr1, val);
3747                     l = 2;
3748                 } else {
3749                     /* 8 bit write access */
3750                     val = ldub_p(buf);
3751                     io_mem_write[io_index][0](io_mem_opaque[io_index], addr1, val);
3752                     l = 1;
3753                 }
3754             } else {
3755                 unsigned long addr1;
3756                 addr1 = (pd & TARGET_PAGE_MASK) + (addr & ~TARGET_PAGE_MASK);
3757                 /* RAM case */
3758                 ptr = qemu_get_ram_ptr(addr1);
3759                 memcpy(ptr, buf, l);
3760                 if (!cpu_physical_memory_is_dirty(addr1)) {
3761                     /* invalidate code */
3762                     tb_invalidate_phys_page_range(addr1, addr1 + l, 0);
3763                     /* set dirty bit */
3764                     cpu_physical_memory_set_dirty_flags(
3765                         addr1, (0xff & ~CODE_DIRTY_FLAG));
3766                 }
3767             }
3768         } else {
3769             if ((pd & ~TARGET_PAGE_MASK) > IO_MEM_ROM &&
3770                 !(pd & IO_MEM_ROMD)) {
3771                 target_phys_addr_t addr1 = addr;
3772                 /* I/O case */
3773                 io_index = (pd >> IO_MEM_SHIFT) & (IO_MEM_NB_ENTRIES - 1);
3774                 if (p)
3775                     addr1 = (addr & ~TARGET_PAGE_MASK) + p->region_offset;
3776                 if (l >= 4 && ((addr1 & 3) == 0)) {
3777                     /* 32 bit read access */
3778                     val = io_mem_read[io_index][2](io_mem_opaque[io_index], addr1);
3779                     stl_p(buf, val);
3780                     l = 4;
3781                 } else if (l >= 2 && ((addr1 & 1) == 0)) {
3782                     /* 16 bit read access */
3783                     val = io_mem_read[io_index][1](io_mem_opaque[io_index], addr1);
3784                     stw_p(buf, val);
3785                     l = 2;
3786                 } else {
3787                     /* 8 bit read access */
3788                     val = io_mem_read[io_index][0](io_mem_opaque[io_index], addr1);
3789                     stb_p(buf, val);
3790                     l = 1;
3791                 }
3792             } else {
3793                 /* RAM case */
3794                 ptr = qemu_get_ram_ptr(pd & TARGET_PAGE_MASK) +
3795                     (addr & ~TARGET_PAGE_MASK);
3796                 memcpy(buf, ptr, l);
3797             }
3798         }
3799         len -= l;
3800         buf += l;
3801         addr += l;
3802     }
3803 }
3804
3805 /* used for ROM loading : can write in RAM and ROM */
3806 void cpu_physical_memory_write_rom(target_phys_addr_t addr,
3807                                    const uint8_t *buf, int len)
3808 {
3809     int l;
3810     uint8_t *ptr;
3811     target_phys_addr_t page;
3812     unsigned long pd;
3813     PhysPageDesc *p;
3814
3815     while (len > 0) {
3816         page = addr & TARGET_PAGE_MASK;
3817         l = (page + TARGET_PAGE_SIZE) - addr;
3818         if (l > len)
3819             l = len;
3820         p = phys_page_find(page >> TARGET_PAGE_BITS);
3821         if (!p) {
3822             pd = IO_MEM_UNASSIGNED;
3823         } else {
3824             pd = p->phys_offset;
3825         }
3826
3827         if ((pd & ~TARGET_PAGE_MASK) != IO_MEM_RAM &&
3828             (pd & ~TARGET_PAGE_MASK) != IO_MEM_ROM &&
3829             !(pd & IO_MEM_ROMD)) {
3830             /* do nothing */
3831         } else {
3832             unsigned long addr1;
3833             addr1 = (pd & TARGET_PAGE_MASK) + (addr & ~TARGET_PAGE_MASK);
3834             /* ROM/RAM case */
3835             ptr = qemu_get_ram_ptr(addr1);
3836             memcpy(ptr, buf, l);
3837         }
3838         len -= l;
3839         buf += l;
3840         addr += l;
3841     }
3842 }
3843
3844 typedef struct {
3845     void *buffer;
3846     target_phys_addr_t addr;
3847     target_phys_addr_t len;
3848 } BounceBuffer;
3849
3850 static BounceBuffer bounce;
3851
3852 typedef struct MapClient {
3853     void *opaque;
3854     void (*callback)(void *opaque);
3855     QLIST_ENTRY(MapClient) link;
3856 } MapClient;
3857
3858 static QLIST_HEAD(map_client_list, MapClient) map_client_list
3859     = QLIST_HEAD_INITIALIZER(map_client_list);
3860
3861 void *cpu_register_map_client(void *opaque, void (*callback)(void *opaque))
3862 {
3863     MapClient *client = qemu_malloc(sizeof(*client));
3864
3865     client->opaque = opaque;
3866     client->callback = callback;
3867     QLIST_INSERT_HEAD(&map_client_list, client, link);
3868     return client;
3869 }
3870
3871 void cpu_unregister_map_client(void *_client)
3872 {
3873     MapClient *client = (MapClient *)_client;
3874
3875     QLIST_REMOVE(client, link);
3876     qemu_free(client);
3877 }
3878
3879 static void cpu_notify_map_clients(void)
3880 {
3881     MapClient *client;
3882
3883     while (!QLIST_EMPTY(&map_client_list)) {
3884         client = QLIST_FIRST(&map_client_list);
3885         client->callback(client->opaque);
3886         cpu_unregister_map_client(client);
3887     }
3888 }
3889
3890 /* Map a physical memory region into a host virtual address.
3891  * May map a subset of the requested range, given by and returned in *plen.
3892  * May return NULL if resources needed to perform the mapping are exhausted.
3893  * Use only for reads OR writes - not for read-modify-write operations.
3894  * Use cpu_register_map_client() to know when retrying the map operation is
3895  * likely to succeed.
3896  */
3897 void *cpu_physical_memory_map(target_phys_addr_t addr,
3898                               target_phys_addr_t *plen,
3899                               int is_write)
3900 {
3901     target_phys_addr_t len = *plen;
3902     target_phys_addr_t done = 0;
3903     int l;
3904     uint8_t *ret = NULL;
3905     uint8_t *ptr;
3906     target_phys_addr_t page;
3907     unsigned long pd;
3908     PhysPageDesc *p;
3909     unsigned long addr1;
3910
3911     while (len > 0) {
3912         page = addr & TARGET_PAGE_MASK;
3913         l = (page + TARGET_PAGE_SIZE) - addr;
3914         if (l > len)
3915             l = len;
3916         p = phys_page_find(page >> TARGET_PAGE_BITS);
3917         if (!p) {
3918             pd = IO_MEM_UNASSIGNED;
3919         } else {
3920             pd = p->phys_offset;
3921         }
3922
3923         if ((pd & ~TARGET_PAGE_MASK) != IO_MEM_RAM) {
3924             if (done || bounce.buffer) {
3925                 break;
3926             }
3927             bounce.buffer = qemu_memalign(TARGET_PAGE_SIZE, TARGET_PAGE_SIZE);
3928             bounce.addr = addr;
3929             bounce.len = l;
3930             if (!is_write) {
3931                 cpu_physical_memory_rw(addr, bounce.buffer, l, 0);
3932             }
3933             ptr = bounce.buffer;
3934         } else {
3935             addr1 = (pd & TARGET_PAGE_MASK) + (addr & ~TARGET_PAGE_MASK);
3936             ptr = qemu_get_ram_ptr(addr1);
3937         }
3938         if (!done) {
3939             ret = ptr;
3940         } else if (ret + done != ptr) {
3941             break;
3942         }
3943
3944         len -= l;
3945         addr += l;
3946         done += l;
3947     }
3948     *plen = done;
3949     return ret;
3950 }
3951
3952 /* Unmaps a memory region previously mapped by cpu_physical_memory_map().
3953  * Will also mark the memory as dirty if is_write == 1.  access_len gives
3954  * the amount of memory that was actually read or written by the caller.
3955  */
3956 void cpu_physical_memory_unmap(void *buffer, target_phys_addr_t len,
3957                                int is_write, target_phys_addr_t access_len)
3958 {
3959     if (buffer != bounce.buffer) {
3960         if (is_write) {
3961             ram_addr_t addr1 = qemu_ram_addr_from_host_nofail(buffer);
3962             while (access_len) {
3963                 unsigned l;
3964                 l = TARGET_PAGE_SIZE;
3965                 if (l > access_len)
3966                     l = access_len;
3967                 if (!cpu_physical_memory_is_dirty(addr1)) {
3968                     /* invalidate code */
3969                     tb_invalidate_phys_page_range(addr1, addr1 + l, 0);
3970                     /* set dirty bit */
3971                     cpu_physical_memory_set_dirty_flags(
3972                         addr1, (0xff & ~CODE_DIRTY_FLAG));
3973                 }
3974                 addr1 += l;
3975                 access_len -= l;
3976             }
3977         }
3978         return;
3979     }
3980     if (is_write) {
3981         cpu_physical_memory_write(bounce.addr, bounce.buffer, access_len);
3982     }
3983     qemu_vfree(bounce.buffer);
3984     bounce.buffer = NULL;
3985     cpu_notify_map_clients();
3986 }
3987
3988 /* warning: addr must be aligned */
3989 uint32_t ldl_phys(target_phys_addr_t addr)
3990 {
3991     int io_index;
3992     uint8_t *ptr;
3993     uint32_t val;
3994     unsigned long pd;
3995     PhysPageDesc *p;
3996
3997     p = phys_page_find(addr >> TARGET_PAGE_BITS);
3998     if (!p) {
3999         pd = IO_MEM_UNASSIGNED;
4000     } else {
4001         pd = p->phys_offset;
4002     }
4003
4004     if ((pd & ~TARGET_PAGE_MASK) > IO_MEM_ROM &&
4005         !(pd & IO_MEM_ROMD)) {
4006         /* I/O case */
4007         io_index = (pd >> IO_MEM_SHIFT) & (IO_MEM_NB_ENTRIES - 1);
4008         if (p)
4009             addr = (addr & ~TARGET_PAGE_MASK) + p->region_offset;
4010         val = io_mem_read[io_index][2](io_mem_opaque[io_index], addr);
4011     } else {
4012         /* RAM case */
4013         ptr = qemu_get_ram_ptr(pd & TARGET_PAGE_MASK) +
4014             (addr & ~TARGET_PAGE_MASK);
4015         val = ldl_p(ptr);
4016     }
4017     return val;
4018 }
4019
4020 /* warning: addr must be aligned */
4021 uint64_t ldq_phys(target_phys_addr_t addr)
4022 {
4023     int io_index;
4024     uint8_t *ptr;
4025     uint64_t val;
4026     unsigned long pd;
4027     PhysPageDesc *p;
4028
4029     p = phys_page_find(addr >> TARGET_PAGE_BITS);
4030     if (!p) {
4031         pd = IO_MEM_UNASSIGNED;
4032     } else {
4033         pd = p->phys_offset;
4034     }
4035
4036     if ((pd & ~TARGET_PAGE_MASK) > IO_MEM_ROM &&
4037         !(pd & IO_MEM_ROMD)) {
4038         /* I/O case */
4039         io_index = (pd >> IO_MEM_SHIFT) & (IO_MEM_NB_ENTRIES - 1);
4040         if (p)
4041             addr = (addr & ~TARGET_PAGE_MASK) + p->region_offset;
4042 #ifdef TARGET_WORDS_BIGENDIAN
4043         val = (uint64_t)io_mem_read[io_index][2](io_mem_opaque[io_index], addr) << 32;
4044         val |= io_mem_read[io_index][2](io_mem_opaque[io_index], addr + 4);
4045 #else
4046         val = io_mem_read[io_index][2](io_mem_opaque[io_index], addr);
4047         val |= (uint64_t)io_mem_read[io_index][2](io_mem_opaque[io_index], addr + 4) << 32;
4048 #endif
4049     } else {
4050         /* RAM case */
4051         ptr = qemu_get_ram_ptr(pd & TARGET_PAGE_MASK) +
4052             (addr & ~TARGET_PAGE_MASK);
4053         val = ldq_p(ptr);
4054     }
4055     return val;
4056 }
4057
4058 /* XXX: optimize */
4059 uint32_t ldub_phys(target_phys_addr_t addr)
4060 {
4061     uint8_t val;
4062     cpu_physical_memory_read(addr, &val, 1);
4063     return val;
4064 }
4065
4066 /* warning: addr must be aligned */
4067 uint32_t lduw_phys(target_phys_addr_t addr)
4068 {
4069     int io_index;
4070     uint8_t *ptr;
4071     uint64_t val;
4072     unsigned long pd;
4073     PhysPageDesc *p;
4074
4075     p = phys_page_find(addr >> TARGET_PAGE_BITS);
4076     if (!p) {
4077         pd = IO_MEM_UNASSIGNED;
4078     } else {
4079         pd = p->phys_offset;
4080     }
4081
4082     if ((pd & ~TARGET_PAGE_MASK) > IO_MEM_ROM &&
4083         !(pd & IO_MEM_ROMD)) {
4084         /* I/O case */
4085         io_index = (pd >> IO_MEM_SHIFT) & (IO_MEM_NB_ENTRIES - 1);
4086         if (p)
4087             addr = (addr & ~TARGET_PAGE_MASK) + p->region_offset;
4088         val = io_mem_read[io_index][1](io_mem_opaque[io_index], addr);
4089     } else {
4090         /* RAM case */
4091         ptr = qemu_get_ram_ptr(pd & TARGET_PAGE_MASK) +
4092             (addr & ~TARGET_PAGE_MASK);
4093         val = lduw_p(ptr);
4094     }
4095     return val;
4096 }
4097
4098 /* warning: addr must be aligned. The ram page is not masked as dirty
4099    and the code inside is not invalidated. It is useful if the dirty
4100    bits are used to track modified PTEs */
4101 void stl_phys_notdirty(target_phys_addr_t addr, uint32_t val)
4102 {
4103     int io_index;
4104     uint8_t *ptr;
4105     unsigned long pd;
4106     PhysPageDesc *p;
4107
4108     p = phys_page_find(addr >> TARGET_PAGE_BITS);
4109     if (!p) {
4110         pd = IO_MEM_UNASSIGNED;
4111     } else {
4112         pd = p->phys_offset;
4113     }
4114
4115     if ((pd & ~TARGET_PAGE_MASK) != IO_MEM_RAM) {
4116         io_index = (pd >> IO_MEM_SHIFT) & (IO_MEM_NB_ENTRIES - 1);
4117         if (p)
4118             addr = (addr & ~TARGET_PAGE_MASK) + p->region_offset;
4119         io_mem_write[io_index][2](io_mem_opaque[io_index], addr, val);
4120     } else {
4121         unsigned long addr1 = (pd & TARGET_PAGE_MASK) + (addr & ~TARGET_PAGE_MASK);
4122         ptr = qemu_get_ram_ptr(addr1);
4123         stl_p(ptr, val);
4124
4125         if (unlikely(in_migration)) {
4126             if (!cpu_physical_memory_is_dirty(addr1)) {
4127                 /* invalidate code */
4128                 tb_invalidate_phys_page_range(addr1, addr1 + 4, 0);
4129                 /* set dirty bit */
4130                 cpu_physical_memory_set_dirty_flags(
4131                     addr1, (0xff & ~CODE_DIRTY_FLAG));
4132             }
4133         }
4134     }
4135 }
4136
4137 void stq_phys_notdirty(target_phys_addr_t addr, uint64_t val)
4138 {
4139     int io_index;
4140     uint8_t *ptr;
4141     unsigned long pd;
4142     PhysPageDesc *p;
4143
4144     p = phys_page_find(addr >> TARGET_PAGE_BITS);
4145     if (!p) {
4146         pd = IO_MEM_UNASSIGNED;
4147     } else {
4148         pd = p->phys_offset;
4149     }
4150
4151     if ((pd & ~TARGET_PAGE_MASK) != IO_MEM_RAM) {
4152         io_index = (pd >> IO_MEM_SHIFT) & (IO_MEM_NB_ENTRIES - 1);
4153         if (p)
4154             addr = (addr & ~TARGET_PAGE_MASK) + p->region_offset;
4155 #ifdef TARGET_WORDS_BIGENDIAN
4156         io_mem_write[io_index][2](io_mem_opaque[io_index], addr, val >> 32);
4157         io_mem_write[io_index][2](io_mem_opaque[io_index], addr + 4, val);
4158 #else
4159         io_mem_write[io_index][2](io_mem_opaque[io_index], addr, val);
4160         io_mem_write[io_index][2](io_mem_opaque[io_index], addr + 4, val >> 32);
4161 #endif
4162     } else {
4163         ptr = qemu_get_ram_ptr(pd & TARGET_PAGE_MASK) +
4164             (addr & ~TARGET_PAGE_MASK);
4165         stq_p(ptr, val);
4166     }
4167 }
4168
4169 /* warning: addr must be aligned */
4170 void stl_phys(target_phys_addr_t addr, uint32_t val)
4171 {
4172     int io_index;
4173     uint8_t *ptr;
4174     unsigned long pd;
4175     PhysPageDesc *p;
4176
4177     p = phys_page_find(addr >> TARGET_PAGE_BITS);
4178     if (!p) {
4179         pd = IO_MEM_UNASSIGNED;
4180     } else {
4181         pd = p->phys_offset;
4182     }
4183
4184     if ((pd & ~TARGET_PAGE_MASK) != IO_MEM_RAM) {
4185         io_index = (pd >> IO_MEM_SHIFT) & (IO_MEM_NB_ENTRIES - 1);
4186         if (p)
4187             addr = (addr & ~TARGET_PAGE_MASK) + p->region_offset;
4188         io_mem_write[io_index][2](io_mem_opaque[io_index], addr, val);
4189     } else {
4190         unsigned long addr1;
4191         addr1 = (pd & TARGET_PAGE_MASK) + (addr & ~TARGET_PAGE_MASK);
4192         /* RAM case */
4193         ptr = qemu_get_ram_ptr(addr1);
4194         stl_p(ptr, val);
4195         if (!cpu_physical_memory_is_dirty(addr1)) {
4196             /* invalidate code */
4197             tb_invalidate_phys_page_range(addr1, addr1 + 4, 0);
4198             /* set dirty bit */
4199             cpu_physical_memory_set_dirty_flags(addr1,
4200                 (0xff & ~CODE_DIRTY_FLAG));
4201         }
4202     }
4203 }
4204
4205 /* XXX: optimize */
4206 void stb_phys(target_phys_addr_t addr, uint32_t val)
4207 {
4208     uint8_t v = val;
4209     cpu_physical_memory_write(addr, &v, 1);
4210 }
4211
4212 /* warning: addr must be aligned */
4213 void stw_phys(target_phys_addr_t addr, uint32_t val)
4214 {
4215     int io_index;
4216     uint8_t *ptr;
4217     unsigned long pd;
4218     PhysPageDesc *p;
4219
4220     p = phys_page_find(addr >> TARGET_PAGE_BITS);
4221     if (!p) {
4222         pd = IO_MEM_UNASSIGNED;
4223     } else {
4224         pd = p->phys_offset;
4225     }
4226
4227     if ((pd & ~TARGET_PAGE_MASK) != IO_MEM_RAM) {
4228         io_index = (pd >> IO_MEM_SHIFT) & (IO_MEM_NB_ENTRIES - 1);
4229         if (p)
4230             addr = (addr & ~TARGET_PAGE_MASK) + p->region_offset;
4231         io_mem_write[io_index][1](io_mem_opaque[io_index], addr, val);
4232     } else {
4233         unsigned long addr1;
4234         addr1 = (pd & TARGET_PAGE_MASK) + (addr & ~TARGET_PAGE_MASK);
4235         /* RAM case */
4236         ptr = qemu_get_ram_ptr(addr1);
4237         stw_p(ptr, val);
4238         if (!cpu_physical_memory_is_dirty(addr1)) {
4239             /* invalidate code */
4240             tb_invalidate_phys_page_range(addr1, addr1 + 2, 0);
4241             /* set dirty bit */
4242             cpu_physical_memory_set_dirty_flags(addr1,
4243                 (0xff & ~CODE_DIRTY_FLAG));
4244         }
4245     }
4246 }
4247
4248 /* XXX: optimize */
4249 void stq_phys(target_phys_addr_t addr, uint64_t val)
4250 {
4251     val = tswap64(val);
4252     cpu_physical_memory_write(addr, (const uint8_t *)&val, 8);
4253 }
4254
4255 /* virtual memory access for debug (includes writing to ROM) */
4256 int cpu_memory_rw_debug(CPUState *env, target_ulong addr,
4257                         uint8_t *buf, int len, int is_write)
4258 {
4259     int l;
4260     target_phys_addr_t phys_addr;
4261     target_ulong page;
4262
4263     while (len > 0) {
4264         page = addr & TARGET_PAGE_MASK;
4265         phys_addr = cpu_get_phys_page_debug(env, page);
4266         /* if no physical page mapped, return an error */
4267         if (phys_addr == -1)
4268             return -1;
4269         l = (page + TARGET_PAGE_SIZE) - addr;
4270         if (l > len)
4271             l = len;
4272         phys_addr += (addr & ~TARGET_PAGE_MASK);
4273         if (is_write)
4274             cpu_physical_memory_write_rom(phys_addr, buf, l);
4275         else
4276             cpu_physical_memory_rw(phys_addr, buf, l, is_write);
4277         len -= l;
4278         buf += l;
4279         addr += l;
4280     }
4281     return 0;
4282 }
4283 #endif
4284
4285 /* in deterministic execution mode, instructions doing device I/Os
4286    must be at the end of the TB */
4287 void cpu_io_recompile(CPUState *env, void *retaddr)
4288 {
4289     TranslationBlock *tb;
4290     uint32_t n, cflags;
4291     target_ulong pc, cs_base;
4292     uint64_t flags;
4293
4294     tb = tb_find_pc((unsigned long)retaddr);
4295     if (!tb) {
4296         cpu_abort(env, "cpu_io_recompile: could not find TB for pc=%p",
4297                   retaddr);
4298     }
4299     n = env->icount_decr.u16.low + tb->icount;
4300     cpu_restore_state(tb, env, (unsigned long)retaddr, NULL);
4301     /* Calculate how many instructions had been executed before the fault
4302        occurred.  */
4303     n = n - env->icount_decr.u16.low;
4304     /* Generate a new TB ending on the I/O insn.  */
4305     n++;
4306     /* On MIPS and SH, delay slot instructions can only be restarted if
4307        they were already the first instruction in the TB.  If this is not
4308        the first instruction in a TB then re-execute the preceding
4309        branch.  */
4310 #if defined(TARGET_MIPS)
4311     if ((env->hflags & MIPS_HFLAG_BMASK) != 0 && n > 1) {
4312         env->active_tc.PC -= 4;
4313         env->icount_decr.u16.low++;
4314         env->hflags &= ~MIPS_HFLAG_BMASK;
4315     }
4316 #elif defined(TARGET_SH4)
4317     if ((env->flags & ((DELAY_SLOT | DELAY_SLOT_CONDITIONAL))) != 0
4318             && n > 1) {
4319         env->pc -= 2;
4320         env->icount_decr.u16.low++;
4321         env->flags &= ~(DELAY_SLOT | DELAY_SLOT_CONDITIONAL);
4322     }
4323 #endif
4324     /* This should never happen.  */
4325     if (n > CF_COUNT_MASK)
4326         cpu_abort(env, "TB too big during recompile");
4327
4328     cflags = n | CF_LAST_IO;
4329     pc = tb->pc;
4330     cs_base = tb->cs_base;
4331     flags = tb->flags;
4332     tb_phys_invalidate(tb, -1);
4333     /* FIXME: In theory this could raise an exception.  In practice
4334        we have already translated the block once so it's probably ok.  */
4335     tb_gen_code(env, pc, cs_base, flags, cflags);
4336     /* TODO: If env->pc != tb->pc (i.e. the faulting instruction was not
4337        the first in the TB) then we end up generating a whole new TB and
4338        repeating the fault, which is horribly inefficient.
4339        Better would be to execute just this insn uncached, or generate a
4340        second new TB.  */
4341     cpu_resume_from_signal(env, NULL);
4342 }
4343
4344 #if !defined(CONFIG_USER_ONLY)
4345
4346 void dump_exec_info(FILE *f, fprintf_function cpu_fprintf)
4347 {
4348     int i, target_code_size, max_target_code_size;
4349     int direct_jmp_count, direct_jmp2_count, cross_page;
4350     TranslationBlock *tb;
4351
4352     target_code_size = 0;
4353     max_target_code_size = 0;
4354     cross_page = 0;
4355     direct_jmp_count = 0;
4356     direct_jmp2_count = 0;
4357     for(i = 0; i < nb_tbs; i++) {
4358         tb = &tbs[i];
4359         target_code_size += tb->size;
4360         if (tb->size > max_target_code_size)
4361             max_target_code_size = tb->size;
4362         if (tb->page_addr[1] != -1)
4363             cross_page++;
4364         if (tb->tb_next_offset[0] != 0xffff) {
4365             direct_jmp_count++;
4366             if (tb->tb_next_offset[1] != 0xffff) {
4367                 direct_jmp2_count++;
4368             }
4369         }
4370     }
4371     /* XXX: avoid using doubles ? */
4372     cpu_fprintf(f, "Translation buffer state:\n");
4373     cpu_fprintf(f, "gen code size       %td/%ld\n",
4374                 code_gen_ptr - code_gen_buffer, code_gen_buffer_max_size);
4375     cpu_fprintf(f, "TB count            %d/%d\n",
4376                 nb_tbs, code_gen_max_blocks);
4377     cpu_fprintf(f, "TB avg target size  %d max=%d bytes\n",
4378                 nb_tbs ? target_code_size / nb_tbs : 0,
4379                 max_target_code_size);
4380     cpu_fprintf(f, "TB avg host size    %td bytes (expansion ratio: %0.1f)\n",
4381                 nb_tbs ? (code_gen_ptr - code_gen_buffer) / nb_tbs : 0,
4382                 target_code_size ? (double) (code_gen_ptr - code_gen_buffer) / target_code_size : 0);
4383     cpu_fprintf(f, "cross page TB count %d (%d%%)\n",
4384             cross_page,
4385             nb_tbs ? (cross_page * 100) / nb_tbs : 0);
4386     cpu_fprintf(f, "direct jump count   %d (%d%%) (2 jumps=%d %d%%)\n",
4387                 direct_jmp_count,
4388                 nb_tbs ? (direct_jmp_count * 100) / nb_tbs : 0,
4389                 direct_jmp2_count,
4390                 nb_tbs ? (direct_jmp2_count * 100) / nb_tbs : 0);
4391     cpu_fprintf(f, "\nStatistics:\n");
4392     cpu_fprintf(f, "TB flush count      %d\n", tb_flush_count);
4393     cpu_fprintf(f, "TB invalidate count %d\n", tb_phys_invalidate_count);
4394     cpu_fprintf(f, "TLB flush count     %d\n", tlb_flush_count);
4395     tcg_dump_info(f, cpu_fprintf);
4396 }
4397
4398 #define MMUSUFFIX _cmmu
4399 #define GETPC() NULL
4400 #define env cpu_single_env
4401 #define SOFTMMU_CODE_ACCESS
4402
4403 #define SHIFT 0
4404 #include "softmmu_template.h"
4405
4406 #define SHIFT 1
4407 #include "softmmu_template.h"
4408
4409 #define SHIFT 2
4410 #include "softmmu_template.h"
4411
4412 #define SHIFT 3
4413 #include "softmmu_template.h"
4414
4415 #undef env
4416
4417 #endif