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