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