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, env->mem_io_pc);
1074                 cpu_get_tb_cpu_state(env, &current_pc, &current_cs_base,
1075                                      &current_flags);
1076             }
1077 #endif /* TARGET_HAS_PRECISE_SMC */
1078             /* we need to do that to handle the case where a signal
1079                occurs while doing tb_phys_invalidate() */
1080             saved_tb = NULL;
1081             if (env) {
1082                 saved_tb = env->current_tb;
1083                 env->current_tb = NULL;
1084             }
1085             tb_phys_invalidate(tb, -1);
1086             if (env) {
1087                 env->current_tb = saved_tb;
1088                 if (env->interrupt_request && env->current_tb)
1089                     cpu_interrupt(env, env->interrupt_request);
1090             }
1091         }
1092         tb = tb_next;
1093     }
1094 #if !defined(CONFIG_USER_ONLY)
1095     /* if no code remaining, no need to continue to use slow writes */
1096     if (!p->first_tb) {
1097         invalidate_page_bitmap(p);
1098         if (is_cpu_write_access) {
1099             tlb_unprotect_code_phys(env, start, env->mem_io_vaddr);
1100         }
1101     }
1102 #endif
1103 #ifdef TARGET_HAS_PRECISE_SMC
1104     if (current_tb_modified) {
1105         /* we generate a block containing just the instruction
1106            modifying the memory. It will ensure that it cannot modify
1107            itself */
1108         env->current_tb = NULL;
1109         tb_gen_code(env, current_pc, current_cs_base, current_flags, 1);
1110         cpu_resume_from_signal(env, NULL);
1111     }
1112 #endif
1113 }
1114
1115 /* len must be <= 8 and start must be a multiple of len */
1116 static inline void tb_invalidate_phys_page_fast(tb_page_addr_t start, int len)
1117 {
1118     PageDesc *p;
1119     int offset, b;
1120 #if 0
1121     if (1) {
1122         qemu_log("modifying code at 0x%x size=%d EIP=%x PC=%08x\n",
1123                   cpu_single_env->mem_io_vaddr, len,
1124                   cpu_single_env->eip,
1125                   cpu_single_env->eip + (long)cpu_single_env->segs[R_CS].base);
1126     }
1127 #endif
1128     p = page_find(start >> TARGET_PAGE_BITS);
1129     if (!p)
1130         return;
1131     if (p->code_bitmap) {
1132         offset = start & ~TARGET_PAGE_MASK;
1133         b = p->code_bitmap[offset >> 3] >> (offset & 7);
1134         if (b & ((1 << len) - 1))
1135             goto do_invalidate;
1136     } else {
1137     do_invalidate:
1138         tb_invalidate_phys_page_range(start, start + len, 1);
1139     }
1140 }
1141
1142 #if !defined(CONFIG_SOFTMMU)
1143 static void tb_invalidate_phys_page(tb_page_addr_t addr,
1144                                     unsigned long pc, void *puc)
1145 {
1146     TranslationBlock *tb;
1147     PageDesc *p;
1148     int n;
1149 #ifdef TARGET_HAS_PRECISE_SMC
1150     TranslationBlock *current_tb = NULL;
1151     CPUState *env = cpu_single_env;
1152     int current_tb_modified = 0;
1153     target_ulong current_pc = 0;
1154     target_ulong current_cs_base = 0;
1155     int current_flags = 0;
1156 #endif
1157
1158     addr &= TARGET_PAGE_MASK;
1159     p = page_find(addr >> TARGET_PAGE_BITS);
1160     if (!p)
1161         return;
1162     tb = p->first_tb;
1163 #ifdef TARGET_HAS_PRECISE_SMC
1164     if (tb && pc != 0) {
1165         current_tb = tb_find_pc(pc);
1166     }
1167 #endif
1168     while (tb != NULL) {
1169         n = (long)tb & 3;
1170         tb = (TranslationBlock *)((long)tb & ~3);
1171 #ifdef TARGET_HAS_PRECISE_SMC
1172         if (current_tb == tb &&
1173             (current_tb->cflags & CF_COUNT_MASK) != 1) {
1174                 /* If we are modifying the current TB, we must stop
1175                    its execution. We could be more precise by checking
1176                    that the modification is after the current PC, but it
1177                    would require a specialized function to partially
1178                    restore the CPU state */
1179
1180             current_tb_modified = 1;
1181             cpu_restore_state(current_tb, env, pc);
1182             cpu_get_tb_cpu_state(env, &current_pc, &current_cs_base,
1183                                  &current_flags);
1184         }
1185 #endif /* TARGET_HAS_PRECISE_SMC */
1186         tb_phys_invalidate(tb, addr);
1187         tb = tb->page_next[n];
1188     }
1189     p->first_tb = NULL;
1190 #ifdef TARGET_HAS_PRECISE_SMC
1191     if (current_tb_modified) {
1192         /* we generate a block containing just the instruction
1193            modifying the memory. It will ensure that it cannot modify
1194            itself */
1195         env->current_tb = NULL;
1196         tb_gen_code(env, current_pc, current_cs_base, current_flags, 1);
1197         cpu_resume_from_signal(env, puc);
1198     }
1199 #endif
1200 }
1201 #endif
1202
1203 /* add the tb in the target page and protect it if necessary */
1204 static inline void tb_alloc_page(TranslationBlock *tb,
1205                                  unsigned int n, tb_page_addr_t page_addr)
1206 {
1207     PageDesc *p;
1208     TranslationBlock *last_first_tb;
1209
1210     tb->page_addr[n] = page_addr;
1211     p = page_find_alloc(page_addr >> TARGET_PAGE_BITS, 1);
1212     tb->page_next[n] = p->first_tb;
1213     last_first_tb = p->first_tb;
1214     p->first_tb = (TranslationBlock *)((long)tb | n);
1215     invalidate_page_bitmap(p);
1216
1217 #if defined(TARGET_HAS_SMC) || 1
1218
1219 #if defined(CONFIG_USER_ONLY)
1220     if (p->flags & PAGE_WRITE) {
1221         target_ulong addr;
1222         PageDesc *p2;
1223         int prot;
1224
1225         /* force the host page as non writable (writes will have a
1226            page fault + mprotect overhead) */
1227         page_addr &= qemu_host_page_mask;
1228         prot = 0;
1229         for(addr = page_addr; addr < page_addr + qemu_host_page_size;
1230             addr += TARGET_PAGE_SIZE) {
1231
1232             p2 = page_find (addr >> TARGET_PAGE_BITS);
1233             if (!p2)
1234                 continue;
1235             prot |= p2->flags;
1236             p2->flags &= ~PAGE_WRITE;
1237           }
1238         mprotect(g2h(page_addr), qemu_host_page_size,
1239                  (prot & PAGE_BITS) & ~PAGE_WRITE);
1240 #ifdef DEBUG_TB_INVALIDATE
1241         printf("protecting code page: 0x" TARGET_FMT_lx "\n",
1242                page_addr);
1243 #endif
1244     }
1245 #else
1246     /* if some code is already present, then the pages are already
1247        protected. So we handle the case where only the first TB is
1248        allocated in a physical page */
1249     if (!last_first_tb) {
1250         tlb_protect_code(page_addr);
1251     }
1252 #endif
1253
1254 #endif /* TARGET_HAS_SMC */
1255 }
1256
1257 /* add a new TB and link it to the physical page tables. phys_page2 is
1258    (-1) to indicate that only one page contains the TB. */
1259 void tb_link_page(TranslationBlock *tb,
1260                   tb_page_addr_t phys_pc, tb_page_addr_t phys_page2)
1261 {
1262     unsigned int h;
1263     TranslationBlock **ptb;
1264
1265     /* Grab the mmap lock to stop another thread invalidating this TB
1266        before we are done.  */
1267     mmap_lock();
1268     /* add in the physical hash table */
1269     h = tb_phys_hash_func(phys_pc);
1270     ptb = &tb_phys_hash[h];
1271     tb->phys_hash_next = *ptb;
1272     *ptb = tb;
1273
1274     /* add in the page list */
1275     tb_alloc_page(tb, 0, phys_pc & TARGET_PAGE_MASK);
1276     if (phys_page2 != -1)
1277         tb_alloc_page(tb, 1, phys_page2);
1278     else
1279         tb->page_addr[1] = -1;
1280
1281     tb->jmp_first = (TranslationBlock *)((long)tb | 2);
1282     tb->jmp_next[0] = NULL;
1283     tb->jmp_next[1] = NULL;
1284
1285     /* init original jump addresses */
1286     if (tb->tb_next_offset[0] != 0xffff)
1287         tb_reset_jump(tb, 0);
1288     if (tb->tb_next_offset[1] != 0xffff)
1289         tb_reset_jump(tb, 1);
1290
1291 #ifdef DEBUG_TB_CHECK
1292     tb_page_check();
1293 #endif
1294     mmap_unlock();
1295 }
1296
1297 /* find the TB 'tb' such that tb[0].tc_ptr <= tc_ptr <
1298    tb[1].tc_ptr. Return NULL if not found */
1299 TranslationBlock *tb_find_pc(unsigned long tc_ptr)
1300 {
1301     int m_min, m_max, m;
1302     unsigned long v;
1303     TranslationBlock *tb;
1304
1305     if (nb_tbs <= 0)
1306         return NULL;
1307     if (tc_ptr < (unsigned long)code_gen_buffer ||
1308         tc_ptr >= (unsigned long)code_gen_ptr)
1309         return NULL;
1310     /* binary search (cf Knuth) */
1311     m_min = 0;
1312     m_max = nb_tbs - 1;
1313     while (m_min <= m_max) {
1314         m = (m_min + m_max) >> 1;
1315         tb = &tbs[m];
1316         v = (unsigned long)tb->tc_ptr;
1317         if (v == tc_ptr)
1318             return tb;
1319         else if (tc_ptr < v) {
1320             m_max = m - 1;
1321         } else {
1322             m_min = m + 1;
1323         }
1324     }
1325     return &tbs[m_max];
1326 }
1327
1328 static void tb_reset_jump_recursive(TranslationBlock *tb);
1329
1330 static inline void tb_reset_jump_recursive2(TranslationBlock *tb, int n)
1331 {
1332     TranslationBlock *tb1, *tb_next, **ptb;
1333     unsigned int n1;
1334
1335     tb1 = tb->jmp_next[n];
1336     if (tb1 != NULL) {
1337         /* find head of list */
1338         for(;;) {
1339             n1 = (long)tb1 & 3;
1340             tb1 = (TranslationBlock *)((long)tb1 & ~3);
1341             if (n1 == 2)
1342                 break;
1343             tb1 = tb1->jmp_next[n1];
1344         }
1345         /* we are now sure now that tb jumps to tb1 */
1346         tb_next = tb1;
1347
1348         /* remove tb from the jmp_first list */
1349         ptb = &tb_next->jmp_first;
1350         for(;;) {
1351             tb1 = *ptb;
1352             n1 = (long)tb1 & 3;
1353             tb1 = (TranslationBlock *)((long)tb1 & ~3);
1354             if (n1 == n && tb1 == tb)
1355                 break;
1356             ptb = &tb1->jmp_next[n1];
1357         }
1358         *ptb = tb->jmp_next[n];
1359         tb->jmp_next[n] = NULL;
1360
1361         /* suppress the jump to next tb in generated code */
1362         tb_reset_jump(tb, n);
1363
1364         /* suppress jumps in the tb on which we could have jumped */
1365         tb_reset_jump_recursive(tb_next);
1366     }
1367 }
1368
1369 static void tb_reset_jump_recursive(TranslationBlock *tb)
1370 {
1371     tb_reset_jump_recursive2(tb, 0);
1372     tb_reset_jump_recursive2(tb, 1);
1373 }
1374
1375 #if defined(TARGET_HAS_ICE)
1376 #if defined(CONFIG_USER_ONLY)
1377 static void breakpoint_invalidate(CPUState *env, target_ulong pc)
1378 {
1379     tb_invalidate_phys_page_range(pc, pc + 1, 0);
1380 }
1381 #else
1382 static void breakpoint_invalidate(CPUState *env, target_ulong pc)
1383 {
1384     target_phys_addr_t addr;
1385     target_ulong pd;
1386     ram_addr_t ram_addr;
1387     PhysPageDesc *p;
1388
1389     addr = cpu_get_phys_page_debug(env, pc);
1390     p = phys_page_find(addr >> TARGET_PAGE_BITS);
1391     if (!p) {
1392         pd = IO_MEM_UNASSIGNED;
1393     } else {
1394         pd = p->phys_offset;
1395     }
1396     ram_addr = (pd & TARGET_PAGE_MASK) | (pc & ~TARGET_PAGE_MASK);
1397     tb_invalidate_phys_page_range(ram_addr, ram_addr + 1, 0);
1398 }
1399 #endif
1400 #endif /* TARGET_HAS_ICE */
1401
1402 #if defined(CONFIG_USER_ONLY)
1403 void cpu_watchpoint_remove_all(CPUState *env, int mask)
1404
1405 {
1406 }
1407
1408 int cpu_watchpoint_insert(CPUState *env, target_ulong addr, target_ulong len,
1409                           int flags, CPUWatchpoint **watchpoint)
1410 {
1411     return -ENOSYS;
1412 }
1413 #else
1414 /* Add a watchpoint.  */
1415 int cpu_watchpoint_insert(CPUState *env, target_ulong addr, target_ulong len,
1416                           int flags, CPUWatchpoint **watchpoint)
1417 {
1418     target_ulong len_mask = ~(len - 1);
1419     CPUWatchpoint *wp;
1420
1421     /* sanity checks: allow power-of-2 lengths, deny unaligned watchpoints */
1422     if ((len != 1 && len != 2 && len != 4 && len != 8) || (addr & ~len_mask)) {
1423         fprintf(stderr, "qemu: tried to set invalid watchpoint at "
1424                 TARGET_FMT_lx ", len=" TARGET_FMT_lu "\n", addr, len);
1425         return -EINVAL;
1426     }
1427     wp = qemu_malloc(sizeof(*wp));
1428
1429     wp->vaddr = addr;
1430     wp->len_mask = len_mask;
1431     wp->flags = flags;
1432
1433     /* keep all GDB-injected watchpoints in front */
1434     if (flags & BP_GDB)
1435         QTAILQ_INSERT_HEAD(&env->watchpoints, wp, entry);
1436     else
1437         QTAILQ_INSERT_TAIL(&env->watchpoints, wp, entry);
1438
1439     tlb_flush_page(env, addr);
1440
1441     if (watchpoint)
1442         *watchpoint = wp;
1443     return 0;
1444 }
1445
1446 /* Remove a specific watchpoint.  */
1447 int cpu_watchpoint_remove(CPUState *env, target_ulong addr, target_ulong len,
1448                           int flags)
1449 {
1450     target_ulong len_mask = ~(len - 1);
1451     CPUWatchpoint *wp;
1452
1453     QTAILQ_FOREACH(wp, &env->watchpoints, entry) {
1454         if (addr == wp->vaddr && len_mask == wp->len_mask
1455                 && flags == (wp->flags & ~BP_WATCHPOINT_HIT)) {
1456             cpu_watchpoint_remove_by_ref(env, wp);
1457             return 0;
1458         }
1459     }
1460     return -ENOENT;
1461 }
1462
1463 /* Remove a specific watchpoint by reference.  */
1464 void cpu_watchpoint_remove_by_ref(CPUState *env, CPUWatchpoint *watchpoint)
1465 {
1466     QTAILQ_REMOVE(&env->watchpoints, watchpoint, entry);
1467
1468     tlb_flush_page(env, watchpoint->vaddr);
1469
1470     qemu_free(watchpoint);
1471 }
1472
1473 /* Remove all matching watchpoints.  */
1474 void cpu_watchpoint_remove_all(CPUState *env, int mask)
1475 {
1476     CPUWatchpoint *wp, *next;
1477
1478     QTAILQ_FOREACH_SAFE(wp, &env->watchpoints, entry, next) {
1479         if (wp->flags & mask)
1480             cpu_watchpoint_remove_by_ref(env, wp);
1481     }
1482 }
1483 #endif
1484
1485 /* Add a breakpoint.  */
1486 int cpu_breakpoint_insert(CPUState *env, target_ulong pc, int flags,
1487                           CPUBreakpoint **breakpoint)
1488 {
1489 #if defined(TARGET_HAS_ICE)
1490     CPUBreakpoint *bp;
1491
1492     bp = qemu_malloc(sizeof(*bp));
1493
1494     bp->pc = pc;
1495     bp->flags = flags;
1496
1497     /* keep all GDB-injected breakpoints in front */
1498     if (flags & BP_GDB)
1499         QTAILQ_INSERT_HEAD(&env->breakpoints, bp, entry);
1500     else
1501         QTAILQ_INSERT_TAIL(&env->breakpoints, bp, entry);
1502
1503     breakpoint_invalidate(env, pc);
1504
1505     if (breakpoint)
1506         *breakpoint = bp;
1507     return 0;
1508 #else
1509     return -ENOSYS;
1510 #endif
1511 }
1512
1513 /* Remove a specific breakpoint.  */
1514 int cpu_breakpoint_remove(CPUState *env, target_ulong pc, int flags)
1515 {
1516 #if defined(TARGET_HAS_ICE)
1517     CPUBreakpoint *bp;
1518
1519     QTAILQ_FOREACH(bp, &env->breakpoints, entry) {
1520         if (bp->pc == pc && bp->flags == flags) {
1521             cpu_breakpoint_remove_by_ref(env, bp);
1522             return 0;
1523         }
1524     }
1525     return -ENOENT;
1526 #else
1527     return -ENOSYS;
1528 #endif
1529 }
1530
1531 /* Remove a specific breakpoint by reference.  */
1532 void cpu_breakpoint_remove_by_ref(CPUState *env, CPUBreakpoint *breakpoint)
1533 {
1534 #if defined(TARGET_HAS_ICE)
1535     QTAILQ_REMOVE(&env->breakpoints, breakpoint, entry);
1536
1537     breakpoint_invalidate(env, breakpoint->pc);
1538
1539     qemu_free(breakpoint);
1540 #endif
1541 }
1542
1543 /* Remove all matching breakpoints. */
1544 void cpu_breakpoint_remove_all(CPUState *env, int mask)
1545 {
1546 #if defined(TARGET_HAS_ICE)
1547     CPUBreakpoint *bp, *next;
1548
1549     QTAILQ_FOREACH_SAFE(bp, &env->breakpoints, entry, next) {
1550         if (bp->flags & mask)
1551             cpu_breakpoint_remove_by_ref(env, bp);
1552     }
1553 #endif
1554 }
1555
1556 /* enable or disable single step mode. EXCP_DEBUG is returned by the
1557    CPU loop after each instruction */
1558 void cpu_single_step(CPUState *env, int enabled)
1559 {
1560 #if defined(TARGET_HAS_ICE)
1561     if (env->singlestep_enabled != enabled) {
1562         env->singlestep_enabled = enabled;
1563         if (kvm_enabled())
1564             kvm_update_guest_debug(env, 0);
1565         else {
1566             /* must flush all the translated code to avoid inconsistencies */
1567             /* XXX: only flush what is necessary */
1568             tb_flush(env);
1569         }
1570     }
1571 #endif
1572 }
1573
1574 /* enable or disable low levels log */
1575 void cpu_set_log(int log_flags)
1576 {
1577     loglevel = log_flags;
1578     if (loglevel && !logfile) {
1579         logfile = fopen(logfilename, log_append ? "a" : "w");
1580         if (!logfile) {
1581             perror(logfilename);
1582             _exit(1);
1583         }
1584 #if !defined(CONFIG_SOFTMMU)
1585         /* must avoid mmap() usage of glibc by setting a buffer "by hand" */
1586         {
1587             static char logfile_buf[4096];
1588             setvbuf(logfile, logfile_buf, _IOLBF, sizeof(logfile_buf));
1589         }
1590 #elif !defined(_WIN32)
1591         /* Win32 doesn't support line-buffering and requires size >= 2 */
1592         setvbuf(logfile, NULL, _IOLBF, 0);
1593 #endif
1594         log_append = 1;
1595     }
1596     if (!loglevel && logfile) {
1597         fclose(logfile);
1598         logfile = NULL;
1599     }
1600 }
1601
1602 void cpu_set_log_filename(const char *filename)
1603 {
1604     logfilename = strdup(filename);
1605     if (logfile) {
1606         fclose(logfile);
1607         logfile = NULL;
1608     }
1609     cpu_set_log(loglevel);
1610 }
1611
1612 static void cpu_unlink_tb(CPUState *env)
1613 {
1614     /* FIXME: TB unchaining isn't SMP safe.  For now just ignore the
1615        problem and hope the cpu will stop of its own accord.  For userspace
1616        emulation this often isn't actually as bad as it sounds.  Often
1617        signals are used primarily to interrupt blocking syscalls.  */
1618     TranslationBlock *tb;
1619     static spinlock_t interrupt_lock = SPIN_LOCK_UNLOCKED;
1620
1621     spin_lock(&interrupt_lock);
1622     tb = env->current_tb;
1623     /* if the cpu is currently executing code, we must unlink it and
1624        all the potentially executing TB */
1625     if (tb) {
1626         env->current_tb = NULL;
1627         tb_reset_jump_recursive(tb);
1628     }
1629     spin_unlock(&interrupt_lock);
1630 }
1631
1632 #ifndef CONFIG_USER_ONLY
1633 /* mask must never be zero, except for A20 change call */
1634 static void tcg_handle_interrupt(CPUState *env, int mask)
1635 {
1636     int old_mask;
1637
1638     old_mask = env->interrupt_request;
1639     env->interrupt_request |= mask;
1640
1641     /*
1642      * If called from iothread context, wake the target cpu in
1643      * case its halted.
1644      */
1645     if (!qemu_cpu_is_self(env)) {
1646         qemu_cpu_kick(env);
1647         return;
1648     }
1649
1650     if (use_icount) {
1651         env->icount_decr.u16.high = 0xffff;
1652         if (!can_do_io(env)
1653             && (mask & ~old_mask) != 0) {
1654             cpu_abort(env, "Raised interrupt while not in I/O function");
1655         }
1656     } else {
1657         cpu_unlink_tb(env);
1658     }
1659 }
1660
1661 CPUInterruptHandler cpu_interrupt_handler = tcg_handle_interrupt;
1662
1663 #else /* CONFIG_USER_ONLY */
1664
1665 void cpu_interrupt(CPUState *env, int mask)
1666 {
1667     env->interrupt_request |= mask;
1668     cpu_unlink_tb(env);
1669 }
1670 #endif /* CONFIG_USER_ONLY */
1671
1672 void cpu_reset_interrupt(CPUState *env, int mask)
1673 {
1674     env->interrupt_request &= ~mask;
1675 }
1676
1677 void cpu_exit(CPUState *env)
1678 {
1679     env->exit_request = 1;
1680     cpu_unlink_tb(env);
1681 }
1682
1683 const CPULogItem cpu_log_items[] = {
1684     { CPU_LOG_TB_OUT_ASM, "out_asm",
1685       "show generated host assembly code for each compiled TB" },
1686     { CPU_LOG_TB_IN_ASM, "in_asm",
1687       "show target assembly code for each compiled TB" },
1688     { CPU_LOG_TB_OP, "op",
1689       "show micro ops for each compiled TB" },
1690     { CPU_LOG_TB_OP_OPT, "op_opt",
1691       "show micro ops "
1692 #ifdef TARGET_I386
1693       "before eflags optimization and "
1694 #endif
1695       "after liveness analysis" },
1696     { CPU_LOG_INT, "int",
1697       "show interrupts/exceptions in short format" },
1698     { CPU_LOG_EXEC, "exec",
1699       "show trace before each executed TB (lots of logs)" },
1700     { CPU_LOG_TB_CPU, "cpu",
1701       "show CPU state before block translation" },
1702 #ifdef TARGET_I386
1703     { CPU_LOG_PCALL, "pcall",
1704       "show protected mode far calls/returns/exceptions" },
1705     { CPU_LOG_RESET, "cpu_reset",
1706       "show CPU state before CPU resets" },
1707 #endif
1708 #ifdef DEBUG_IOPORT
1709     { CPU_LOG_IOPORT, "ioport",
1710       "show all i/o ports accesses" },
1711 #endif
1712     { 0, NULL, NULL },
1713 };
1714
1715 #ifndef CONFIG_USER_ONLY
1716 static QLIST_HEAD(memory_client_list, CPUPhysMemoryClient) memory_client_list
1717     = QLIST_HEAD_INITIALIZER(memory_client_list);
1718
1719 static void cpu_notify_set_memory(target_phys_addr_t start_addr,
1720                                   ram_addr_t size,
1721                                   ram_addr_t phys_offset,
1722                                   bool log_dirty)
1723 {
1724     CPUPhysMemoryClient *client;
1725     QLIST_FOREACH(client, &memory_client_list, list) {
1726         client->set_memory(client, start_addr, size, phys_offset, log_dirty);
1727     }
1728 }
1729
1730 static int cpu_notify_sync_dirty_bitmap(target_phys_addr_t start,
1731                                         target_phys_addr_t end)
1732 {
1733     CPUPhysMemoryClient *client;
1734     QLIST_FOREACH(client, &memory_client_list, list) {
1735         int r = client->sync_dirty_bitmap(client, start, end);
1736         if (r < 0)
1737             return r;
1738     }
1739     return 0;
1740 }
1741
1742 static int cpu_notify_migration_log(int enable)
1743 {
1744     CPUPhysMemoryClient *client;
1745     QLIST_FOREACH(client, &memory_client_list, list) {
1746         int r = client->migration_log(client, enable);
1747         if (r < 0)
1748             return r;
1749     }
1750     return 0;
1751 }
1752
1753 /* The l1_phys_map provides the upper P_L1_BITs of the guest physical
1754  * address.  Each intermediate table provides the next L2_BITs of guest
1755  * physical address space.  The number of levels vary based on host and
1756  * guest configuration, making it efficient to build the final guest
1757  * physical address by seeding the L1 offset and shifting and adding in
1758  * each L2 offset as we recurse through them. */
1759 static void phys_page_for_each_1(CPUPhysMemoryClient *client,
1760                                  int level, void **lp, target_phys_addr_t addr)
1761 {
1762     int i;
1763
1764     if (*lp == NULL) {
1765         return;
1766     }
1767     if (level == 0) {
1768         PhysPageDesc *pd = *lp;
1769         addr <<= L2_BITS + TARGET_PAGE_BITS;
1770         for (i = 0; i < L2_SIZE; ++i) {
1771             if (pd[i].phys_offset != IO_MEM_UNASSIGNED) {
1772                 client->set_memory(client, addr | i << TARGET_PAGE_BITS,
1773                                    TARGET_PAGE_SIZE, pd[i].phys_offset, false);
1774             }
1775         }
1776     } else {
1777         void **pp = *lp;
1778         for (i = 0; i < L2_SIZE; ++i) {
1779             phys_page_for_each_1(client, level - 1, pp + i,
1780                                  (addr << L2_BITS) | i);
1781         }
1782     }
1783 }
1784
1785 static void phys_page_for_each(CPUPhysMemoryClient *client)
1786 {
1787     int i;
1788     for (i = 0; i < P_L1_SIZE; ++i) {
1789         phys_page_for_each_1(client, P_L1_SHIFT / L2_BITS - 1,
1790                              l1_phys_map + i, i);
1791     }
1792 }
1793
1794 void cpu_register_phys_memory_client(CPUPhysMemoryClient *client)
1795 {
1796     QLIST_INSERT_HEAD(&memory_client_list, client, list);
1797     phys_page_for_each(client);
1798 }
1799
1800 void cpu_unregister_phys_memory_client(CPUPhysMemoryClient *client)
1801 {
1802     QLIST_REMOVE(client, list);
1803 }
1804 #endif
1805
1806 static int cmp1(const char *s1, int n, const char *s2)
1807 {
1808     if (strlen(s2) != n)
1809         return 0;
1810     return memcmp(s1, s2, n) == 0;
1811 }
1812
1813 /* takes a comma separated list of log masks. Return 0 if error. */
1814 int cpu_str_to_log_mask(const char *str)
1815 {
1816     const CPULogItem *item;
1817     int mask;
1818     const char *p, *p1;
1819
1820     p = str;
1821     mask = 0;
1822     for(;;) {
1823         p1 = strchr(p, ',');
1824         if (!p1)
1825             p1 = p + strlen(p);
1826         if(cmp1(p,p1-p,"all")) {
1827             for(item = cpu_log_items; item->mask != 0; item++) {
1828                 mask |= item->mask;
1829             }
1830         } else {
1831             for(item = cpu_log_items; item->mask != 0; item++) {
1832                 if (cmp1(p, p1 - p, item->name))
1833                     goto found;
1834             }
1835             return 0;
1836         }
1837     found:
1838         mask |= item->mask;
1839         if (*p1 != ',')
1840             break;
1841         p = p1 + 1;
1842     }
1843     return mask;
1844 }
1845
1846 void cpu_abort(CPUState *env, const char *fmt, ...)
1847 {
1848     va_list ap;
1849     va_list ap2;
1850
1851     va_start(ap, fmt);
1852     va_copy(ap2, ap);
1853     fprintf(stderr, "qemu: fatal: ");
1854     vfprintf(stderr, fmt, ap);
1855     fprintf(stderr, "\n");
1856 #ifdef TARGET_I386
1857     cpu_dump_state(env, stderr, fprintf, X86_DUMP_FPU | X86_DUMP_CCOP);
1858 #else
1859     cpu_dump_state(env, stderr, fprintf, 0);
1860 #endif
1861     if (qemu_log_enabled()) {
1862         qemu_log("qemu: fatal: ");
1863         qemu_log_vprintf(fmt, ap2);
1864         qemu_log("\n");
1865 #ifdef TARGET_I386
1866         log_cpu_state(env, X86_DUMP_FPU | X86_DUMP_CCOP);
1867 #else
1868         log_cpu_state(env, 0);
1869 #endif
1870         qemu_log_flush();
1871         qemu_log_close();
1872     }
1873     va_end(ap2);
1874     va_end(ap);
1875 #if defined(CONFIG_USER_ONLY)
1876     {
1877         struct sigaction act;
1878         sigfillset(&act.sa_mask);
1879         act.sa_handler = SIG_DFL;
1880         sigaction(SIGABRT, &act, NULL);
1881     }
1882 #endif
1883     abort();
1884 }
1885
1886 CPUState *cpu_copy(CPUState *env)
1887 {
1888     CPUState *new_env = cpu_init(env->cpu_model_str);
1889     CPUState *next_cpu = new_env->next_cpu;
1890     int cpu_index = new_env->cpu_index;
1891 #if defined(TARGET_HAS_ICE)
1892     CPUBreakpoint *bp;
1893     CPUWatchpoint *wp;
1894 #endif
1895
1896     memcpy(new_env, env, sizeof(CPUState));
1897
1898     /* Preserve chaining and index. */
1899     new_env->next_cpu = next_cpu;
1900     new_env->cpu_index = cpu_index;
1901
1902     /* Clone all break/watchpoints.
1903        Note: Once we support ptrace with hw-debug register access, make sure
1904        BP_CPU break/watchpoints are handled correctly on clone. */
1905     QTAILQ_INIT(&env->breakpoints);
1906     QTAILQ_INIT(&env->watchpoints);
1907 #if defined(TARGET_HAS_ICE)
1908     QTAILQ_FOREACH(bp, &env->breakpoints, entry) {
1909         cpu_breakpoint_insert(new_env, bp->pc, bp->flags, NULL);
1910     }
1911     QTAILQ_FOREACH(wp, &env->watchpoints, entry) {
1912         cpu_watchpoint_insert(new_env, wp->vaddr, (~wp->len_mask) + 1,
1913                               wp->flags, NULL);
1914     }
1915 #endif
1916
1917     return new_env;
1918 }
1919
1920 #if !defined(CONFIG_USER_ONLY)
1921
1922 static inline void tlb_flush_jmp_cache(CPUState *env, target_ulong addr)
1923 {
1924     unsigned int i;
1925
1926     /* Discard jump cache entries for any tb which might potentially
1927        overlap the flushed page.  */
1928     i = tb_jmp_cache_hash_page(addr - TARGET_PAGE_SIZE);
1929     memset (&env->tb_jmp_cache[i], 0,
1930             TB_JMP_PAGE_SIZE * sizeof(TranslationBlock *));
1931
1932     i = tb_jmp_cache_hash_page(addr);
1933     memset (&env->tb_jmp_cache[i], 0,
1934             TB_JMP_PAGE_SIZE * sizeof(TranslationBlock *));
1935 }
1936
1937 static CPUTLBEntry s_cputlb_empty_entry = {
1938     .addr_read  = -1,
1939     .addr_write = -1,
1940     .addr_code  = -1,
1941     .addend     = -1,
1942 };
1943
1944 /* NOTE: if flush_global is true, also flush global entries (not
1945    implemented yet) */
1946 void tlb_flush(CPUState *env, int flush_global)
1947 {
1948     int i;
1949
1950 #if defined(DEBUG_TLB)
1951     printf("tlb_flush:\n");
1952 #endif
1953     /* must reset current TB so that interrupts cannot modify the
1954        links while we are modifying them */
1955     env->current_tb = NULL;
1956
1957     for(i = 0; i < CPU_TLB_SIZE; i++) {
1958         int mmu_idx;
1959         for (mmu_idx = 0; mmu_idx < NB_MMU_MODES; mmu_idx++) {
1960             env->tlb_table[mmu_idx][i] = s_cputlb_empty_entry;
1961         }
1962     }
1963
1964     memset (env->tb_jmp_cache, 0, TB_JMP_CACHE_SIZE * sizeof (void *));
1965
1966     env->tlb_flush_addr = -1;
1967     env->tlb_flush_mask = 0;
1968     tlb_flush_count++;
1969 }
1970
1971 static inline void tlb_flush_entry(CPUTLBEntry *tlb_entry, target_ulong addr)
1972 {
1973     if (addr == (tlb_entry->addr_read &
1974                  (TARGET_PAGE_MASK | TLB_INVALID_MASK)) ||
1975         addr == (tlb_entry->addr_write &
1976                  (TARGET_PAGE_MASK | TLB_INVALID_MASK)) ||
1977         addr == (tlb_entry->addr_code &
1978                  (TARGET_PAGE_MASK | TLB_INVALID_MASK))) {
1979         *tlb_entry = s_cputlb_empty_entry;
1980     }
1981 }
1982
1983 void tlb_flush_page(CPUState *env, target_ulong addr)
1984 {
1985     int i;
1986     int mmu_idx;
1987
1988 #if defined(DEBUG_TLB)
1989     printf("tlb_flush_page: " TARGET_FMT_lx "\n", addr);
1990 #endif
1991     /* Check if we need to flush due to large pages.  */
1992     if ((addr & env->tlb_flush_mask) == env->tlb_flush_addr) {
1993 #if defined(DEBUG_TLB)
1994         printf("tlb_flush_page: forced full flush ("
1995                TARGET_FMT_lx "/" TARGET_FMT_lx ")\n",
1996                env->tlb_flush_addr, env->tlb_flush_mask);
1997 #endif
1998         tlb_flush(env, 1);
1999         return;
2000     }
2001     /* must reset current TB so that interrupts cannot modify the
2002        links while we are modifying them */
2003     env->current_tb = NULL;
2004
2005     addr &= TARGET_PAGE_MASK;
2006     i = (addr >> TARGET_PAGE_BITS) & (CPU_TLB_SIZE - 1);
2007     for (mmu_idx = 0; mmu_idx < NB_MMU_MODES; mmu_idx++)
2008         tlb_flush_entry(&env->tlb_table[mmu_idx][i], addr);
2009
2010     tlb_flush_jmp_cache(env, addr);
2011 }
2012
2013 /* update the TLBs so that writes to code in the virtual page 'addr'
2014    can be detected */
2015 static void tlb_protect_code(ram_addr_t ram_addr)
2016 {
2017     cpu_physical_memory_reset_dirty(ram_addr,
2018                                     ram_addr + TARGET_PAGE_SIZE,
2019                                     CODE_DIRTY_FLAG);
2020 }
2021
2022 /* update the TLB so that writes in physical page 'phys_addr' are no longer
2023    tested for self modifying code */
2024 static void tlb_unprotect_code_phys(CPUState *env, ram_addr_t ram_addr,
2025                                     target_ulong vaddr)
2026 {
2027     cpu_physical_memory_set_dirty_flags(ram_addr, CODE_DIRTY_FLAG);
2028 }
2029
2030 static inline void tlb_reset_dirty_range(CPUTLBEntry *tlb_entry,
2031                                          unsigned long start, unsigned long length)
2032 {
2033     unsigned long addr;
2034     if ((tlb_entry->addr_write & ~TARGET_PAGE_MASK) == IO_MEM_RAM) {
2035         addr = (tlb_entry->addr_write & TARGET_PAGE_MASK) + tlb_entry->addend;
2036         if ((addr - start) < length) {
2037             tlb_entry->addr_write = (tlb_entry->addr_write & TARGET_PAGE_MASK) | TLB_NOTDIRTY;
2038         }
2039     }
2040 }
2041
2042 /* Note: start and end must be within the same ram block.  */
2043 void cpu_physical_memory_reset_dirty(ram_addr_t start, ram_addr_t end,
2044                                      int dirty_flags)
2045 {
2046     CPUState *env;
2047     unsigned long length, start1;
2048     int i;
2049
2050     start &= TARGET_PAGE_MASK;
2051     end = TARGET_PAGE_ALIGN(end);
2052
2053     length = end - start;
2054     if (length == 0)
2055         return;
2056     cpu_physical_memory_mask_dirty_range(start, length, dirty_flags);
2057
2058     /* we modify the TLB cache so that the dirty bit will be set again
2059        when accessing the range */
2060     start1 = (unsigned long)qemu_safe_ram_ptr(start);
2061     /* Chek that we don't span multiple blocks - this breaks the
2062        address comparisons below.  */
2063     if ((unsigned long)qemu_safe_ram_ptr(end - 1) - start1
2064             != (end - 1) - start) {
2065         abort();
2066     }
2067
2068     for(env = first_cpu; env != NULL; env = env->next_cpu) {
2069         int mmu_idx;
2070         for (mmu_idx = 0; mmu_idx < NB_MMU_MODES; mmu_idx++) {
2071             for(i = 0; i < CPU_TLB_SIZE; i++)
2072                 tlb_reset_dirty_range(&env->tlb_table[mmu_idx][i],
2073                                       start1, length);
2074         }
2075     }
2076 }
2077
2078 int cpu_physical_memory_set_dirty_tracking(int enable)
2079 {
2080     int ret = 0;
2081     in_migration = enable;
2082     ret = cpu_notify_migration_log(!!enable);
2083     return ret;
2084 }
2085
2086 int cpu_physical_memory_get_dirty_tracking(void)
2087 {
2088     return in_migration;
2089 }
2090
2091 int cpu_physical_sync_dirty_bitmap(target_phys_addr_t start_addr,
2092                                    target_phys_addr_t end_addr)
2093 {
2094     int ret;
2095
2096     ret = cpu_notify_sync_dirty_bitmap(start_addr, end_addr);
2097     return ret;
2098 }
2099
2100 int cpu_physical_log_start(target_phys_addr_t start_addr,
2101                            ram_addr_t size)
2102 {
2103     CPUPhysMemoryClient *client;
2104     QLIST_FOREACH(client, &memory_client_list, list) {
2105         if (client->log_start) {
2106             int r = client->log_start(client, start_addr, size);
2107             if (r < 0) {
2108                 return r;
2109             }
2110         }
2111     }
2112     return 0;
2113 }
2114
2115 int cpu_physical_log_stop(target_phys_addr_t start_addr,
2116                           ram_addr_t size)
2117 {
2118     CPUPhysMemoryClient *client;
2119     QLIST_FOREACH(client, &memory_client_list, list) {
2120         if (client->log_stop) {
2121             int r = client->log_stop(client, start_addr, size);
2122             if (r < 0) {
2123                 return r;
2124             }
2125         }
2126     }
2127     return 0;
2128 }
2129
2130 static inline void tlb_update_dirty(CPUTLBEntry *tlb_entry)
2131 {
2132     ram_addr_t ram_addr;
2133     void *p;
2134
2135     if ((tlb_entry->addr_write & ~TARGET_PAGE_MASK) == IO_MEM_RAM) {
2136         p = (void *)(unsigned long)((tlb_entry->addr_write & TARGET_PAGE_MASK)
2137             + tlb_entry->addend);
2138         ram_addr = qemu_ram_addr_from_host_nofail(p);
2139         if (!cpu_physical_memory_is_dirty(ram_addr)) {
2140             tlb_entry->addr_write |= TLB_NOTDIRTY;
2141         }
2142     }
2143 }
2144
2145 /* update the TLB according to the current state of the dirty bits */
2146 void cpu_tlb_update_dirty(CPUState *env)
2147 {
2148     int i;
2149     int mmu_idx;
2150     for (mmu_idx = 0; mmu_idx < NB_MMU_MODES; mmu_idx++) {
2151         for(i = 0; i < CPU_TLB_SIZE; i++)
2152             tlb_update_dirty(&env->tlb_table[mmu_idx][i]);
2153     }
2154 }
2155
2156 static inline void tlb_set_dirty1(CPUTLBEntry *tlb_entry, target_ulong vaddr)
2157 {
2158     if (tlb_entry->addr_write == (vaddr | TLB_NOTDIRTY))
2159         tlb_entry->addr_write = vaddr;
2160 }
2161
2162 /* update the TLB corresponding to virtual page vaddr
2163    so that it is no longer dirty */
2164 static inline void tlb_set_dirty(CPUState *env, target_ulong vaddr)
2165 {
2166     int i;
2167     int mmu_idx;
2168
2169     vaddr &= TARGET_PAGE_MASK;
2170     i = (vaddr >> TARGET_PAGE_BITS) & (CPU_TLB_SIZE - 1);
2171     for (mmu_idx = 0; mmu_idx < NB_MMU_MODES; mmu_idx++)
2172         tlb_set_dirty1(&env->tlb_table[mmu_idx][i], vaddr);
2173 }
2174
2175 /* Our TLB does not support large pages, so remember the area covered by
2176    large pages and trigger a full TLB flush if these are invalidated.  */
2177 static void tlb_add_large_page(CPUState *env, target_ulong vaddr,
2178                                target_ulong size)
2179 {
2180     target_ulong mask = ~(size - 1);
2181
2182     if (env->tlb_flush_addr == (target_ulong)-1) {
2183         env->tlb_flush_addr = vaddr & mask;
2184         env->tlb_flush_mask = mask;
2185         return;
2186     }
2187     /* Extend the existing region to include the new page.
2188        This is a compromise between unnecessary flushes and the cost
2189        of maintaining a full variable size TLB.  */
2190     mask &= env->tlb_flush_mask;
2191     while (((env->tlb_flush_addr ^ vaddr) & mask) != 0) {
2192         mask <<= 1;
2193     }
2194     env->tlb_flush_addr &= mask;
2195     env->tlb_flush_mask = mask;
2196 }
2197
2198 /* Add a new TLB entry. At most one entry for a given virtual address
2199    is permitted. Only a single TARGET_PAGE_SIZE region is mapped, the
2200    supplied size is only used by tlb_flush_page.  */
2201 void tlb_set_page(CPUState *env, target_ulong vaddr,
2202                   target_phys_addr_t paddr, int prot,
2203                   int mmu_idx, target_ulong size)
2204 {
2205     PhysPageDesc *p;
2206     unsigned long pd;
2207     unsigned int index;
2208     target_ulong address;
2209     target_ulong code_address;
2210     unsigned long addend;
2211     CPUTLBEntry *te;
2212     CPUWatchpoint *wp;
2213     target_phys_addr_t iotlb;
2214
2215     assert(size >= TARGET_PAGE_SIZE);
2216     if (size != TARGET_PAGE_SIZE) {
2217         tlb_add_large_page(env, vaddr, size);
2218     }
2219     p = phys_page_find(paddr >> TARGET_PAGE_BITS);
2220     if (!p) {
2221         pd = IO_MEM_UNASSIGNED;
2222     } else {
2223         pd = p->phys_offset;
2224     }
2225 #if defined(DEBUG_TLB)
2226     printf("tlb_set_page: vaddr=" TARGET_FMT_lx " paddr=0x" TARGET_FMT_plx
2227            " prot=%x idx=%d pd=0x%08lx\n",
2228            vaddr, paddr, prot, mmu_idx, pd);
2229 #endif
2230
2231     address = vaddr;
2232     if ((pd & ~TARGET_PAGE_MASK) > IO_MEM_ROM && !(pd & IO_MEM_ROMD)) {
2233         /* IO memory case (romd handled later) */
2234         address |= TLB_MMIO;
2235     }
2236     addend = (unsigned long)qemu_get_ram_ptr(pd & TARGET_PAGE_MASK);
2237     if ((pd & ~TARGET_PAGE_MASK) <= IO_MEM_ROM) {
2238         /* Normal RAM.  */
2239         iotlb = pd & TARGET_PAGE_MASK;
2240         if ((pd & ~TARGET_PAGE_MASK) == IO_MEM_RAM)
2241             iotlb |= IO_MEM_NOTDIRTY;
2242         else
2243             iotlb |= IO_MEM_ROM;
2244     } else {
2245         /* IO handlers are currently passed a physical address.
2246            It would be nice to pass an offset from the base address
2247            of that region.  This would avoid having to special case RAM,
2248            and avoid full address decoding in every device.
2249            We can't use the high bits of pd for this because
2250            IO_MEM_ROMD uses these as a ram address.  */
2251         iotlb = (pd & ~TARGET_PAGE_MASK);
2252         if (p) {
2253             iotlb += p->region_offset;
2254         } else {
2255             iotlb += paddr;
2256         }
2257     }
2258
2259     code_address = address;
2260     /* Make accesses to pages with watchpoints go via the
2261        watchpoint trap routines.  */
2262     QTAILQ_FOREACH(wp, &env->watchpoints, entry) {
2263         if (vaddr == (wp->vaddr & TARGET_PAGE_MASK)) {
2264             /* Avoid trapping reads of pages with a write breakpoint. */
2265             if ((prot & PAGE_WRITE) || (wp->flags & BP_MEM_READ)) {
2266                 iotlb = io_mem_watch + paddr;
2267                 address |= TLB_MMIO;
2268                 break;
2269             }
2270         }
2271     }
2272
2273     index = (vaddr >> TARGET_PAGE_BITS) & (CPU_TLB_SIZE - 1);
2274     env->iotlb[mmu_idx][index] = iotlb - vaddr;
2275     te = &env->tlb_table[mmu_idx][index];
2276     te->addend = addend - vaddr;
2277     if (prot & PAGE_READ) {
2278         te->addr_read = address;
2279     } else {
2280         te->addr_read = -1;
2281     }
2282
2283     if (prot & PAGE_EXEC) {
2284         te->addr_code = code_address;
2285     } else {
2286         te->addr_code = -1;
2287     }
2288     if (prot & PAGE_WRITE) {
2289         if ((pd & ~TARGET_PAGE_MASK) == IO_MEM_ROM ||
2290             (pd & IO_MEM_ROMD)) {
2291             /* Write access calls the I/O callback.  */
2292             te->addr_write = address | TLB_MMIO;
2293         } else if ((pd & ~TARGET_PAGE_MASK) == IO_MEM_RAM &&
2294                    !cpu_physical_memory_is_dirty(pd)) {
2295             te->addr_write = address | TLB_NOTDIRTY;
2296         } else {
2297             te->addr_write = address;
2298         }
2299     } else {
2300         te->addr_write = -1;
2301     }
2302 }
2303
2304 #else
2305
2306 void tlb_flush(CPUState *env, int flush_global)
2307 {
2308 }
2309
2310 void tlb_flush_page(CPUState *env, target_ulong addr)
2311 {
2312 }
2313
2314 /*
2315  * Walks guest process memory "regions" one by one
2316  * and calls callback function 'fn' for each region.
2317  */
2318
2319 struct walk_memory_regions_data
2320 {
2321     walk_memory_regions_fn fn;
2322     void *priv;
2323     unsigned long start;
2324     int prot;
2325 };
2326
2327 static int walk_memory_regions_end(struct walk_memory_regions_data *data,
2328                                    abi_ulong end, int new_prot)
2329 {
2330     if (data->start != -1ul) {
2331         int rc = data->fn(data->priv, data->start, end, data->prot);
2332         if (rc != 0) {
2333             return rc;
2334         }
2335     }
2336
2337     data->start = (new_prot ? end : -1ul);
2338     data->prot = new_prot;
2339
2340     return 0;
2341 }
2342
2343 static int walk_memory_regions_1(struct walk_memory_regions_data *data,
2344                                  abi_ulong base, int level, void **lp)
2345 {
2346     abi_ulong pa;
2347     int i, rc;
2348
2349     if (*lp == NULL) {
2350         return walk_memory_regions_end(data, base, 0);
2351     }
2352
2353     if (level == 0) {
2354         PageDesc *pd = *lp;
2355         for (i = 0; i < L2_SIZE; ++i) {
2356             int prot = pd[i].flags;
2357
2358             pa = base | (i << TARGET_PAGE_BITS);
2359             if (prot != data->prot) {
2360                 rc = walk_memory_regions_end(data, pa, prot);
2361                 if (rc != 0) {
2362                     return rc;
2363                 }
2364             }
2365         }
2366     } else {
2367         void **pp = *lp;
2368         for (i = 0; i < L2_SIZE; ++i) {
2369             pa = base | ((abi_ulong)i <<
2370                 (TARGET_PAGE_BITS + L2_BITS * level));
2371             rc = walk_memory_regions_1(data, pa, level - 1, pp + i);
2372             if (rc != 0) {
2373                 return rc;
2374             }
2375         }
2376     }
2377
2378     return 0;
2379 }
2380
2381 int walk_memory_regions(void *priv, walk_memory_regions_fn fn)
2382 {
2383     struct walk_memory_regions_data data;
2384     unsigned long i;
2385
2386     data.fn = fn;
2387     data.priv = priv;
2388     data.start = -1ul;
2389     data.prot = 0;
2390
2391     for (i = 0; i < V_L1_SIZE; i++) {
2392         int rc = walk_memory_regions_1(&data, (abi_ulong)i << V_L1_SHIFT,
2393                                        V_L1_SHIFT / L2_BITS - 1, l1_map + i);
2394         if (rc != 0) {
2395             return rc;
2396         }
2397     }
2398
2399     return walk_memory_regions_end(&data, 0, 0);
2400 }
2401
2402 static int dump_region(void *priv, abi_ulong start,
2403     abi_ulong end, unsigned long prot)
2404 {
2405     FILE *f = (FILE *)priv;
2406
2407     (void) fprintf(f, TARGET_ABI_FMT_lx"-"TARGET_ABI_FMT_lx
2408         " "TARGET_ABI_FMT_lx" %c%c%c\n",
2409         start, end, end - start,
2410         ((prot & PAGE_READ) ? 'r' : '-'),
2411         ((prot & PAGE_WRITE) ? 'w' : '-'),
2412         ((prot & PAGE_EXEC) ? 'x' : '-'));
2413
2414     return (0);
2415 }
2416
2417 /* dump memory mappings */
2418 void page_dump(FILE *f)
2419 {
2420     (void) fprintf(f, "%-8s %-8s %-8s %s\n",
2421             "start", "end", "size", "prot");
2422     walk_memory_regions(f, dump_region);
2423 }
2424
2425 int page_get_flags(target_ulong address)
2426 {
2427     PageDesc *p;
2428
2429     p = page_find(address >> TARGET_PAGE_BITS);
2430     if (!p)
2431         return 0;
2432     return p->flags;
2433 }
2434
2435 /* Modify the flags of a page and invalidate the code if necessary.
2436    The flag PAGE_WRITE_ORG is positioned automatically depending
2437    on PAGE_WRITE.  The mmap_lock should already be held.  */
2438 void page_set_flags(target_ulong start, target_ulong end, int flags)
2439 {
2440     target_ulong addr, len;
2441
2442     /* This function should never be called with addresses outside the
2443        guest address space.  If this assert fires, it probably indicates
2444        a missing call to h2g_valid.  */
2445 #if TARGET_ABI_BITS > L1_MAP_ADDR_SPACE_BITS
2446     assert(end < ((abi_ulong)1 << L1_MAP_ADDR_SPACE_BITS));
2447 #endif
2448     assert(start < end);
2449
2450     start = start & TARGET_PAGE_MASK;
2451     end = TARGET_PAGE_ALIGN(end);
2452
2453     if (flags & PAGE_WRITE) {
2454         flags |= PAGE_WRITE_ORG;
2455     }
2456
2457     for (addr = start, len = end - start;
2458          len != 0;
2459          len -= TARGET_PAGE_SIZE, addr += TARGET_PAGE_SIZE) {
2460         PageDesc *p = page_find_alloc(addr >> TARGET_PAGE_BITS, 1);
2461
2462         /* If the write protection bit is set, then we invalidate
2463            the code inside.  */
2464         if (!(p->flags & PAGE_WRITE) &&
2465             (flags & PAGE_WRITE) &&
2466             p->first_tb) {
2467             tb_invalidate_phys_page(addr, 0, NULL);
2468         }
2469         p->flags = flags;
2470     }
2471 }
2472
2473 int page_check_range(target_ulong start, target_ulong len, int flags)
2474 {
2475     PageDesc *p;
2476     target_ulong end;
2477     target_ulong addr;
2478
2479     /* This function should never be called with addresses outside the
2480        guest address space.  If this assert fires, it probably indicates
2481        a missing call to h2g_valid.  */
2482 #if TARGET_ABI_BITS > L1_MAP_ADDR_SPACE_BITS
2483     assert(start < ((abi_ulong)1 << L1_MAP_ADDR_SPACE_BITS));
2484 #endif
2485
2486     if (len == 0) {
2487         return 0;
2488     }
2489     if (start + len - 1 < start) {
2490         /* We've wrapped around.  */
2491         return -1;
2492     }
2493
2494     end = TARGET_PAGE_ALIGN(start+len); /* must do before we loose bits in the next step */
2495     start = start & TARGET_PAGE_MASK;
2496
2497     for (addr = start, len = end - start;
2498          len != 0;
2499          len -= TARGET_PAGE_SIZE, addr += TARGET_PAGE_SIZE) {
2500         p = page_find(addr >> TARGET_PAGE_BITS);
2501         if( !p )
2502             return -1;
2503         if( !(p->flags & PAGE_VALID) )
2504             return -1;
2505
2506         if ((flags & PAGE_READ) && !(p->flags & PAGE_READ))
2507             return -1;
2508         if (flags & PAGE_WRITE) {
2509             if (!(p->flags & PAGE_WRITE_ORG))
2510                 return -1;
2511             /* unprotect the page if it was put read-only because it
2512                contains translated code */
2513             if (!(p->flags & PAGE_WRITE)) {
2514                 if (!page_unprotect(addr, 0, NULL))
2515                     return -1;
2516             }
2517             return 0;
2518         }
2519     }
2520     return 0;
2521 }
2522
2523 /* called from signal handler: invalidate the code and unprotect the
2524    page. Return TRUE if the fault was successfully handled. */
2525 int page_unprotect(target_ulong address, unsigned long pc, void *puc)
2526 {
2527     unsigned int prot;
2528     PageDesc *p;
2529     target_ulong host_start, host_end, addr;
2530
2531     /* Technically this isn't safe inside a signal handler.  However we
2532        know this only ever happens in a synchronous SEGV handler, so in
2533        practice it seems to be ok.  */
2534     mmap_lock();
2535
2536     p = page_find(address >> TARGET_PAGE_BITS);
2537     if (!p) {
2538         mmap_unlock();
2539         return 0;
2540     }
2541
2542     /* if the page was really writable, then we change its
2543        protection back to writable */
2544     if ((p->flags & PAGE_WRITE_ORG) && !(p->flags & PAGE_WRITE)) {
2545         host_start = address & qemu_host_page_mask;
2546         host_end = host_start + qemu_host_page_size;
2547
2548         prot = 0;
2549         for (addr = host_start ; addr < host_end ; addr += TARGET_PAGE_SIZE) {
2550             p = page_find(addr >> TARGET_PAGE_BITS);
2551             p->flags |= PAGE_WRITE;
2552             prot |= p->flags;
2553
2554             /* and since the content will be modified, we must invalidate
2555                the corresponding translated code. */
2556             tb_invalidate_phys_page(addr, pc, puc);
2557 #ifdef DEBUG_TB_CHECK
2558             tb_invalidate_check(addr);
2559 #endif
2560         }
2561         mprotect((void *)g2h(host_start), qemu_host_page_size,
2562                  prot & PAGE_BITS);
2563
2564         mmap_unlock();
2565         return 1;
2566     }
2567     mmap_unlock();
2568     return 0;
2569 }
2570
2571 static inline void tlb_set_dirty(CPUState *env,
2572                                  unsigned long addr, target_ulong vaddr)
2573 {
2574 }
2575 #endif /* defined(CONFIG_USER_ONLY) */
2576
2577 #if !defined(CONFIG_USER_ONLY)
2578
2579 #define SUBPAGE_IDX(addr) ((addr) & ~TARGET_PAGE_MASK)
2580 typedef struct subpage_t {
2581     target_phys_addr_t base;
2582     ram_addr_t sub_io_index[TARGET_PAGE_SIZE];
2583     ram_addr_t region_offset[TARGET_PAGE_SIZE];
2584 } subpage_t;
2585
2586 static int subpage_register (subpage_t *mmio, uint32_t start, uint32_t end,
2587                              ram_addr_t memory, ram_addr_t region_offset);
2588 static subpage_t *subpage_init (target_phys_addr_t base, ram_addr_t *phys,
2589                                 ram_addr_t orig_memory,
2590                                 ram_addr_t region_offset);
2591 #define CHECK_SUBPAGE(addr, start_addr, start_addr2, end_addr, end_addr2, \
2592                       need_subpage)                                     \
2593     do {                                                                \
2594         if (addr > start_addr)                                          \
2595             start_addr2 = 0;                                            \
2596         else {                                                          \
2597             start_addr2 = start_addr & ~TARGET_PAGE_MASK;               \
2598             if (start_addr2 > 0)                                        \
2599                 need_subpage = 1;                                       \
2600         }                                                               \
2601                                                                         \
2602         if ((start_addr + orig_size) - addr >= TARGET_PAGE_SIZE)        \
2603             end_addr2 = TARGET_PAGE_SIZE - 1;                           \
2604         else {                                                          \
2605             end_addr2 = (start_addr + orig_size - 1) & ~TARGET_PAGE_MASK; \
2606             if (end_addr2 < TARGET_PAGE_SIZE - 1)                       \
2607                 need_subpage = 1;                                       \
2608         }                                                               \
2609     } while (0)
2610
2611 /* register physical memory.
2612    For RAM, 'size' must be a multiple of the target page size.
2613    If (phys_offset & ~TARGET_PAGE_MASK) != 0, then it is an
2614    io memory page.  The address used when calling the IO function is
2615    the offset from the start of the region, plus region_offset.  Both
2616    start_addr and region_offset are rounded down to a page boundary
2617    before calculating this offset.  This should not be a problem unless
2618    the low bits of start_addr and region_offset differ.  */
2619 void cpu_register_physical_memory_log(target_phys_addr_t start_addr,
2620                                          ram_addr_t size,
2621                                          ram_addr_t phys_offset,
2622                                          ram_addr_t region_offset,
2623                                          bool log_dirty)
2624 {
2625     target_phys_addr_t addr, end_addr;
2626     PhysPageDesc *p;
2627     CPUState *env;
2628     ram_addr_t orig_size = size;
2629     subpage_t *subpage;
2630
2631     assert(size);
2632     cpu_notify_set_memory(start_addr, size, phys_offset, log_dirty);
2633
2634     if (phys_offset == IO_MEM_UNASSIGNED) {
2635         region_offset = start_addr;
2636     }
2637     region_offset &= TARGET_PAGE_MASK;
2638     size = (size + TARGET_PAGE_SIZE - 1) & TARGET_PAGE_MASK;
2639     end_addr = start_addr + (target_phys_addr_t)size;
2640
2641     addr = start_addr;
2642     do {
2643         p = phys_page_find(addr >> TARGET_PAGE_BITS);
2644         if (p && p->phys_offset != IO_MEM_UNASSIGNED) {
2645             ram_addr_t orig_memory = p->phys_offset;
2646             target_phys_addr_t start_addr2, end_addr2;
2647             int need_subpage = 0;
2648
2649             CHECK_SUBPAGE(addr, start_addr, start_addr2, end_addr, end_addr2,
2650                           need_subpage);
2651             if (need_subpage) {
2652                 if (!(orig_memory & IO_MEM_SUBPAGE)) {
2653                     subpage = subpage_init((addr & TARGET_PAGE_MASK),
2654                                            &p->phys_offset, orig_memory,
2655                                            p->region_offset);
2656                 } else {
2657                     subpage = io_mem_opaque[(orig_memory & ~TARGET_PAGE_MASK)
2658                                             >> IO_MEM_SHIFT];
2659                 }
2660                 subpage_register(subpage, start_addr2, end_addr2, phys_offset,
2661                                  region_offset);
2662                 p->region_offset = 0;
2663             } else {
2664                 p->phys_offset = phys_offset;
2665                 if ((phys_offset & ~TARGET_PAGE_MASK) <= IO_MEM_ROM ||
2666                     (phys_offset & IO_MEM_ROMD))
2667                     phys_offset += TARGET_PAGE_SIZE;
2668             }
2669         } else {
2670             p = phys_page_find_alloc(addr >> TARGET_PAGE_BITS, 1);
2671             p->phys_offset = phys_offset;
2672             p->region_offset = region_offset;
2673             if ((phys_offset & ~TARGET_PAGE_MASK) <= IO_MEM_ROM ||
2674                 (phys_offset & IO_MEM_ROMD)) {
2675                 phys_offset += TARGET_PAGE_SIZE;
2676             } else {
2677                 target_phys_addr_t start_addr2, end_addr2;
2678                 int need_subpage = 0;
2679
2680                 CHECK_SUBPAGE(addr, start_addr, start_addr2, end_addr,
2681                               end_addr2, need_subpage);
2682
2683                 if (need_subpage) {
2684                     subpage = subpage_init((addr & TARGET_PAGE_MASK),
2685                                            &p->phys_offset, IO_MEM_UNASSIGNED,
2686                                            addr & TARGET_PAGE_MASK);
2687                     subpage_register(subpage, start_addr2, end_addr2,
2688                                      phys_offset, region_offset);
2689                     p->region_offset = 0;
2690                 }
2691             }
2692         }
2693         region_offset += TARGET_PAGE_SIZE;
2694         addr += TARGET_PAGE_SIZE;
2695     } while (addr != end_addr);
2696
2697     /* since each CPU stores ram addresses in its TLB cache, we must
2698        reset the modified entries */
2699     /* XXX: slow ! */
2700     for(env = first_cpu; env != NULL; env = env->next_cpu) {
2701         tlb_flush(env, 1);
2702     }
2703 }
2704
2705 /* XXX: temporary until new memory mapping API */
2706 ram_addr_t cpu_get_physical_page_desc(target_phys_addr_t addr)
2707 {
2708     PhysPageDesc *p;
2709
2710     p = phys_page_find(addr >> TARGET_PAGE_BITS);
2711     if (!p)
2712         return IO_MEM_UNASSIGNED;
2713     return p->phys_offset;
2714 }
2715
2716 void qemu_register_coalesced_mmio(target_phys_addr_t addr, ram_addr_t size)
2717 {
2718     if (kvm_enabled())
2719         kvm_coalesce_mmio_region(addr, size);
2720 }
2721
2722 void qemu_unregister_coalesced_mmio(target_phys_addr_t addr, ram_addr_t size)
2723 {
2724     if (kvm_enabled())
2725         kvm_uncoalesce_mmio_region(addr, size);
2726 }
2727
2728 void qemu_flush_coalesced_mmio_buffer(void)
2729 {
2730     if (kvm_enabled())
2731         kvm_flush_coalesced_mmio_buffer();
2732 }
2733
2734 #if defined(__linux__) && !defined(TARGET_S390X)
2735
2736 #include <sys/vfs.h>
2737
2738 #define HUGETLBFS_MAGIC       0x958458f6
2739
2740 static long gethugepagesize(const char *path)
2741 {
2742     struct statfs fs;
2743     int ret;
2744
2745     do {
2746         ret = statfs(path, &fs);
2747     } while (ret != 0 && errno == EINTR);
2748
2749     if (ret != 0) {
2750         perror(path);
2751         return 0;
2752     }
2753
2754     if (fs.f_type != HUGETLBFS_MAGIC)
2755         fprintf(stderr, "Warning: path not on HugeTLBFS: %s\n", path);
2756
2757     return fs.f_bsize;
2758 }
2759
2760 static void *file_ram_alloc(RAMBlock *block,
2761                             ram_addr_t memory,
2762                             const char *path)
2763 {
2764     char *filename;
2765     void *area;
2766     int fd;
2767 #ifdef MAP_POPULATE
2768     int flags;
2769 #endif
2770     unsigned long hpagesize;
2771
2772     hpagesize = gethugepagesize(path);
2773     if (!hpagesize) {
2774         return NULL;
2775     }
2776
2777     if (memory < hpagesize) {
2778         return NULL;
2779     }
2780
2781     if (kvm_enabled() && !kvm_has_sync_mmu()) {
2782         fprintf(stderr, "host lacks kvm mmu notifiers, -mem-path unsupported\n");
2783         return NULL;
2784     }
2785
2786     if (asprintf(&filename, "%s/qemu_back_mem.XXXXXX", path) == -1) {
2787         return NULL;
2788     }
2789
2790     fd = mkstemp(filename);
2791     if (fd < 0) {
2792         perror("unable to create backing store for hugepages");
2793         free(filename);
2794         return NULL;
2795     }
2796     unlink(filename);
2797     free(filename);
2798
2799     memory = (memory+hpagesize-1) & ~(hpagesize-1);
2800
2801     /*
2802      * ftruncate is not supported by hugetlbfs in older
2803      * hosts, so don't bother bailing out on errors.
2804      * If anything goes wrong with it under other filesystems,
2805      * mmap will fail.
2806      */
2807     if (ftruncate(fd, memory))
2808         perror("ftruncate");
2809
2810 #ifdef MAP_POPULATE
2811     /* NB: MAP_POPULATE won't exhaustively alloc all phys pages in the case
2812      * MAP_PRIVATE is requested.  For mem_prealloc we mmap as MAP_SHARED
2813      * to sidestep this quirk.
2814      */
2815     flags = mem_prealloc ? MAP_POPULATE | MAP_SHARED : MAP_PRIVATE;
2816     area = mmap(0, memory, PROT_READ | PROT_WRITE, flags, fd, 0);
2817 #else
2818     area = mmap(0, memory, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
2819 #endif
2820     if (area == MAP_FAILED) {
2821         perror("file_ram_alloc: can't mmap RAM pages");
2822         close(fd);
2823         return (NULL);
2824     }
2825     block->fd = fd;
2826     return area;
2827 }
2828 #endif
2829
2830 static ram_addr_t find_ram_offset(ram_addr_t size)
2831 {
2832     RAMBlock *block, *next_block;
2833     ram_addr_t offset = 0, mingap = ULONG_MAX;
2834
2835     if (QLIST_EMPTY(&ram_list.blocks))
2836         return 0;
2837
2838     QLIST_FOREACH(block, &ram_list.blocks, next) {
2839         ram_addr_t end, next = ULONG_MAX;
2840
2841         end = block->offset + block->length;
2842
2843         QLIST_FOREACH(next_block, &ram_list.blocks, next) {
2844             if (next_block->offset >= end) {
2845                 next = MIN(next, next_block->offset);
2846             }
2847         }
2848         if (next - end >= size && next - end < mingap) {
2849             offset =  end;
2850             mingap = next - end;
2851         }
2852     }
2853     return offset;
2854 }
2855
2856 static ram_addr_t last_ram_offset(void)
2857 {
2858     RAMBlock *block;
2859     ram_addr_t last = 0;
2860
2861     QLIST_FOREACH(block, &ram_list.blocks, next)
2862         last = MAX(last, block->offset + block->length);
2863
2864     return last;
2865 }
2866
2867 ram_addr_t qemu_ram_alloc_from_ptr(DeviceState *dev, const char *name,
2868                                    ram_addr_t size, void *host)
2869 {
2870     RAMBlock *new_block, *block;
2871
2872     size = TARGET_PAGE_ALIGN(size);
2873     new_block = qemu_mallocz(sizeof(*new_block));
2874
2875     if (dev && dev->parent_bus && dev->parent_bus->info->get_dev_path) {
2876         char *id = dev->parent_bus->info->get_dev_path(dev);
2877         if (id) {
2878             snprintf(new_block->idstr, sizeof(new_block->idstr), "%s/", id);
2879             qemu_free(id);
2880         }
2881     }
2882     pstrcat(new_block->idstr, sizeof(new_block->idstr), name);
2883
2884     QLIST_FOREACH(block, &ram_list.blocks, next) {
2885         if (!strcmp(block->idstr, new_block->idstr)) {
2886             fprintf(stderr, "RAMBlock \"%s\" already registered, abort!\n",
2887                     new_block->idstr);
2888             abort();
2889         }
2890     }
2891
2892     if (host) {
2893         new_block->host = host;
2894         new_block->flags |= RAM_PREALLOC_MASK;
2895     } else {
2896         if (mem_path) {
2897 #if defined (__linux__) && !defined(TARGET_S390X)
2898             new_block->host = file_ram_alloc(new_block, size, mem_path);
2899             if (!new_block->host) {
2900                 new_block->host = qemu_vmalloc(size);
2901                 qemu_madvise(new_block->host, size, QEMU_MADV_MERGEABLE);
2902             }
2903 #else
2904             fprintf(stderr, "-mem-path option unsupported\n");
2905             exit(1);
2906 #endif
2907         } else {
2908 #if defined(TARGET_S390X) && defined(CONFIG_KVM)
2909             /* XXX S390 KVM requires the topmost vma of the RAM to be < 256GB */
2910             new_block->host = mmap((void*)0x1000000, size,
2911                                    PROT_EXEC|PROT_READ|PROT_WRITE,
2912                                    MAP_SHARED | MAP_ANONYMOUS, -1, 0);
2913 #else
2914             new_block->host = qemu_vmalloc(size);
2915 #endif
2916             qemu_madvise(new_block->host, size, QEMU_MADV_MERGEABLE);
2917         }
2918     }
2919
2920     new_block->offset = find_ram_offset(size);
2921     new_block->length = size;
2922
2923     QLIST_INSERT_HEAD(&ram_list.blocks, new_block, next);
2924
2925     ram_list.phys_dirty = qemu_realloc(ram_list.phys_dirty,
2926                                        last_ram_offset() >> TARGET_PAGE_BITS);
2927     memset(ram_list.phys_dirty + (new_block->offset >> TARGET_PAGE_BITS),
2928            0xff, size >> TARGET_PAGE_BITS);
2929
2930     if (kvm_enabled())
2931         kvm_setup_guest_memory(new_block->host, size);
2932
2933     return new_block->offset;
2934 }
2935
2936 ram_addr_t qemu_ram_alloc(DeviceState *dev, const char *name, ram_addr_t size)
2937 {
2938     return qemu_ram_alloc_from_ptr(dev, name, size, NULL);
2939 }
2940
2941 void qemu_ram_free(ram_addr_t addr)
2942 {
2943     RAMBlock *block;
2944
2945     QLIST_FOREACH(block, &ram_list.blocks, next) {
2946         if (addr == block->offset) {
2947             QLIST_REMOVE(block, next);
2948             if (block->flags & RAM_PREALLOC_MASK) {
2949                 ;
2950             } else if (mem_path) {
2951 #if defined (__linux__) && !defined(TARGET_S390X)
2952                 if (block->fd) {
2953                     munmap(block->host, block->length);
2954                     close(block->fd);
2955                 } else {
2956                     qemu_vfree(block->host);
2957                 }
2958 #else
2959                 abort();
2960 #endif
2961             } else {
2962 #if defined(TARGET_S390X) && defined(CONFIG_KVM)
2963                 munmap(block->host, block->length);
2964 #else
2965                 qemu_vfree(block->host);
2966 #endif
2967             }
2968             qemu_free(block);
2969             return;
2970         }
2971     }
2972
2973 }
2974
2975 #ifndef _WIN32
2976 void qemu_ram_remap(ram_addr_t addr, ram_addr_t length)
2977 {
2978     RAMBlock *block;
2979     ram_addr_t offset;
2980     int flags;
2981     void *area, *vaddr;
2982
2983     QLIST_FOREACH(block, &ram_list.blocks, next) {
2984         offset = addr - block->offset;
2985         if (offset < block->length) {
2986             vaddr = block->host + offset;
2987             if (block->flags & RAM_PREALLOC_MASK) {
2988                 ;
2989             } else {
2990                 flags = MAP_FIXED;
2991                 munmap(vaddr, length);
2992                 if (mem_path) {
2993 #if defined(__linux__) && !defined(TARGET_S390X)
2994                     if (block->fd) {
2995 #ifdef MAP_POPULATE
2996                         flags |= mem_prealloc ? MAP_POPULATE | MAP_SHARED :
2997                             MAP_PRIVATE;
2998 #else
2999                         flags |= MAP_PRIVATE;
3000 #endif
3001                         area = mmap(vaddr, length, PROT_READ | PROT_WRITE,
3002                                     flags, block->fd, offset);
3003                     } else {
3004                         flags |= MAP_PRIVATE | MAP_ANONYMOUS;
3005                         area = mmap(vaddr, length, PROT_READ | PROT_WRITE,
3006                                     flags, -1, 0);
3007                     }
3008 #else
3009                     abort();
3010 #endif
3011                 } else {
3012 #if defined(TARGET_S390X) && defined(CONFIG_KVM)
3013                     flags |= MAP_SHARED | MAP_ANONYMOUS;
3014                     area = mmap(vaddr, length, PROT_EXEC|PROT_READ|PROT_WRITE,
3015                                 flags, -1, 0);
3016 #else
3017                     flags |= MAP_PRIVATE | MAP_ANONYMOUS;
3018                     area = mmap(vaddr, length, PROT_READ | PROT_WRITE,
3019                                 flags, -1, 0);
3020 #endif
3021                 }
3022                 if (area != vaddr) {
3023                     fprintf(stderr, "Could not remap addr: %lx@%lx\n",
3024                             length, addr);
3025                     exit(1);
3026                 }
3027                 qemu_madvise(vaddr, length, QEMU_MADV_MERGEABLE);
3028             }
3029             return;
3030         }
3031     }
3032 }
3033 #endif /* !_WIN32 */
3034
3035 /* Return a host pointer to ram allocated with qemu_ram_alloc.
3036    With the exception of the softmmu code in this file, this should
3037    only be used for local memory (e.g. video ram) that the device owns,
3038    and knows it isn't going to access beyond the end of the block.
3039
3040    It should not be used for general purpose DMA.
3041    Use cpu_physical_memory_map/cpu_physical_memory_rw instead.
3042  */
3043 void *qemu_get_ram_ptr(ram_addr_t addr)
3044 {
3045     RAMBlock *block;
3046
3047     QLIST_FOREACH(block, &ram_list.blocks, next) {
3048         if (addr - block->offset < block->length) {
3049             /* Move this entry to to start of the list.  */
3050             if (block != QLIST_FIRST(&ram_list.blocks)) {
3051                 QLIST_REMOVE(block, next);
3052                 QLIST_INSERT_HEAD(&ram_list.blocks, block, next);
3053             }
3054             return block->host + (addr - block->offset);
3055         }
3056     }
3057
3058     fprintf(stderr, "Bad ram offset %" PRIx64 "\n", (uint64_t)addr);
3059     abort();
3060
3061     return NULL;
3062 }
3063
3064 /* Return a host pointer to ram allocated with qemu_ram_alloc.
3065  * Same as qemu_get_ram_ptr but avoid reordering ramblocks.
3066  */
3067 void *qemu_safe_ram_ptr(ram_addr_t addr)
3068 {
3069     RAMBlock *block;
3070
3071     QLIST_FOREACH(block, &ram_list.blocks, next) {
3072         if (addr - block->offset < block->length) {
3073             return block->host + (addr - block->offset);
3074         }
3075     }
3076
3077     fprintf(stderr, "Bad ram offset %" PRIx64 "\n", (uint64_t)addr);
3078     abort();
3079
3080     return NULL;
3081 }
3082
3083 int qemu_ram_addr_from_host(void *ptr, ram_addr_t *ram_addr)
3084 {
3085     RAMBlock *block;
3086     uint8_t *host = ptr;
3087
3088     QLIST_FOREACH(block, &ram_list.blocks, next) {
3089         if (host - block->host < block->length) {
3090             *ram_addr = block->offset + (host - block->host);
3091             return 0;
3092         }
3093     }
3094     return -1;
3095 }
3096
3097 /* Some of the softmmu routines need to translate from a host pointer
3098    (typically a TLB entry) back to a ram offset.  */
3099 ram_addr_t qemu_ram_addr_from_host_nofail(void *ptr)
3100 {
3101     ram_addr_t ram_addr;
3102
3103     if (qemu_ram_addr_from_host(ptr, &ram_addr)) {
3104         fprintf(stderr, "Bad ram pointer %p\n", ptr);
3105         abort();
3106     }
3107     return ram_addr;
3108 }
3109
3110 static uint32_t unassigned_mem_readb(void *opaque, target_phys_addr_t addr)
3111 {
3112 #ifdef DEBUG_UNASSIGNED
3113     printf("Unassigned mem read " TARGET_FMT_plx "\n", addr);
3114 #endif
3115 #if defined(TARGET_SPARC) || defined(TARGET_MICROBLAZE)
3116     do_unassigned_access(addr, 0, 0, 0, 1);
3117 #endif
3118     return 0;
3119 }
3120
3121 static uint32_t unassigned_mem_readw(void *opaque, target_phys_addr_t addr)
3122 {
3123 #ifdef DEBUG_UNASSIGNED
3124     printf("Unassigned mem read " TARGET_FMT_plx "\n", addr);
3125 #endif
3126 #if defined(TARGET_SPARC) || defined(TARGET_MICROBLAZE)
3127     do_unassigned_access(addr, 0, 0, 0, 2);
3128 #endif
3129     return 0;
3130 }
3131
3132 static uint32_t unassigned_mem_readl(void *opaque, target_phys_addr_t addr)
3133 {
3134 #ifdef DEBUG_UNASSIGNED
3135     printf("Unassigned mem read " TARGET_FMT_plx "\n", addr);
3136 #endif
3137 #if defined(TARGET_SPARC) || defined(TARGET_MICROBLAZE)
3138     do_unassigned_access(addr, 0, 0, 0, 4);
3139 #endif
3140     return 0;
3141 }
3142
3143 static void unassigned_mem_writeb(void *opaque, target_phys_addr_t addr, uint32_t val)
3144 {
3145 #ifdef DEBUG_UNASSIGNED
3146     printf("Unassigned mem write " TARGET_FMT_plx " = 0x%x\n", addr, val);
3147 #endif
3148 #if defined(TARGET_SPARC) || defined(TARGET_MICROBLAZE)
3149     do_unassigned_access(addr, 1, 0, 0, 1);
3150 #endif
3151 }
3152
3153 static void unassigned_mem_writew(void *opaque, target_phys_addr_t addr, uint32_t val)
3154 {
3155 #ifdef DEBUG_UNASSIGNED
3156     printf("Unassigned mem write " TARGET_FMT_plx " = 0x%x\n", addr, val);
3157 #endif
3158 #if defined(TARGET_SPARC) || defined(TARGET_MICROBLAZE)
3159     do_unassigned_access(addr, 1, 0, 0, 2);
3160 #endif
3161 }
3162
3163 static void unassigned_mem_writel(void *opaque, target_phys_addr_t addr, uint32_t val)
3164 {
3165 #ifdef DEBUG_UNASSIGNED
3166     printf("Unassigned mem write " TARGET_FMT_plx " = 0x%x\n", addr, val);
3167 #endif
3168 #if defined(TARGET_SPARC) || defined(TARGET_MICROBLAZE)
3169     do_unassigned_access(addr, 1, 0, 0, 4);
3170 #endif
3171 }
3172
3173 static CPUReadMemoryFunc * const unassigned_mem_read[3] = {
3174     unassigned_mem_readb,
3175     unassigned_mem_readw,
3176     unassigned_mem_readl,
3177 };
3178
3179 static CPUWriteMemoryFunc * const unassigned_mem_write[3] = {
3180     unassigned_mem_writeb,
3181     unassigned_mem_writew,
3182     unassigned_mem_writel,
3183 };
3184
3185 static void notdirty_mem_writeb(void *opaque, target_phys_addr_t ram_addr,
3186                                 uint32_t val)
3187 {
3188     int dirty_flags;
3189     dirty_flags = cpu_physical_memory_get_dirty_flags(ram_addr);
3190     if (!(dirty_flags & CODE_DIRTY_FLAG)) {
3191 #if !defined(CONFIG_USER_ONLY)
3192         tb_invalidate_phys_page_fast(ram_addr, 1);
3193         dirty_flags = cpu_physical_memory_get_dirty_flags(ram_addr);
3194 #endif
3195     }
3196     stb_p(qemu_get_ram_ptr(ram_addr), val);
3197     dirty_flags |= (0xff & ~CODE_DIRTY_FLAG);
3198     cpu_physical_memory_set_dirty_flags(ram_addr, dirty_flags);
3199     /* we remove the notdirty callback only if the code has been
3200        flushed */
3201     if (dirty_flags == 0xff)
3202         tlb_set_dirty(cpu_single_env, cpu_single_env->mem_io_vaddr);
3203 }
3204
3205 static void notdirty_mem_writew(void *opaque, target_phys_addr_t ram_addr,
3206                                 uint32_t val)
3207 {
3208     int dirty_flags;
3209     dirty_flags = cpu_physical_memory_get_dirty_flags(ram_addr);
3210     if (!(dirty_flags & CODE_DIRTY_FLAG)) {
3211 #if !defined(CONFIG_USER_ONLY)
3212         tb_invalidate_phys_page_fast(ram_addr, 2);
3213         dirty_flags = cpu_physical_memory_get_dirty_flags(ram_addr);
3214 #endif
3215     }
3216     stw_p(qemu_get_ram_ptr(ram_addr), val);
3217     dirty_flags |= (0xff & ~CODE_DIRTY_FLAG);
3218     cpu_physical_memory_set_dirty_flags(ram_addr, dirty_flags);
3219     /* we remove the notdirty callback only if the code has been
3220        flushed */
3221     if (dirty_flags == 0xff)
3222         tlb_set_dirty(cpu_single_env, cpu_single_env->mem_io_vaddr);
3223 }
3224
3225 static void notdirty_mem_writel(void *opaque, target_phys_addr_t ram_addr,
3226                                 uint32_t val)
3227 {
3228     int dirty_flags;
3229     dirty_flags = cpu_physical_memory_get_dirty_flags(ram_addr);
3230     if (!(dirty_flags & CODE_DIRTY_FLAG)) {
3231 #if !defined(CONFIG_USER_ONLY)
3232         tb_invalidate_phys_page_fast(ram_addr, 4);
3233         dirty_flags = cpu_physical_memory_get_dirty_flags(ram_addr);
3234 #endif
3235     }
3236     stl_p(qemu_get_ram_ptr(ram_addr), val);
3237     dirty_flags |= (0xff & ~CODE_DIRTY_FLAG);
3238     cpu_physical_memory_set_dirty_flags(ram_addr, dirty_flags);
3239     /* we remove the notdirty callback only if the code has been
3240        flushed */
3241     if (dirty_flags == 0xff)
3242         tlb_set_dirty(cpu_single_env, cpu_single_env->mem_io_vaddr);
3243 }
3244
3245 static CPUReadMemoryFunc * const error_mem_read[3] = {
3246     NULL, /* never used */
3247     NULL, /* never used */
3248     NULL, /* never used */
3249 };
3250
3251 static CPUWriteMemoryFunc * const notdirty_mem_write[3] = {
3252     notdirty_mem_writeb,
3253     notdirty_mem_writew,
3254     notdirty_mem_writel,
3255 };
3256
3257 /* Generate a debug exception if a watchpoint has been hit.  */
3258 static void check_watchpoint(int offset, int len_mask, int flags)
3259 {
3260     CPUState *env = cpu_single_env;
3261     target_ulong pc, cs_base;
3262     TranslationBlock *tb;
3263     target_ulong vaddr;
3264     CPUWatchpoint *wp;
3265     int cpu_flags;
3266
3267     if (env->watchpoint_hit) {
3268         /* We re-entered the check after replacing the TB. Now raise
3269          * the debug interrupt so that is will trigger after the
3270          * current instruction. */
3271         cpu_interrupt(env, CPU_INTERRUPT_DEBUG);
3272         return;
3273     }
3274     vaddr = (env->mem_io_vaddr & TARGET_PAGE_MASK) + offset;
3275     QTAILQ_FOREACH(wp, &env->watchpoints, entry) {
3276         if ((vaddr == (wp->vaddr & len_mask) ||
3277              (vaddr & wp->len_mask) == wp->vaddr) && (wp->flags & flags)) {
3278             wp->flags |= BP_WATCHPOINT_HIT;
3279             if (!env->watchpoint_hit) {
3280                 env->watchpoint_hit = wp;
3281                 tb = tb_find_pc(env->mem_io_pc);
3282                 if (!tb) {
3283                     cpu_abort(env, "check_watchpoint: could not find TB for "
3284                               "pc=%p", (void *)env->mem_io_pc);
3285                 }
3286                 cpu_restore_state(tb, env, env->mem_io_pc);
3287                 tb_phys_invalidate(tb, -1);
3288                 if (wp->flags & BP_STOP_BEFORE_ACCESS) {
3289                     env->exception_index = EXCP_DEBUG;
3290                 } else {
3291                     cpu_get_tb_cpu_state(env, &pc, &cs_base, &cpu_flags);
3292                     tb_gen_code(env, pc, cs_base, cpu_flags, 1);
3293                 }
3294                 cpu_resume_from_signal(env, NULL);
3295             }
3296         } else {
3297             wp->flags &= ~BP_WATCHPOINT_HIT;
3298         }
3299     }
3300 }
3301
3302 /* Watchpoint access routines.  Watchpoints are inserted using TLB tricks,
3303    so these check for a hit then pass through to the normal out-of-line
3304    phys routines.  */
3305 static uint32_t watch_mem_readb(void *opaque, target_phys_addr_t addr)
3306 {
3307     check_watchpoint(addr & ~TARGET_PAGE_MASK, ~0x0, BP_MEM_READ);
3308     return ldub_phys(addr);
3309 }
3310
3311 static uint32_t watch_mem_readw(void *opaque, target_phys_addr_t addr)
3312 {
3313     check_watchpoint(addr & ~TARGET_PAGE_MASK, ~0x1, BP_MEM_READ);
3314     return lduw_phys(addr);
3315 }
3316
3317 static uint32_t watch_mem_readl(void *opaque, target_phys_addr_t addr)
3318 {
3319     check_watchpoint(addr & ~TARGET_PAGE_MASK, ~0x3, BP_MEM_READ);
3320     return ldl_phys(addr);
3321 }
3322
3323 static void watch_mem_writeb(void *opaque, target_phys_addr_t addr,
3324                              uint32_t val)
3325 {
3326     check_watchpoint(addr & ~TARGET_PAGE_MASK, ~0x0, BP_MEM_WRITE);
3327     stb_phys(addr, val);
3328 }
3329
3330 static void watch_mem_writew(void *opaque, target_phys_addr_t addr,
3331                              uint32_t val)
3332 {
3333     check_watchpoint(addr & ~TARGET_PAGE_MASK, ~0x1, BP_MEM_WRITE);
3334     stw_phys(addr, val);
3335 }
3336
3337 static void watch_mem_writel(void *opaque, target_phys_addr_t addr,
3338                              uint32_t val)
3339 {
3340     check_watchpoint(addr & ~TARGET_PAGE_MASK, ~0x3, BP_MEM_WRITE);
3341     stl_phys(addr, val);
3342 }
3343
3344 static CPUReadMemoryFunc * const watch_mem_read[3] = {
3345     watch_mem_readb,
3346     watch_mem_readw,
3347     watch_mem_readl,
3348 };
3349
3350 static CPUWriteMemoryFunc * const watch_mem_write[3] = {
3351     watch_mem_writeb,
3352     watch_mem_writew,
3353     watch_mem_writel,
3354 };
3355
3356 static inline uint32_t subpage_readlen (subpage_t *mmio,
3357                                         target_phys_addr_t addr,
3358                                         unsigned int len)
3359 {
3360     unsigned int idx = SUBPAGE_IDX(addr);
3361 #if defined(DEBUG_SUBPAGE)
3362     printf("%s: subpage %p len %d addr " TARGET_FMT_plx " idx %d\n", __func__,
3363            mmio, len, addr, idx);
3364 #endif
3365
3366     addr += mmio->region_offset[idx];
3367     idx = mmio->sub_io_index[idx];
3368     return io_mem_read[idx][len](io_mem_opaque[idx], addr);
3369 }
3370
3371 static inline void subpage_writelen (subpage_t *mmio, target_phys_addr_t addr,
3372                                      uint32_t value, unsigned int len)
3373 {
3374     unsigned int idx = SUBPAGE_IDX(addr);
3375 #if defined(DEBUG_SUBPAGE)
3376     printf("%s: subpage %p len %d addr " TARGET_FMT_plx " idx %d value %08x\n",
3377            __func__, mmio, len, addr, idx, value);
3378 #endif
3379
3380     addr += mmio->region_offset[idx];
3381     idx = mmio->sub_io_index[idx];
3382     io_mem_write[idx][len](io_mem_opaque[idx], addr, value);
3383 }
3384
3385 static uint32_t subpage_readb (void *opaque, target_phys_addr_t addr)
3386 {
3387     return subpage_readlen(opaque, addr, 0);
3388 }
3389
3390 static void subpage_writeb (void *opaque, target_phys_addr_t addr,
3391                             uint32_t value)
3392 {
3393     subpage_writelen(opaque, addr, value, 0);
3394 }
3395
3396 static uint32_t subpage_readw (void *opaque, target_phys_addr_t addr)
3397 {
3398     return subpage_readlen(opaque, addr, 1);
3399 }
3400
3401 static void subpage_writew (void *opaque, target_phys_addr_t addr,
3402                             uint32_t value)
3403 {
3404     subpage_writelen(opaque, addr, value, 1);
3405 }
3406
3407 static uint32_t subpage_readl (void *opaque, target_phys_addr_t addr)
3408 {
3409     return subpage_readlen(opaque, addr, 2);
3410 }
3411
3412 static void subpage_writel (void *opaque, target_phys_addr_t addr,
3413                             uint32_t value)
3414 {
3415     subpage_writelen(opaque, addr, value, 2);
3416 }
3417
3418 static CPUReadMemoryFunc * const subpage_read[] = {
3419     &subpage_readb,
3420     &subpage_readw,
3421     &subpage_readl,
3422 };
3423
3424 static CPUWriteMemoryFunc * const subpage_write[] = {
3425     &subpage_writeb,
3426     &subpage_writew,
3427     &subpage_writel,
3428 };
3429
3430 static int subpage_register (subpage_t *mmio, uint32_t start, uint32_t end,
3431                              ram_addr_t memory, ram_addr_t region_offset)
3432 {
3433     int idx, eidx;
3434
3435     if (start >= TARGET_PAGE_SIZE || end >= TARGET_PAGE_SIZE)
3436         return -1;
3437     idx = SUBPAGE_IDX(start);
3438     eidx = SUBPAGE_IDX(end);
3439 #if defined(DEBUG_SUBPAGE)
3440     printf("%s: %p start %08x end %08x idx %08x eidx %08x mem %ld\n", __func__,
3441            mmio, start, end, idx, eidx, memory);
3442 #endif
3443     if ((memory & ~TARGET_PAGE_MASK) == IO_MEM_RAM)
3444         memory = IO_MEM_UNASSIGNED;
3445     memory = (memory >> IO_MEM_SHIFT) & (IO_MEM_NB_ENTRIES - 1);
3446     for (; idx <= eidx; idx++) {
3447         mmio->sub_io_index[idx] = memory;
3448         mmio->region_offset[idx] = region_offset;
3449     }
3450
3451     return 0;
3452 }
3453
3454 static subpage_t *subpage_init (target_phys_addr_t base, ram_addr_t *phys,
3455                                 ram_addr_t orig_memory,
3456                                 ram_addr_t region_offset)
3457 {
3458     subpage_t *mmio;
3459     int subpage_memory;
3460
3461     mmio = qemu_mallocz(sizeof(subpage_t));
3462
3463     mmio->base = base;
3464     subpage_memory = cpu_register_io_memory(subpage_read, subpage_write, mmio,
3465                                             DEVICE_NATIVE_ENDIAN);
3466 #if defined(DEBUG_SUBPAGE)
3467     printf("%s: %p base " TARGET_FMT_plx " len %08x %d\n", __func__,
3468            mmio, base, TARGET_PAGE_SIZE, subpage_memory);
3469 #endif
3470     *phys = subpage_memory | IO_MEM_SUBPAGE;
3471     subpage_register(mmio, 0, TARGET_PAGE_SIZE-1, orig_memory, region_offset);
3472
3473     return mmio;
3474 }
3475
3476 static int get_free_io_mem_idx(void)
3477 {
3478     int i;
3479
3480     for (i = 0; i<IO_MEM_NB_ENTRIES; i++)
3481         if (!io_mem_used[i]) {
3482             io_mem_used[i] = 1;
3483             return i;
3484         }
3485     fprintf(stderr, "RAN out out io_mem_idx, max %d !\n", IO_MEM_NB_ENTRIES);
3486     return -1;
3487 }
3488
3489 /*
3490  * Usually, devices operate in little endian mode. There are devices out
3491  * there that operate in big endian too. Each device gets byte swapped
3492  * mmio if plugged onto a CPU that does the other endianness.
3493  *
3494  * CPU          Device           swap?
3495  *
3496  * little       little           no
3497  * little       big              yes
3498  * big          little           yes
3499  * big          big              no
3500  */
3501
3502 typedef struct SwapEndianContainer {
3503     CPUReadMemoryFunc *read[3];
3504     CPUWriteMemoryFunc *write[3];
3505     void *opaque;
3506 } SwapEndianContainer;
3507
3508 static uint32_t swapendian_mem_readb (void *opaque, target_phys_addr_t addr)
3509 {
3510     uint32_t val;
3511     SwapEndianContainer *c = opaque;
3512     val = c->read[0](c->opaque, addr);
3513     return val;
3514 }
3515
3516 static uint32_t swapendian_mem_readw(void *opaque, target_phys_addr_t addr)
3517 {
3518     uint32_t val;
3519     SwapEndianContainer *c = opaque;
3520     val = bswap16(c->read[1](c->opaque, addr));
3521     return val;
3522 }
3523
3524 static uint32_t swapendian_mem_readl(void *opaque, target_phys_addr_t addr)
3525 {
3526     uint32_t val;
3527     SwapEndianContainer *c = opaque;
3528     val = bswap32(c->read[2](c->opaque, addr));
3529     return val;
3530 }
3531
3532 static CPUReadMemoryFunc * const swapendian_readfn[3]={
3533     swapendian_mem_readb,
3534     swapendian_mem_readw,
3535     swapendian_mem_readl
3536 };
3537
3538 static void swapendian_mem_writeb(void *opaque, target_phys_addr_t addr,
3539                                   uint32_t val)
3540 {
3541     SwapEndianContainer *c = opaque;
3542     c->write[0](c->opaque, addr, val);
3543 }
3544
3545 static void swapendian_mem_writew(void *opaque, target_phys_addr_t addr,
3546                                   uint32_t val)
3547 {
3548     SwapEndianContainer *c = opaque;
3549     c->write[1](c->opaque, addr, bswap16(val));
3550 }
3551
3552 static void swapendian_mem_writel(void *opaque, target_phys_addr_t addr,
3553                                   uint32_t val)
3554 {
3555     SwapEndianContainer *c = opaque;
3556     c->write[2](c->opaque, addr, bswap32(val));
3557 }
3558
3559 static CPUWriteMemoryFunc * const swapendian_writefn[3]={
3560     swapendian_mem_writeb,
3561     swapendian_mem_writew,
3562     swapendian_mem_writel
3563 };
3564
3565 static void swapendian_init(int io_index)
3566 {
3567     SwapEndianContainer *c = qemu_malloc(sizeof(SwapEndianContainer));
3568     int i;
3569
3570     /* Swap mmio for big endian targets */
3571     c->opaque = io_mem_opaque[io_index];
3572     for (i = 0; i < 3; i++) {
3573         c->read[i] = io_mem_read[io_index][i];
3574         c->write[i] = io_mem_write[io_index][i];
3575
3576         io_mem_read[io_index][i] = swapendian_readfn[i];
3577         io_mem_write[io_index][i] = swapendian_writefn[i];
3578     }
3579     io_mem_opaque[io_index] = c;
3580 }
3581
3582 static void swapendian_del(int io_index)
3583 {
3584     if (io_mem_read[io_index][0] == swapendian_readfn[0]) {
3585         qemu_free(io_mem_opaque[io_index]);
3586     }
3587 }
3588
3589 /* mem_read and mem_write are arrays of functions containing the
3590    function to access byte (index 0), word (index 1) and dword (index
3591    2). Functions can be omitted with a NULL function pointer.
3592    If io_index is non zero, the corresponding io zone is
3593    modified. If it is zero, a new io zone is allocated. The return
3594    value can be used with cpu_register_physical_memory(). (-1) is
3595    returned if error. */
3596 static int cpu_register_io_memory_fixed(int io_index,
3597                                         CPUReadMemoryFunc * const *mem_read,
3598                                         CPUWriteMemoryFunc * const *mem_write,
3599                                         void *opaque, enum device_endian endian)
3600 {
3601     int i;
3602
3603     if (io_index <= 0) {
3604         io_index = get_free_io_mem_idx();
3605         if (io_index == -1)
3606             return io_index;
3607     } else {
3608         io_index >>= IO_MEM_SHIFT;
3609         if (io_index >= IO_MEM_NB_ENTRIES)
3610             return -1;
3611     }
3612
3613     for (i = 0; i < 3; ++i) {
3614         io_mem_read[io_index][i]
3615             = (mem_read[i] ? mem_read[i] : unassigned_mem_read[i]);
3616     }
3617     for (i = 0; i < 3; ++i) {
3618         io_mem_write[io_index][i]
3619             = (mem_write[i] ? mem_write[i] : unassigned_mem_write[i]);
3620     }
3621     io_mem_opaque[io_index] = opaque;
3622
3623     switch (endian) {
3624     case DEVICE_BIG_ENDIAN:
3625 #ifndef TARGET_WORDS_BIGENDIAN
3626         swapendian_init(io_index);
3627 #endif
3628         break;
3629     case DEVICE_LITTLE_ENDIAN:
3630 #ifdef TARGET_WORDS_BIGENDIAN
3631         swapendian_init(io_index);
3632 #endif
3633         break;
3634     case DEVICE_NATIVE_ENDIAN:
3635     default:
3636         break;
3637     }
3638
3639     return (io_index << IO_MEM_SHIFT);
3640 }
3641
3642 int cpu_register_io_memory(CPUReadMemoryFunc * const *mem_read,
3643                            CPUWriteMemoryFunc * const *mem_write,
3644                            void *opaque, enum device_endian endian)
3645 {
3646     return cpu_register_io_memory_fixed(0, mem_read, mem_write, opaque, endian);
3647 }
3648
3649 void cpu_unregister_io_memory(int io_table_address)
3650 {
3651     int i;
3652     int io_index = io_table_address >> IO_MEM_SHIFT;
3653
3654     swapendian_del(io_index);
3655
3656     for (i=0;i < 3; i++) {
3657         io_mem_read[io_index][i] = unassigned_mem_read[i];
3658         io_mem_write[io_index][i] = unassigned_mem_write[i];
3659     }
3660     io_mem_opaque[io_index] = NULL;
3661     io_mem_used[io_index] = 0;
3662 }
3663
3664 static void io_mem_init(void)
3665 {
3666     int i;
3667
3668     cpu_register_io_memory_fixed(IO_MEM_ROM, error_mem_read,
3669                                  unassigned_mem_write, NULL,
3670                                  DEVICE_NATIVE_ENDIAN);
3671     cpu_register_io_memory_fixed(IO_MEM_UNASSIGNED, unassigned_mem_read,
3672                                  unassigned_mem_write, NULL,
3673                                  DEVICE_NATIVE_ENDIAN);
3674     cpu_register_io_memory_fixed(IO_MEM_NOTDIRTY, error_mem_read,
3675                                  notdirty_mem_write, NULL,
3676                                  DEVICE_NATIVE_ENDIAN);
3677     for (i=0; i<5; i++)
3678         io_mem_used[i] = 1;
3679
3680     io_mem_watch = cpu_register_io_memory(watch_mem_read,
3681                                           watch_mem_write, NULL,
3682                                           DEVICE_NATIVE_ENDIAN);
3683 }
3684
3685 #endif /* !defined(CONFIG_USER_ONLY) */
3686
3687 /* physical memory access (slow version, mainly for debug) */
3688 #if defined(CONFIG_USER_ONLY)
3689 int cpu_memory_rw_debug(CPUState *env, target_ulong addr,
3690                         uint8_t *buf, int len, int is_write)
3691 {
3692     int l, flags;
3693     target_ulong page;
3694     void * p;
3695
3696     while (len > 0) {
3697         page = addr & TARGET_PAGE_MASK;
3698         l = (page + TARGET_PAGE_SIZE) - addr;
3699         if (l > len)
3700             l = len;
3701         flags = page_get_flags(page);
3702         if (!(flags & PAGE_VALID))
3703             return -1;
3704         if (is_write) {
3705             if (!(flags & PAGE_WRITE))
3706                 return -1;
3707             /* XXX: this code should not depend on lock_user */
3708             if (!(p = lock_user(VERIFY_WRITE, addr, l, 0)))
3709                 return -1;
3710             memcpy(p, buf, l);
3711             unlock_user(p, addr, l);
3712         } else {
3713             if (!(flags & PAGE_READ))
3714                 return -1;
3715             /* XXX: this code should not depend on lock_user */
3716             if (!(p = lock_user(VERIFY_READ, addr, l, 1)))
3717                 return -1;
3718             memcpy(buf, p, l);
3719             unlock_user(p, addr, 0);
3720         }
3721         len -= l;
3722         buf += l;
3723         addr += l;
3724     }
3725     return 0;
3726 }
3727
3728 #else
3729 void cpu_physical_memory_rw(target_phys_addr_t addr, uint8_t *buf,
3730                             int len, int is_write)
3731 {
3732     int l, io_index;
3733     uint8_t *ptr;
3734     uint32_t val;
3735     target_phys_addr_t page;
3736     unsigned long pd;
3737     PhysPageDesc *p;
3738
3739     while (len > 0) {
3740         page = addr & TARGET_PAGE_MASK;
3741         l = (page + TARGET_PAGE_SIZE) - addr;
3742         if (l > len)
3743             l = len;
3744         p = phys_page_find(page >> TARGET_PAGE_BITS);
3745         if (!p) {
3746             pd = IO_MEM_UNASSIGNED;
3747         } else {
3748             pd = p->phys_offset;
3749         }
3750
3751         if (is_write) {
3752             if ((pd & ~TARGET_PAGE_MASK) != IO_MEM_RAM) {
3753                 target_phys_addr_t addr1 = addr;
3754                 io_index = (pd >> IO_MEM_SHIFT) & (IO_MEM_NB_ENTRIES - 1);
3755                 if (p)
3756                     addr1 = (addr & ~TARGET_PAGE_MASK) + p->region_offset;
3757                 /* XXX: could force cpu_single_env to NULL to avoid
3758                    potential bugs */
3759                 if (l >= 4 && ((addr1 & 3) == 0)) {
3760                     /* 32 bit write access */
3761                     val = ldl_p(buf);
3762                     io_mem_write[io_index][2](io_mem_opaque[io_index], addr1, val);
3763                     l = 4;
3764                 } else if (l >= 2 && ((addr1 & 1) == 0)) {
3765                     /* 16 bit write access */
3766                     val = lduw_p(buf);
3767                     io_mem_write[io_index][1](io_mem_opaque[io_index], addr1, val);
3768                     l = 2;
3769                 } else {
3770                     /* 8 bit write access */
3771                     val = ldub_p(buf);
3772                     io_mem_write[io_index][0](io_mem_opaque[io_index], addr1, val);
3773                     l = 1;
3774                 }
3775             } else {
3776                 unsigned long addr1;
3777                 addr1 = (pd & TARGET_PAGE_MASK) + (addr & ~TARGET_PAGE_MASK);
3778                 /* RAM case */
3779                 ptr = qemu_get_ram_ptr(addr1);
3780                 memcpy(ptr, buf, l);
3781                 if (!cpu_physical_memory_is_dirty(addr1)) {
3782                     /* invalidate code */
3783                     tb_invalidate_phys_page_range(addr1, addr1 + l, 0);
3784                     /* set dirty bit */
3785                     cpu_physical_memory_set_dirty_flags(
3786                         addr1, (0xff & ~CODE_DIRTY_FLAG));
3787                 }
3788             }
3789         } else {
3790             if ((pd & ~TARGET_PAGE_MASK) > IO_MEM_ROM &&
3791                 !(pd & IO_MEM_ROMD)) {
3792                 target_phys_addr_t addr1 = addr;
3793                 /* I/O case */
3794                 io_index = (pd >> IO_MEM_SHIFT) & (IO_MEM_NB_ENTRIES - 1);
3795                 if (p)
3796                     addr1 = (addr & ~TARGET_PAGE_MASK) + p->region_offset;
3797                 if (l >= 4 && ((addr1 & 3) == 0)) {
3798                     /* 32 bit read access */
3799                     val = io_mem_read[io_index][2](io_mem_opaque[io_index], addr1);
3800                     stl_p(buf, val);
3801                     l = 4;
3802                 } else if (l >= 2 && ((addr1 & 1) == 0)) {
3803                     /* 16 bit read access */
3804                     val = io_mem_read[io_index][1](io_mem_opaque[io_index], addr1);
3805                     stw_p(buf, val);
3806                     l = 2;
3807                 } else {
3808                     /* 8 bit read access */
3809                     val = io_mem_read[io_index][0](io_mem_opaque[io_index], addr1);
3810                     stb_p(buf, val);
3811                     l = 1;
3812                 }
3813             } else {
3814                 /* RAM case */
3815                 ptr = qemu_get_ram_ptr(pd & TARGET_PAGE_MASK) +
3816                     (addr & ~TARGET_PAGE_MASK);
3817                 memcpy(buf, ptr, l);
3818             }
3819         }
3820         len -= l;
3821         buf += l;
3822         addr += l;
3823     }
3824 }
3825
3826 /* used for ROM loading : can write in RAM and ROM */
3827 void cpu_physical_memory_write_rom(target_phys_addr_t addr,
3828                                    const uint8_t *buf, int len)
3829 {
3830     int l;
3831     uint8_t *ptr;
3832     target_phys_addr_t page;
3833     unsigned long pd;
3834     PhysPageDesc *p;
3835
3836     while (len > 0) {
3837         page = addr & TARGET_PAGE_MASK;
3838         l = (page + TARGET_PAGE_SIZE) - addr;
3839         if (l > len)
3840             l = len;
3841         p = phys_page_find(page >> TARGET_PAGE_BITS);
3842         if (!p) {
3843             pd = IO_MEM_UNASSIGNED;
3844         } else {
3845             pd = p->phys_offset;
3846         }
3847
3848         if ((pd & ~TARGET_PAGE_MASK) != IO_MEM_RAM &&
3849             (pd & ~TARGET_PAGE_MASK) != IO_MEM_ROM &&
3850             !(pd & IO_MEM_ROMD)) {
3851             /* do nothing */
3852         } else {
3853             unsigned long addr1;
3854             addr1 = (pd & TARGET_PAGE_MASK) + (addr & ~TARGET_PAGE_MASK);
3855             /* ROM/RAM case */
3856             ptr = qemu_get_ram_ptr(addr1);
3857             memcpy(ptr, buf, l);
3858         }
3859         len -= l;
3860         buf += l;
3861         addr += l;
3862     }
3863 }
3864
3865 typedef struct {
3866     void *buffer;
3867     target_phys_addr_t addr;
3868     target_phys_addr_t len;
3869 } BounceBuffer;
3870
3871 static BounceBuffer bounce;
3872
3873 typedef struct MapClient {
3874     void *opaque;
3875     void (*callback)(void *opaque);
3876     QLIST_ENTRY(MapClient) link;
3877 } MapClient;
3878
3879 static QLIST_HEAD(map_client_list, MapClient) map_client_list
3880     = QLIST_HEAD_INITIALIZER(map_client_list);
3881
3882 void *cpu_register_map_client(void *opaque, void (*callback)(void *opaque))
3883 {
3884     MapClient *client = qemu_malloc(sizeof(*client));
3885
3886     client->opaque = opaque;
3887     client->callback = callback;
3888     QLIST_INSERT_HEAD(&map_client_list, client, link);
3889     return client;
3890 }
3891
3892 void cpu_unregister_map_client(void *_client)
3893 {
3894     MapClient *client = (MapClient *)_client;
3895
3896     QLIST_REMOVE(client, link);
3897     qemu_free(client);
3898 }
3899
3900 static void cpu_notify_map_clients(void)
3901 {
3902     MapClient *client;
3903
3904     while (!QLIST_EMPTY(&map_client_list)) {
3905         client = QLIST_FIRST(&map_client_list);
3906         client->callback(client->opaque);
3907         cpu_unregister_map_client(client);
3908     }
3909 }
3910
3911 /* Map a physical memory region into a host virtual address.
3912  * May map a subset of the requested range, given by and returned in *plen.
3913  * May return NULL if resources needed to perform the mapping are exhausted.
3914  * Use only for reads OR writes - not for read-modify-write operations.
3915  * Use cpu_register_map_client() to know when retrying the map operation is
3916  * likely to succeed.
3917  */
3918 void *cpu_physical_memory_map(target_phys_addr_t addr,
3919                               target_phys_addr_t *plen,
3920                               int is_write)
3921 {
3922     target_phys_addr_t len = *plen;
3923     target_phys_addr_t done = 0;
3924     int l;
3925     uint8_t *ret = NULL;
3926     uint8_t *ptr;
3927     target_phys_addr_t page;
3928     unsigned long pd;
3929     PhysPageDesc *p;
3930     unsigned long addr1;
3931
3932     while (len > 0) {
3933         page = addr & TARGET_PAGE_MASK;
3934         l = (page + TARGET_PAGE_SIZE) - addr;
3935         if (l > len)
3936             l = len;
3937         p = phys_page_find(page >> TARGET_PAGE_BITS);
3938         if (!p) {
3939             pd = IO_MEM_UNASSIGNED;
3940         } else {
3941             pd = p->phys_offset;
3942         }
3943
3944         if ((pd & ~TARGET_PAGE_MASK) != IO_MEM_RAM) {
3945             if (done || bounce.buffer) {
3946                 break;
3947             }
3948             bounce.buffer = qemu_memalign(TARGET_PAGE_SIZE, TARGET_PAGE_SIZE);
3949             bounce.addr = addr;
3950             bounce.len = l;
3951             if (!is_write) {
3952                 cpu_physical_memory_read(addr, bounce.buffer, l);
3953             }
3954             ptr = bounce.buffer;
3955         } else {
3956             addr1 = (pd & TARGET_PAGE_MASK) + (addr & ~TARGET_PAGE_MASK);
3957             ptr = qemu_get_ram_ptr(addr1);
3958         }
3959         if (!done) {
3960             ret = ptr;
3961         } else if (ret + done != ptr) {
3962             break;
3963         }
3964
3965         len -= l;
3966         addr += l;
3967         done += l;
3968     }
3969     *plen = done;
3970     return ret;
3971 }
3972
3973 /* Unmaps a memory region previously mapped by cpu_physical_memory_map().
3974  * Will also mark the memory as dirty if is_write == 1.  access_len gives
3975  * the amount of memory that was actually read or written by the caller.
3976  */
3977 void cpu_physical_memory_unmap(void *buffer, target_phys_addr_t len,
3978                                int is_write, target_phys_addr_t access_len)
3979 {
3980     if (buffer != bounce.buffer) {
3981         if (is_write) {
3982             ram_addr_t addr1 = qemu_ram_addr_from_host_nofail(buffer);
3983             while (access_len) {
3984                 unsigned l;
3985                 l = TARGET_PAGE_SIZE;
3986                 if (l > access_len)
3987                     l = access_len;
3988                 if (!cpu_physical_memory_is_dirty(addr1)) {
3989                     /* invalidate code */
3990                     tb_invalidate_phys_page_range(addr1, addr1 + l, 0);
3991                     /* set dirty bit */
3992                     cpu_physical_memory_set_dirty_flags(
3993                         addr1, (0xff & ~CODE_DIRTY_FLAG));
3994                 }
3995                 addr1 += l;
3996                 access_len -= l;
3997             }
3998         }
3999         return;
4000     }
4001     if (is_write) {
4002         cpu_physical_memory_write(bounce.addr, bounce.buffer, access_len);
4003     }
4004     qemu_vfree(bounce.buffer);
4005     bounce.buffer = NULL;
4006     cpu_notify_map_clients();
4007 }
4008
4009 /* warning: addr must be aligned */
4010 uint32_t ldl_phys(target_phys_addr_t addr)
4011 {
4012     int io_index;
4013     uint8_t *ptr;
4014     uint32_t val;
4015     unsigned long pd;
4016     PhysPageDesc *p;
4017
4018     p = phys_page_find(addr >> TARGET_PAGE_BITS);
4019     if (!p) {
4020         pd = IO_MEM_UNASSIGNED;
4021     } else {
4022         pd = p->phys_offset;
4023     }
4024
4025     if ((pd & ~TARGET_PAGE_MASK) > IO_MEM_ROM &&
4026         !(pd & IO_MEM_ROMD)) {
4027         /* I/O case */
4028         io_index = (pd >> IO_MEM_SHIFT) & (IO_MEM_NB_ENTRIES - 1);
4029         if (p)
4030             addr = (addr & ~TARGET_PAGE_MASK) + p->region_offset;
4031         val = io_mem_read[io_index][2](io_mem_opaque[io_index], addr);
4032     } else {
4033         /* RAM case */
4034         ptr = qemu_get_ram_ptr(pd & TARGET_PAGE_MASK) +
4035             (addr & ~TARGET_PAGE_MASK);
4036         val = ldl_p(ptr);
4037     }
4038     return val;
4039 }
4040
4041 /* warning: addr must be aligned */
4042 uint64_t ldq_phys(target_phys_addr_t addr)
4043 {
4044     int io_index;
4045     uint8_t *ptr;
4046     uint64_t val;
4047     unsigned long pd;
4048     PhysPageDesc *p;
4049
4050     p = phys_page_find(addr >> TARGET_PAGE_BITS);
4051     if (!p) {
4052         pd = IO_MEM_UNASSIGNED;
4053     } else {
4054         pd = p->phys_offset;
4055     }
4056
4057     if ((pd & ~TARGET_PAGE_MASK) > IO_MEM_ROM &&
4058         !(pd & IO_MEM_ROMD)) {
4059         /* I/O case */
4060         io_index = (pd >> IO_MEM_SHIFT) & (IO_MEM_NB_ENTRIES - 1);
4061         if (p)
4062             addr = (addr & ~TARGET_PAGE_MASK) + p->region_offset;
4063 #ifdef TARGET_WORDS_BIGENDIAN
4064         val = (uint64_t)io_mem_read[io_index][2](io_mem_opaque[io_index], addr) << 32;
4065         val |= io_mem_read[io_index][2](io_mem_opaque[io_index], addr + 4);
4066 #else
4067         val = io_mem_read[io_index][2](io_mem_opaque[io_index], addr);
4068         val |= (uint64_t)io_mem_read[io_index][2](io_mem_opaque[io_index], addr + 4) << 32;
4069 #endif
4070     } else {
4071         /* RAM case */
4072         ptr = qemu_get_ram_ptr(pd & TARGET_PAGE_MASK) +
4073             (addr & ~TARGET_PAGE_MASK);
4074         val = ldq_p(ptr);
4075     }
4076     return val;
4077 }
4078
4079 /* XXX: optimize */
4080 uint32_t ldub_phys(target_phys_addr_t addr)
4081 {
4082     uint8_t val;
4083     cpu_physical_memory_read(addr, &val, 1);
4084     return val;
4085 }
4086
4087 /* warning: addr must be aligned */
4088 uint32_t lduw_phys(target_phys_addr_t addr)
4089 {
4090     int io_index;
4091     uint8_t *ptr;
4092     uint64_t val;
4093     unsigned long pd;
4094     PhysPageDesc *p;
4095
4096     p = phys_page_find(addr >> TARGET_PAGE_BITS);
4097     if (!p) {
4098         pd = IO_MEM_UNASSIGNED;
4099     } else {
4100         pd = p->phys_offset;
4101     }
4102
4103     if ((pd & ~TARGET_PAGE_MASK) > IO_MEM_ROM &&
4104         !(pd & IO_MEM_ROMD)) {
4105         /* I/O case */
4106         io_index = (pd >> IO_MEM_SHIFT) & (IO_MEM_NB_ENTRIES - 1);
4107         if (p)
4108             addr = (addr & ~TARGET_PAGE_MASK) + p->region_offset;
4109         val = io_mem_read[io_index][1](io_mem_opaque[io_index], addr);
4110     } else {
4111         /* RAM case */
4112         ptr = qemu_get_ram_ptr(pd & TARGET_PAGE_MASK) +
4113             (addr & ~TARGET_PAGE_MASK);
4114         val = lduw_p(ptr);
4115     }
4116     return val;
4117 }
4118
4119 /* warning: addr must be aligned. The ram page is not masked as dirty
4120    and the code inside is not invalidated. It is useful if the dirty
4121    bits are used to track modified PTEs */
4122 void stl_phys_notdirty(target_phys_addr_t addr, uint32_t val)
4123 {
4124     int io_index;
4125     uint8_t *ptr;
4126     unsigned long pd;
4127     PhysPageDesc *p;
4128
4129     p = phys_page_find(addr >> TARGET_PAGE_BITS);
4130     if (!p) {
4131         pd = IO_MEM_UNASSIGNED;
4132     } else {
4133         pd = p->phys_offset;
4134     }
4135
4136     if ((pd & ~TARGET_PAGE_MASK) != IO_MEM_RAM) {
4137         io_index = (pd >> IO_MEM_SHIFT) & (IO_MEM_NB_ENTRIES - 1);
4138         if (p)
4139             addr = (addr & ~TARGET_PAGE_MASK) + p->region_offset;
4140         io_mem_write[io_index][2](io_mem_opaque[io_index], addr, val);
4141     } else {
4142         unsigned long addr1 = (pd & TARGET_PAGE_MASK) + (addr & ~TARGET_PAGE_MASK);
4143         ptr = qemu_get_ram_ptr(addr1);
4144         stl_p(ptr, val);
4145
4146         if (unlikely(in_migration)) {
4147             if (!cpu_physical_memory_is_dirty(addr1)) {
4148                 /* invalidate code */
4149                 tb_invalidate_phys_page_range(addr1, addr1 + 4, 0);
4150                 /* set dirty bit */
4151                 cpu_physical_memory_set_dirty_flags(
4152                     addr1, (0xff & ~CODE_DIRTY_FLAG));
4153             }
4154         }
4155     }
4156 }
4157
4158 void stq_phys_notdirty(target_phys_addr_t addr, uint64_t val)
4159 {
4160     int io_index;
4161     uint8_t *ptr;
4162     unsigned long pd;
4163     PhysPageDesc *p;
4164
4165     p = phys_page_find(addr >> TARGET_PAGE_BITS);
4166     if (!p) {
4167         pd = IO_MEM_UNASSIGNED;
4168     } else {
4169         pd = p->phys_offset;
4170     }
4171
4172     if ((pd & ~TARGET_PAGE_MASK) != IO_MEM_RAM) {
4173         io_index = (pd >> IO_MEM_SHIFT) & (IO_MEM_NB_ENTRIES - 1);
4174         if (p)
4175             addr = (addr & ~TARGET_PAGE_MASK) + p->region_offset;
4176 #ifdef TARGET_WORDS_BIGENDIAN
4177         io_mem_write[io_index][2](io_mem_opaque[io_index], addr, val >> 32);
4178         io_mem_write[io_index][2](io_mem_opaque[io_index], addr + 4, val);
4179 #else
4180         io_mem_write[io_index][2](io_mem_opaque[io_index], addr, val);
4181         io_mem_write[io_index][2](io_mem_opaque[io_index], addr + 4, val >> 32);
4182 #endif
4183     } else {
4184         ptr = qemu_get_ram_ptr(pd & TARGET_PAGE_MASK) +
4185             (addr & ~TARGET_PAGE_MASK);
4186         stq_p(ptr, val);
4187     }
4188 }
4189
4190 /* warning: addr must be aligned */
4191 void stl_phys(target_phys_addr_t addr, uint32_t val)
4192 {
4193     int io_index;
4194     uint8_t *ptr;
4195     unsigned long pd;
4196     PhysPageDesc *p;
4197
4198     p = phys_page_find(addr >> TARGET_PAGE_BITS);
4199     if (!p) {
4200         pd = IO_MEM_UNASSIGNED;
4201     } else {
4202         pd = p->phys_offset;
4203     }
4204
4205     if ((pd & ~TARGET_PAGE_MASK) != IO_MEM_RAM) {
4206         io_index = (pd >> IO_MEM_SHIFT) & (IO_MEM_NB_ENTRIES - 1);
4207         if (p)
4208             addr = (addr & ~TARGET_PAGE_MASK) + p->region_offset;
4209         io_mem_write[io_index][2](io_mem_opaque[io_index], addr, val);
4210     } else {
4211         unsigned long addr1;
4212         addr1 = (pd & TARGET_PAGE_MASK) + (addr & ~TARGET_PAGE_MASK);
4213         /* RAM case */
4214         ptr = qemu_get_ram_ptr(addr1);
4215         stl_p(ptr, val);
4216         if (!cpu_physical_memory_is_dirty(addr1)) {
4217             /* invalidate code */
4218             tb_invalidate_phys_page_range(addr1, addr1 + 4, 0);
4219             /* set dirty bit */
4220             cpu_physical_memory_set_dirty_flags(addr1,
4221                 (0xff & ~CODE_DIRTY_FLAG));
4222         }
4223     }
4224 }
4225
4226 /* XXX: optimize */
4227 void stb_phys(target_phys_addr_t addr, uint32_t val)
4228 {
4229     uint8_t v = val;
4230     cpu_physical_memory_write(addr, &v, 1);
4231 }
4232
4233 /* warning: addr must be aligned */
4234 void stw_phys(target_phys_addr_t addr, uint32_t val)
4235 {
4236     int io_index;
4237     uint8_t *ptr;
4238     unsigned long pd;
4239     PhysPageDesc *p;
4240
4241     p = phys_page_find(addr >> TARGET_PAGE_BITS);
4242     if (!p) {
4243         pd = IO_MEM_UNASSIGNED;
4244     } else {
4245         pd = p->phys_offset;
4246     }
4247
4248     if ((pd & ~TARGET_PAGE_MASK) != IO_MEM_RAM) {
4249         io_index = (pd >> IO_MEM_SHIFT) & (IO_MEM_NB_ENTRIES - 1);
4250         if (p)
4251             addr = (addr & ~TARGET_PAGE_MASK) + p->region_offset;
4252         io_mem_write[io_index][1](io_mem_opaque[io_index], addr, val);
4253     } else {
4254         unsigned long addr1;
4255         addr1 = (pd & TARGET_PAGE_MASK) + (addr & ~TARGET_PAGE_MASK);
4256         /* RAM case */
4257         ptr = qemu_get_ram_ptr(addr1);
4258         stw_p(ptr, val);
4259         if (!cpu_physical_memory_is_dirty(addr1)) {
4260             /* invalidate code */
4261             tb_invalidate_phys_page_range(addr1, addr1 + 2, 0);
4262             /* set dirty bit */
4263             cpu_physical_memory_set_dirty_flags(addr1,
4264                 (0xff & ~CODE_DIRTY_FLAG));
4265         }
4266     }
4267 }
4268
4269 /* XXX: optimize */
4270 void stq_phys(target_phys_addr_t addr, uint64_t val)
4271 {
4272     val = tswap64(val);
4273     cpu_physical_memory_write(addr, &val, 8);
4274 }
4275
4276 /* virtual memory access for debug (includes writing to ROM) */
4277 int cpu_memory_rw_debug(CPUState *env, target_ulong addr,
4278                         uint8_t *buf, int len, int is_write)
4279 {
4280     int l;
4281     target_phys_addr_t phys_addr;
4282     target_ulong page;
4283
4284     while (len > 0) {
4285         page = addr & TARGET_PAGE_MASK;
4286         phys_addr = cpu_get_phys_page_debug(env, page);
4287         /* if no physical page mapped, return an error */
4288         if (phys_addr == -1)
4289             return -1;
4290         l = (page + TARGET_PAGE_SIZE) - addr;
4291         if (l > len)
4292             l = len;
4293         phys_addr += (addr & ~TARGET_PAGE_MASK);
4294         if (is_write)
4295             cpu_physical_memory_write_rom(phys_addr, buf, l);
4296         else
4297             cpu_physical_memory_rw(phys_addr, buf, l, is_write);
4298         len -= l;
4299         buf += l;
4300         addr += l;
4301     }
4302     return 0;
4303 }
4304 #endif
4305
4306 /* in deterministic execution mode, instructions doing device I/Os
4307    must be at the end of the TB */
4308 void cpu_io_recompile(CPUState *env, void *retaddr)
4309 {
4310     TranslationBlock *tb;
4311     uint32_t n, cflags;
4312     target_ulong pc, cs_base;
4313     uint64_t flags;
4314
4315     tb = tb_find_pc((unsigned long)retaddr);
4316     if (!tb) {
4317         cpu_abort(env, "cpu_io_recompile: could not find TB for pc=%p",
4318                   retaddr);
4319     }
4320     n = env->icount_decr.u16.low + tb->icount;
4321     cpu_restore_state(tb, env, (unsigned long)retaddr);
4322     /* Calculate how many instructions had been executed before the fault
4323        occurred.  */
4324     n = n - env->icount_decr.u16.low;
4325     /* Generate a new TB ending on the I/O insn.  */
4326     n++;
4327     /* On MIPS and SH, delay slot instructions can only be restarted if
4328        they were already the first instruction in the TB.  If this is not
4329        the first instruction in a TB then re-execute the preceding
4330        branch.  */
4331 #if defined(TARGET_MIPS)
4332     if ((env->hflags & MIPS_HFLAG_BMASK) != 0 && n > 1) {
4333         env->active_tc.PC -= 4;
4334         env->icount_decr.u16.low++;
4335         env->hflags &= ~MIPS_HFLAG_BMASK;
4336     }
4337 #elif defined(TARGET_SH4)
4338     if ((env->flags & ((DELAY_SLOT | DELAY_SLOT_CONDITIONAL))) != 0
4339             && n > 1) {
4340         env->pc -= 2;
4341         env->icount_decr.u16.low++;
4342         env->flags &= ~(DELAY_SLOT | DELAY_SLOT_CONDITIONAL);
4343     }
4344 #endif
4345     /* This should never happen.  */
4346     if (n > CF_COUNT_MASK)
4347         cpu_abort(env, "TB too big during recompile");
4348
4349     cflags = n | CF_LAST_IO;
4350     pc = tb->pc;
4351     cs_base = tb->cs_base;
4352     flags = tb->flags;
4353     tb_phys_invalidate(tb, -1);
4354     /* FIXME: In theory this could raise an exception.  In practice
4355        we have already translated the block once so it's probably ok.  */
4356     tb_gen_code(env, pc, cs_base, flags, cflags);
4357     /* TODO: If env->pc != tb->pc (i.e. the faulting instruction was not
4358        the first in the TB) then we end up generating a whole new TB and
4359        repeating the fault, which is horribly inefficient.
4360        Better would be to execute just this insn uncached, or generate a
4361        second new TB.  */
4362     cpu_resume_from_signal(env, NULL);
4363 }
4364
4365 #if !defined(CONFIG_USER_ONLY)
4366
4367 void dump_exec_info(FILE *f, fprintf_function cpu_fprintf)
4368 {
4369     int i, target_code_size, max_target_code_size;
4370     int direct_jmp_count, direct_jmp2_count, cross_page;
4371     TranslationBlock *tb;
4372
4373     target_code_size = 0;
4374     max_target_code_size = 0;
4375     cross_page = 0;
4376     direct_jmp_count = 0;
4377     direct_jmp2_count = 0;
4378     for(i = 0; i < nb_tbs; i++) {
4379         tb = &tbs[i];
4380         target_code_size += tb->size;
4381         if (tb->size > max_target_code_size)
4382             max_target_code_size = tb->size;
4383         if (tb->page_addr[1] != -1)
4384             cross_page++;
4385         if (tb->tb_next_offset[0] != 0xffff) {
4386             direct_jmp_count++;
4387             if (tb->tb_next_offset[1] != 0xffff) {
4388                 direct_jmp2_count++;
4389             }
4390         }
4391     }
4392     /* XXX: avoid using doubles ? */
4393     cpu_fprintf(f, "Translation buffer state:\n");
4394     cpu_fprintf(f, "gen code size       %td/%ld\n",
4395                 code_gen_ptr - code_gen_buffer, code_gen_buffer_max_size);
4396     cpu_fprintf(f, "TB count            %d/%d\n",
4397                 nb_tbs, code_gen_max_blocks);
4398     cpu_fprintf(f, "TB avg target size  %d max=%d bytes\n",
4399                 nb_tbs ? target_code_size / nb_tbs : 0,
4400                 max_target_code_size);
4401     cpu_fprintf(f, "TB avg host size    %td bytes (expansion ratio: %0.1f)\n",
4402                 nb_tbs ? (code_gen_ptr - code_gen_buffer) / nb_tbs : 0,
4403                 target_code_size ? (double) (code_gen_ptr - code_gen_buffer) / target_code_size : 0);
4404     cpu_fprintf(f, "cross page TB count %d (%d%%)\n",
4405             cross_page,
4406             nb_tbs ? (cross_page * 100) / nb_tbs : 0);
4407     cpu_fprintf(f, "direct jump count   %d (%d%%) (2 jumps=%d %d%%)\n",
4408                 direct_jmp_count,
4409                 nb_tbs ? (direct_jmp_count * 100) / nb_tbs : 0,
4410                 direct_jmp2_count,
4411                 nb_tbs ? (direct_jmp2_count * 100) / nb_tbs : 0);
4412     cpu_fprintf(f, "\nStatistics:\n");
4413     cpu_fprintf(f, "TB flush count      %d\n", tb_flush_count);
4414     cpu_fprintf(f, "TB invalidate count %d\n", tb_phys_invalidate_count);
4415     cpu_fprintf(f, "TLB flush count     %d\n", tlb_flush_count);
4416     tcg_dump_info(f, cpu_fprintf);
4417 }
4418
4419 #define MMUSUFFIX _cmmu
4420 #define GETPC() NULL
4421 #define env cpu_single_env
4422 #define SOFTMMU_CODE_ACCESS
4423
4424 #define SHIFT 0
4425 #include "softmmu_template.h"
4426
4427 #define SHIFT 1
4428 #include "softmmu_template.h"
4429
4430 #define SHIFT 2
4431 #include "softmmu_template.h"
4432
4433 #define SHIFT 3
4434 #include "softmmu_template.h"
4435
4436 #undef env
4437
4438 #endif