translate-all.c

   1 /*
   2  *  Host code generation
   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 #ifdef _WIN32
  20 #include <windows.h>
  21 #else
  22 #include <sys/types.h>
  23 #include <sys/mman.h>
  24 #endif
  25 #include <stdarg.h>
  26 #include <stdlib.h>
  27 #include <stdio.h>
  28 #include <string.h>
  29 #include <inttypes.h>
  30
  31 #include "config.h"
  32
  33 #include "qemu-common.h"
  34 #define NO_CPU_IO_DEFS
  35 #include "cpu.h"
  36 #include "trace.h"
  37 #include "disas/disas.h"
  38 #include "tcg.h"
  39 #if defined(CONFIG_USER_ONLY)
  40 #include "qemu.h"
  41 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
  42 #include <sys/param.h>
  43 #if __FreeBSD_version >= 700104
  44 #define HAVE_KINFO_GETVMMAP
  45 #define sigqueue sigqueue_freebsd  /* avoid redefinition */
  46 #include <sys/time.h>
  47 #include <sys/proc.h>
  48 #include <machine/profile.h>
  49 #define _KERNEL
  50 #include <sys/user.h>
  51 #undef _KERNEL
  52 #undef sigqueue
  53 #include <libutil.h>
  54 #endif
  55 #endif
  56 #else
  57 #include "exec/address-spaces.h"
  58 #endif
  59
  60 #include "exec/cputlb.h"
  61 #include "exec/tb-hash.h"
  62 #include "translate-all.h"
  63 #include "qemu/bitmap.h"
  64 #include "qemu/timer.h"
  65
  66 //#define DEBUG_TB_INVALIDATE
  67 //#define DEBUG_FLUSH
  68 /* make various TB consistency checks */
  69 //#define DEBUG_TB_CHECK
  70
  71 #if !defined(CONFIG_USER_ONLY)
  72 /* TB consistency checks only implemented for usermode emulation.  */
  73 #undef DEBUG_TB_CHECK
  74 #endif
  75
  76 #define SMC_BITMAP_USE_THRESHOLD 10
  77
  78 typedef struct PageDesc {
  79     /* list of TBs intersecting this ram page */
  80     TranslationBlock *first_tb;
  81     /* in order to optimize self modifying code, we count the number
  82        of lookups we do to a given page to use a bitmap */
  83     unsigned int code_write_count;
  84     unsigned long *code_bitmap;
  85 #if defined(CONFIG_USER_ONLY)
  86     unsigned long flags;
  87 #endif
  88 } PageDesc;
  89
  90 /* In system mode we want L1_MAP to be based on ram offsets,
  91    while in user mode we want it to be based on virtual addresses.  */
  92 #if !defined(CONFIG_USER_ONLY)
  93 #if HOST_LONG_BITS < TARGET_PHYS_ADDR_SPACE_BITS
  94 # define L1_MAP_ADDR_SPACE_BITS  HOST_LONG_BITS
  95 #else
  96 # define L1_MAP_ADDR_SPACE_BITS  TARGET_PHYS_ADDR_SPACE_BITS
  97 #endif
  98 #else
  99 # define L1_MAP_ADDR_SPACE_BITS  TARGET_VIRT_ADDR_SPACE_BITS
 100 #endif
 101
 102 /* Size of the L2 (and L3, etc) page tables.  */
 103 #define V_L2_BITS 10
 104 #define V_L2_SIZE (1 << V_L2_BITS)
 105
 106 /* The bits remaining after N lower levels of page tables.  */
 107 #define V_L1_BITS_REM \
 108     ((L1_MAP_ADDR_SPACE_BITS - TARGET_PAGE_BITS) % V_L2_BITS)
 109
 110 #if V_L1_BITS_REM < 4
 111 #define V_L1_BITS  (V_L1_BITS_REM + V_L2_BITS)
 112 #else
 113 #define V_L1_BITS  V_L1_BITS_REM
 114 #endif
 115
 116 #define V_L1_SIZE  ((target_ulong)1 << V_L1_BITS)
 117
 118 #define V_L1_SHIFT (L1_MAP_ADDR_SPACE_BITS - TARGET_PAGE_BITS - V_L1_BITS)
 119
 120 uintptr_t qemu_host_page_size;
 121 uintptr_t qemu_host_page_mask;
 122
 123 /* The bottom level has pointers to PageDesc */
 124 static void *l1_map[V_L1_SIZE];
 125
 126 /* code generation context */
 127 TCGContext tcg_ctx;
 128
 129 /* translation block context */
 130 #ifdef CONFIG_USER_ONLY
 131 __thread int have_tb_lock;
 132 #endif
 133
 134 void tb_lock(void)
 135 {
 136 #ifdef CONFIG_USER_ONLY
 137     assert(!have_tb_lock);
 138     qemu_mutex_lock(&tcg_ctx.tb_ctx.tb_lock);
 139     have_tb_lock++;
 140 #endif
 141 }
 142
 143 void tb_unlock(void)
 144 {
 145 #ifdef CONFIG_USER_ONLY
 146     assert(have_tb_lock);
 147     have_tb_lock--;
 148     qemu_mutex_unlock(&tcg_ctx.tb_ctx.tb_lock);
 149 #endif
 150 }
 151
 152 void tb_lock_reset(void)
 153 {
 154 #ifdef CONFIG_USER_ONLY
 155     if (have_tb_lock) {
 156         qemu_mutex_unlock(&tcg_ctx.tb_ctx.tb_lock);
 157         have_tb_lock = 0;
 158     }
 159 #endif
 160 }
 161
 162 static void tb_link_page(TranslationBlock *tb, tb_page_addr_t phys_pc,
 163                          tb_page_addr_t phys_page2);
 164 static TranslationBlock *tb_find_pc(uintptr_t tc_ptr);
 165
 166 void cpu_gen_init(void)
 167 {
 168     tcg_context_init(&tcg_ctx);
 169 }
 170
 171 /* The cpu state corresponding to 'searched_pc' is restored.  */
 172 static int cpu_restore_state_from_tb(CPUState *cpu, TranslationBlock *tb,
 173                                      uintptr_t searched_pc)
 174 {
 175     CPUArchState *env = cpu->env_ptr;
 176     TCGContext *s = &tcg_ctx;
 177     int j;
 178     uintptr_t tc_ptr;
 179 #ifdef CONFIG_PROFILER
 180     int64_t ti;
 181 #endif
 182
 183 #ifdef CONFIG_PROFILER
 184     ti = profile_getclock();
 185 #endif
 186     tcg_func_start(s);
 187
 188     gen_intermediate_code_pc(env, tb);
 189
 190     if (tb->cflags & CF_USE_ICOUNT) {
 191         assert(use_icount);
 192         /* Reset the cycle counter to the start of the block.  */
 193         cpu->icount_decr.u16.low += tb->icount;
 194         /* Clear the IO flag.  */
 195         cpu->can_do_io = 0;
 196     }
 197
 198     /* find opc index corresponding to search_pc */
 199     tc_ptr = (uintptr_t)tb->tc_ptr;
 200     if (searched_pc < tc_ptr)
 201         return -1;
 202
 203     s->tb_next_offset = tb->tb_next_offset;
 204 #ifdef USE_DIRECT_JUMP
 205     s->tb_jmp_offset = tb->tb_jmp_offset;
 206     s->tb_next = NULL;
 207 #else
 208     s->tb_jmp_offset = NULL;
 209     s->tb_next = tb->tb_next;
 210 #endif
 211     j = tcg_gen_code_search_pc(s, (tcg_insn_unit *)tc_ptr,
 212                                searched_pc - tc_ptr);
 213     if (j < 0)
 214         return -1;
 215     /* now find start of instruction before */
 216     while (s->gen_opc_instr_start[j] == 0) {
 217         j--;
 218     }
 219     cpu->icount_decr.u16.low -= s->gen_opc_icount[j];
 220
 221     restore_state_to_opc(env, tb, s->gen_opc_data);
 222
 223 #ifdef CONFIG_PROFILER
 224     s->restore_time += profile_getclock() - ti;
 225     s->restore_count++;
 226 #endif
 227     return 0;
 228 }
 229
 230 bool cpu_restore_state(CPUState *cpu, uintptr_t retaddr)
 231 {
 232     TranslationBlock *tb;
 233
 234     tb = tb_find_pc(retaddr);
 235     if (tb) {
 236         cpu_restore_state_from_tb(cpu, tb, retaddr);
 237         if (tb->cflags & CF_NOCACHE) {
 238             /* one-shot translation, invalidate it immediately */
 239             cpu->current_tb = NULL;
 240             tb_phys_invalidate(tb, -1);
 241             tb_free(tb);
 242         }
 243         return true;
 244     }
 245     return false;
 246 }
 247
 248 #ifdef _WIN32
 249 static __attribute__((unused)) void map_exec(void *addr, long size)
 250 {
 251     DWORD old_protect;
 252     VirtualProtect(addr, size,
 253                    PAGE_EXECUTE_READWRITE, &old_protect);
 254 }
 255 #else
 256 static __attribute__((unused)) void map_exec(void *addr, long size)
 257 {
 258     unsigned long start, end, page_size;
 259
 260     page_size = getpagesize();
 261     start = (unsigned long)addr;
 262     start &= ~(page_size - 1);
 263
 264     end = (unsigned long)addr + size;
 265     end += page_size - 1;
 266     end &= ~(page_size - 1);
 267
 268     mprotect((void *)start, end - start,
 269              PROT_READ | PROT_WRITE | PROT_EXEC);
 270 }
 271 #endif
 272
 273 void page_size_init(void)
 274 {
 275     /* NOTE: we can always suppose that qemu_host_page_size >=
 276        TARGET_PAGE_SIZE */
 277     qemu_real_host_page_size = getpagesize();
 278     qemu_real_host_page_mask = ~(qemu_real_host_page_size - 1);
 279     if (qemu_host_page_size == 0) {
 280         qemu_host_page_size = qemu_real_host_page_size;
 281     }
 282     if (qemu_host_page_size < TARGET_PAGE_SIZE) {
 283         qemu_host_page_size = TARGET_PAGE_SIZE;
 284     }
 285     qemu_host_page_mask = ~(qemu_host_page_size - 1);
 286 }
 287
 288 static void page_init(void)
 289 {
 290     page_size_init();
 291 #if defined(CONFIG_BSD) && defined(CONFIG_USER_ONLY)
 292     {
 293 #ifdef HAVE_KINFO_GETVMMAP
 294         struct kinfo_vmentry *freep;
 295         int i, cnt;
 296
 297         freep = kinfo_getvmmap(getpid(), &cnt);
 298         if (freep) {
 299             mmap_lock();
 300             for (i = 0; i < cnt; i++) {
 301                 unsigned long startaddr, endaddr;
 302
 303                 startaddr = freep[i].kve_start;
 304                 endaddr = freep[i].kve_end;
 305                 if (h2g_valid(startaddr)) {
 306                     startaddr = h2g(startaddr) & TARGET_PAGE_MASK;
 307
 308                     if (h2g_valid(endaddr)) {
 309                         endaddr = h2g(endaddr);
 310                         page_set_flags(startaddr, endaddr, PAGE_RESERVED);
 311                     } else {
 312 #if TARGET_ABI_BITS <= L1_MAP_ADDR_SPACE_BITS
 313                         endaddr = ~0ul;
 314                         page_set_flags(startaddr, endaddr, PAGE_RESERVED);
 315 #endif
 316                     }
 317                 }
 318             }
 319             free(freep);
 320             mmap_unlock();
 321         }
 322 #else
 323         FILE *f;
 324
 325         last_brk = (unsigned long)sbrk(0);
 326
 327         f = fopen("/compat/linux/proc/self/maps", "r");
 328         if (f) {
 329             mmap_lock();
 330
 331             do {
 332                 unsigned long startaddr, endaddr;
 333                 int n;
 334
 335                 n = fscanf(f, "%lx-%lx %*[^\n]\n", &startaddr, &endaddr);
 336
 337                 if (n == 2 && h2g_valid(startaddr)) {
 338                     startaddr = h2g(startaddr) & TARGET_PAGE_MASK;
 339
 340                     if (h2g_valid(endaddr)) {
 341                         endaddr = h2g(endaddr);
 342                     } else {
 343                         endaddr = ~0ul;
 344                     }
 345                     page_set_flags(startaddr, endaddr, PAGE_RESERVED);
 346                 }
 347             } while (!feof(f));
 348
 349             fclose(f);
 350             mmap_unlock();
 351         }
 352 #endif
 353     }
 354 #endif
 355 }
 356
 357 /* If alloc=1:
 358  * Called with mmap_lock held for user-mode emulation.
 359  */
 360 static PageDesc *page_find_alloc(tb_page_addr_t index, int alloc)
 361 {
 362     PageDesc *pd;
 363     void **lp;
 364     int i;
 365
 366     /* Level 1.  Always allocated.  */
 367     lp = l1_map + ((index >> V_L1_SHIFT) & (V_L1_SIZE - 1));
 368
 369     /* Level 2..N-1.  */
 370     for (i = V_L1_SHIFT / V_L2_BITS - 1; i > 0; i--) {
 371         void **p = atomic_rcu_read(lp);
 372
 373         if (p == NULL) {
 374             if (!alloc) {
 375                 return NULL;
 376             }
 377             p = g_new0(void *, V_L2_SIZE);
 378             atomic_rcu_set(lp, p);
 379         }
 380
 381         lp = p + ((index >> (i * V_L2_BITS)) & (V_L2_SIZE - 1));
 382     }
 383
 384     pd = atomic_rcu_read(lp);
 385     if (pd == NULL) {
 386         if (!alloc) {
 387             return NULL;
 388         }
 389         pd = g_new0(PageDesc, V_L2_SIZE);
 390         atomic_rcu_set(lp, pd);
 391     }
 392
 393     return pd + (index & (V_L2_SIZE - 1));
 394 }
 395
 396 static inline PageDesc *page_find(tb_page_addr_t index)
 397 {
 398     return page_find_alloc(index, 0);
 399 }
 400
 401 #if defined(CONFIG_USER_ONLY)
 402 /* Currently it is not recommended to allocate big chunks of data in
 403    user mode. It will change when a dedicated libc will be used.  */
 404 /* ??? 64-bit hosts ought to have no problem mmaping data outside the
 405    region in which the guest needs to run.  Revisit this.  */
 406 #define USE_STATIC_CODE_GEN_BUFFER
 407 #endif
 408
 409 /* ??? Should configure for this, not list operating systems here.  */
 410 #if (defined(__linux__) \
 411     || defined(__FreeBSD__) || defined(__FreeBSD_kernel__) \
 412     || defined(__DragonFly__) || defined(__OpenBSD__) \
 413     || defined(__NetBSD__))
 414 # define USE_MMAP
 415 #endif
 416
 417 /* Minimum size of the code gen buffer.  This number is randomly chosen,
 418    but not so small that we can't have a fair number of TB's live.  */
 419 #define MIN_CODE_GEN_BUFFER_SIZE     (1024u * 1024)
 420
 421 /* Maximum size of the code gen buffer we'd like to use.  Unless otherwise
 422    indicated, this is constrained by the range of direct branches on the
 423    host cpu, as used by the TCG implementation of goto_tb.  */
 424 #if defined(__x86_64__)
 425 # define MAX_CODE_GEN_BUFFER_SIZE  (2ul * 1024 * 1024 * 1024)
 426 #elif defined(__sparc__)
 427 # define MAX_CODE_GEN_BUFFER_SIZE  (2ul * 1024 * 1024 * 1024)
 428 #elif defined(__aarch64__)
 429 # define MAX_CODE_GEN_BUFFER_SIZE  (128ul * 1024 * 1024)
 430 #elif defined(__arm__)
 431 # define MAX_CODE_GEN_BUFFER_SIZE  (16u * 1024 * 1024)
 432 #elif defined(__s390x__)
 433   /* We have a +- 4GB range on the branches; leave some slop.  */
 434 # define MAX_CODE_GEN_BUFFER_SIZE  (3ul * 1024 * 1024 * 1024)
 435 #elif defined(__mips__)
 436   /* We have a 256MB branch region, but leave room to make sure the
 437      main executable is also within that region.  */
 438 # define MAX_CODE_GEN_BUFFER_SIZE  (128ul * 1024 * 1024)
 439 #else
 440 # define MAX_CODE_GEN_BUFFER_SIZE  ((size_t)-1)
 441 #endif
 442
 443 #define DEFAULT_CODE_GEN_BUFFER_SIZE_1 (32u * 1024 * 1024)
 444
 445 #define DEFAULT_CODE_GEN_BUFFER_SIZE \
 446   (DEFAULT_CODE_GEN_BUFFER_SIZE_1 < MAX_CODE_GEN_BUFFER_SIZE \
 447    ? DEFAULT_CODE_GEN_BUFFER_SIZE_1 : MAX_CODE_GEN_BUFFER_SIZE)
 448
 449 static inline size_t size_code_gen_buffer(size_t tb_size)
 450 {
 451     /* Size the buffer.  */
 452     if (tb_size == 0) {
 453 #ifdef USE_STATIC_CODE_GEN_BUFFER
 454         tb_size = DEFAULT_CODE_GEN_BUFFER_SIZE;
 455 #else
 456         /* ??? Needs adjustments.  */
 457         /* ??? If we relax the requirement that CONFIG_USER_ONLY use the
 458            static buffer, we could size this on RESERVED_VA, on the text
 459            segment size of the executable, or continue to use the default.  */
 460         tb_size = (unsigned long)(ram_size / 4);
 461 #endif
 462     }
 463     if (tb_size < MIN_CODE_GEN_BUFFER_SIZE) {
 464         tb_size = MIN_CODE_GEN_BUFFER_SIZE;
 465     }
 466     if (tb_size > MAX_CODE_GEN_BUFFER_SIZE) {
 467         tb_size = MAX_CODE_GEN_BUFFER_SIZE;
 468     }
 469     tcg_ctx.code_gen_buffer_size = tb_size;
 470     return tb_size;
 471 }
 472
 473 #ifdef __mips__
 474 /* In order to use J and JAL within the code_gen_buffer, we require
 475    that the buffer not cross a 256MB boundary.  */
 476 static inline bool cross_256mb(void *addr, size_t size)
 477 {
 478     return ((uintptr_t)addr ^ ((uintptr_t)addr + size)) & 0xf0000000;
 479 }
 480
 481 /* We weren't able to allocate a buffer without crossing that boundary,
 482    so make do with the larger portion of the buffer that doesn't cross.
 483    Returns the new base of the buffer, and adjusts code_gen_buffer_size.  */
 484 static inline void *split_cross_256mb(void *buf1, size_t size1)
 485 {
 486     void *buf2 = (void *)(((uintptr_t)buf1 + size1) & 0xf0000000);
 487     size_t size2 = buf1 + size1 - buf2;
 488
 489     size1 = buf2 - buf1;
 490     if (size1 < size2) {
 491         size1 = size2;
 492         buf1 = buf2;
 493     }
 494
 495     tcg_ctx.code_gen_buffer_size = size1;
 496     return buf1;
 497 }
 498 #endif
 499
 500 #ifdef USE_STATIC_CODE_GEN_BUFFER
 501 static uint8_t static_code_gen_buffer[DEFAULT_CODE_GEN_BUFFER_SIZE]
 502     __attribute__((aligned(CODE_GEN_ALIGN)));
 503
 504 static inline void *alloc_code_gen_buffer(void)
 505 {
 506     void *buf = static_code_gen_buffer;
 507 #ifdef __mips__
 508     if (cross_256mb(buf, tcg_ctx.code_gen_buffer_size)) {
 509         buf = split_cross_256mb(buf, tcg_ctx.code_gen_buffer_size);
 510     }
 511 #endif
 512     map_exec(buf, tcg_ctx.code_gen_buffer_size);
 513     return buf;
 514 }
 515 #elif defined(USE_MMAP)
 516 static inline void *alloc_code_gen_buffer(void)
 517 {
 518     int flags = MAP_PRIVATE | MAP_ANONYMOUS;
 519     uintptr_t start = 0;
 520     void *buf;
 521
 522     /* Constrain the position of the buffer based on the host cpu.
 523        Note that these addresses are chosen in concert with the
 524        addresses assigned in the relevant linker script file.  */
 525 # if defined(__PIE__) || defined(__PIC__)
 526     /* Don't bother setting a preferred location if we're building
 527        a position-independent executable.  We're more likely to get
 528        an address near the main executable if we let the kernel
 529        choose the address.  */
 530 # elif defined(__x86_64__) && defined(MAP_32BIT)
 531     /* Force the memory down into low memory with the executable.
 532        Leave the choice of exact location with the kernel.  */
 533     flags |= MAP_32BIT;
 534     /* Cannot expect to map more than 800MB in low memory.  */
 535     if (tcg_ctx.code_gen_buffer_size > 800u * 1024 * 1024) {
 536         tcg_ctx.code_gen_buffer_size = 800u * 1024 * 1024;
 537     }
 538 # elif defined(__sparc__)
 539     start = 0x40000000ul;
 540 # elif defined(__s390x__)
 541     start = 0x90000000ul;
 542 # elif defined(__mips__)
 543     /* ??? We ought to more explicitly manage layout for softmmu too.  */
 544 #  ifdef CONFIG_USER_ONLY
 545     start = 0x68000000ul;
 546 #  elif _MIPS_SIM == _ABI64
 547     start = 0x128000000ul;
 548 #  else
 549     start = 0x08000000ul;
 550 #  endif
 551 # endif
 552
 553     buf = mmap((void *)start, tcg_ctx.code_gen_buffer_size,
 554                PROT_WRITE | PROT_READ | PROT_EXEC, flags, -1, 0);
 555     if (buf == MAP_FAILED) {
 556         return NULL;
 557     }
 558
 559 #ifdef __mips__
 560     if (cross_256mb(buf, tcg_ctx.code_gen_buffer_size)) {
 561         /* Try again, with the original still mapped, to avoid re-acquiring
 562            that 256mb crossing.  This time don't specify an address.  */
 563         size_t size2, size1 = tcg_ctx.code_gen_buffer_size;
 564         void *buf2 = mmap(NULL, size1, PROT_WRITE | PROT_READ | PROT_EXEC,
 565                           flags, -1, 0);
 566         if (buf2 != MAP_FAILED) {
 567             if (!cross_256mb(buf2, size1)) {
 568                 /* Success!  Use the new buffer.  */
 569                 munmap(buf, size1);
 570                 return buf2;
 571             }
 572             /* Failure.  Work with what we had.  */
 573             munmap(buf2, size1);
 574         }
 575
 576         /* Split the original buffer.  Free the smaller half.  */
 577         buf2 = split_cross_256mb(buf, size1);
 578         size2 = tcg_ctx.code_gen_buffer_size;
 579         munmap(buf + (buf == buf2 ? size2 : 0), size1 - size2);
 580         return buf2;
 581     }
 582 #endif
 583
 584     return buf;
 585 }
 586 #else
 587 static inline void *alloc_code_gen_buffer(void)
 588 {
 589     void *buf = g_try_malloc(tcg_ctx.code_gen_buffer_size);
 590
 591     if (buf == NULL) {
 592         return NULL;
 593     }
 594
 595 #ifdef __mips__
 596     if (cross_256mb(buf, tcg_ctx.code_gen_buffer_size)) {
 597         void *buf2 = g_malloc(tcg_ctx.code_gen_buffer_size);
 598         if (buf2 != NULL && !cross_256mb(buf2, size1)) {
 599             /* Success!  Use the new buffer.  */
 600             free(buf);
 601             buf = buf2;
 602         } else {
 603             /* Failure.  Work with what we had.  Since this is malloc
 604                and not mmap, we can't free the other half.  */
 605             free(buf2);
 606             buf = split_cross_256mb(buf, tcg_ctx.code_gen_buffer_size);
 607         }
 608     }
 609 #endif
 610
 611     map_exec(buf, tcg_ctx.code_gen_buffer_size);
 612     return buf;
 613 }
 614 #endif /* USE_STATIC_CODE_GEN_BUFFER, USE_MMAP */
 615
 616 static inline void code_gen_alloc(size_t tb_size)
 617 {
 618     tcg_ctx.code_gen_buffer_size = size_code_gen_buffer(tb_size);
 619     tcg_ctx.code_gen_buffer = alloc_code_gen_buffer();
 620     if (tcg_ctx.code_gen_buffer == NULL) {
 621         fprintf(stderr, "Could not allocate dynamic translator buffer\n");
 622         exit(1);
 623     }
 624
 625     qemu_madvise(tcg_ctx.code_gen_buffer, tcg_ctx.code_gen_buffer_size,
 626             QEMU_MADV_HUGEPAGE);
 627
 628     /* Steal room for the prologue at the end of the buffer.  This ensures
 629        (via the MAX_CODE_GEN_BUFFER_SIZE limits above) that direct branches
 630        from TB's to the prologue are going to be in range.  It also means
 631        that we don't need to mark (additional) portions of the data segment
 632        as executable.  */
 633     tcg_ctx.code_gen_prologue = tcg_ctx.code_gen_buffer +
 634             tcg_ctx.code_gen_buffer_size - 1024;
 635     tcg_ctx.code_gen_buffer_size -= 1024;
 636
 637     tcg_ctx.code_gen_buffer_max_size = tcg_ctx.code_gen_buffer_size -
 638         (TCG_MAX_OP_SIZE * OPC_BUF_SIZE);
 639     tcg_ctx.code_gen_max_blocks = tcg_ctx.code_gen_buffer_size /
 640             CODE_GEN_AVG_BLOCK_SIZE;
 641     tcg_ctx.tb_ctx.tbs =
 642             g_malloc(tcg_ctx.code_gen_max_blocks * sizeof(TranslationBlock));
 643     qemu_mutex_init(&tcg_ctx.tb_ctx.tb_lock);
 644 }
 645
 646 /* Must be called before using the QEMU cpus. 'tb_size' is the size
 647    (in bytes) allocated to the translation buffer. Zero means default
 648    size. */
 649 void tcg_exec_init(unsigned long tb_size)
 650 {
 651     cpu_gen_init();
 652     code_gen_alloc(tb_size);
 653     tcg_ctx.code_gen_ptr = tcg_ctx.code_gen_buffer;
 654     tcg_register_jit(tcg_ctx.code_gen_buffer, tcg_ctx.code_gen_buffer_size);
 655     page_init();
 656 #if defined(CONFIG_SOFTMMU)
 657     /* There's no guest base to take into account, so go ahead and
 658        initialize the prologue now.  */
 659     tcg_prologue_init(&tcg_ctx);
 660 #endif
 661 }
 662
 663 bool tcg_enabled(void)
 664 {
 665     return tcg_ctx.code_gen_buffer != NULL;
 666 }
 667
 668 /* Allocate a new translation block. Flush the translation buffer if
 669    too many translation blocks or too much generated code. */
 670 static TranslationBlock *tb_alloc(target_ulong pc)
 671 {
 672     TranslationBlock *tb;
 673
 674     if (tcg_ctx.tb_ctx.nb_tbs >= tcg_ctx.code_gen_max_blocks ||
 675         (tcg_ctx.code_gen_ptr - tcg_ctx.code_gen_buffer) >=
 676          tcg_ctx.code_gen_buffer_max_size) {
 677         return NULL;
 678     }
 679     tb = &tcg_ctx.tb_ctx.tbs[tcg_ctx.tb_ctx.nb_tbs++];
 680     tb->pc = pc;
 681     tb->cflags = 0;
 682     return tb;
 683 }
 684
 685 void tb_free(TranslationBlock *tb)
 686 {
 687     /* In practice this is mostly used for single use temporary TB
 688        Ignore the hard cases and just back up if this TB happens to
 689        be the last one generated.  */
 690     if (tcg_ctx.tb_ctx.nb_tbs > 0 &&
 691             tb == &tcg_ctx.tb_ctx.tbs[tcg_ctx.tb_ctx.nb_tbs - 1]) {
 692         tcg_ctx.code_gen_ptr = tb->tc_ptr;
 693         tcg_ctx.tb_ctx.nb_tbs--;
 694     }
 695 }
 696
 697 static inline void invalidate_page_bitmap(PageDesc *p)
 698 {
 699     g_free(p->code_bitmap);
 700     p->code_bitmap = NULL;
 701     p->code_write_count = 0;
 702 }
 703
 704 /* Set to NULL all the 'first_tb' fields in all PageDescs. */
 705 static void page_flush_tb_1(int level, void **lp)
 706 {
 707     int i;
 708
 709     if (*lp == NULL) {
 710         return;
 711     }
 712     if (level == 0) {
 713         PageDesc *pd = *lp;
 714
 715         for (i = 0; i < V_L2_SIZE; ++i) {
 716             pd[i].first_tb = NULL;
 717             invalidate_page_bitmap(pd + i);
 718         }
 719     } else {
 720         void **pp = *lp;
 721
 722         for (i = 0; i < V_L2_SIZE; ++i) {
 723             page_flush_tb_1(level - 1, pp + i);
 724         }
 725     }
 726 }
 727
 728 static void page_flush_tb(void)
 729 {
 730     int i;
 731
 732     for (i = 0; i < V_L1_SIZE; i++) {
 733         page_flush_tb_1(V_L1_SHIFT / V_L2_BITS - 1, l1_map + i);
 734     }
 735 }
 736
 737 /* flush all the translation blocks */
 738 /* XXX: tb_flush is currently not thread safe */
 739 void tb_flush(CPUState *cpu)
 740 {
 741 #if defined(DEBUG_FLUSH)
 742     printf("qemu: flush code_size=%ld nb_tbs=%d avg_tb_size=%ld\n",
 743            (unsigned long)(tcg_ctx.code_gen_ptr - tcg_ctx.code_gen_buffer),
 744            tcg_ctx.tb_ctx.nb_tbs, tcg_ctx.tb_ctx.nb_tbs > 0 ?
 745            ((unsigned long)(tcg_ctx.code_gen_ptr - tcg_ctx.code_gen_buffer)) /
 746            tcg_ctx.tb_ctx.nb_tbs : 0);
 747 #endif
 748     if ((unsigned long)(tcg_ctx.code_gen_ptr - tcg_ctx.code_gen_buffer)
 749         > tcg_ctx.code_gen_buffer_size) {
 750         cpu_abort(cpu, "Internal error: code buffer overflow\n");
 751     }
 752     tcg_ctx.tb_ctx.nb_tbs = 0;
 753
 754     CPU_FOREACH(cpu) {
 755         memset(cpu->tb_jmp_cache, 0, sizeof(cpu->tb_jmp_cache));
 756     }
 757
 758     memset(tcg_ctx.tb_ctx.tb_phys_hash, 0, sizeof(tcg_ctx.tb_ctx.tb_phys_hash));
 759     page_flush_tb();
 760
 761     tcg_ctx.code_gen_ptr = tcg_ctx.code_gen_buffer;
 762     /* XXX: flush processor icache at this point if cache flush is
 763        expensive */
 764     tcg_ctx.tb_ctx.tb_flush_count++;
 765 }
 766
 767 #ifdef DEBUG_TB_CHECK
 768
 769 static void tb_invalidate_check(target_ulong address)
 770 {
 771     TranslationBlock *tb;
 772     int i;
 773
 774     address &= TARGET_PAGE_MASK;
 775     for (i = 0; i < CODE_GEN_PHYS_HASH_SIZE; i++) {
 776         for (tb = tb_ctx.tb_phys_hash[i]; tb != NULL; tb = tb->phys_hash_next) {
 777             if (!(address + TARGET_PAGE_SIZE <= tb->pc ||
 778                   address >= tb->pc + tb->size)) {
 779                 printf("ERROR invalidate: address=" TARGET_FMT_lx
 780                        " PC=%08lx size=%04x\n",
 781                        address, (long)tb->pc, tb->size);
 782             }
 783         }
 784     }
 785 }
 786
 787 /* verify that all the pages have correct rights for code */
 788 static void tb_page_check(void)
 789 {
 790     TranslationBlock *tb;
 791     int i, flags1, flags2;
 792
 793     for (i = 0; i < CODE_GEN_PHYS_HASH_SIZE; i++) {
 794         for (tb = tcg_ctx.tb_ctx.tb_phys_hash[i]; tb != NULL;
 795                 tb = tb->phys_hash_next) {
 796             flags1 = page_get_flags(tb->pc);
 797             flags2 = page_get_flags(tb->pc + tb->size - 1);
 798             if ((flags1 & PAGE_WRITE) || (flags2 & PAGE_WRITE)) {
 799                 printf("ERROR page flags: PC=%08lx size=%04x f1=%x f2=%x\n",
 800                        (long)tb->pc, tb->size, flags1, flags2);
 801             }
 802         }
 803     }
 804 }
 805
 806 #endif
 807
 808 static inline void tb_hash_remove(TranslationBlock **ptb, TranslationBlock *tb)
 809 {
 810     TranslationBlock *tb1;
 811
 812     for (;;) {
 813         tb1 = *ptb;
 814         if (tb1 == tb) {
 815             *ptb = tb1->phys_hash_next;
 816             break;
 817         }
 818         ptb = &tb1->phys_hash_next;
 819     }
 820 }
 821
 822 static inline void tb_page_remove(TranslationBlock **ptb, TranslationBlock *tb)
 823 {
 824     TranslationBlock *tb1;
 825     unsigned int n1;
 826
 827     for (;;) {
 828         tb1 = *ptb;
 829         n1 = (uintptr_t)tb1 & 3;
 830         tb1 = (TranslationBlock *)((uintptr_t)tb1 & ~3);
 831         if (tb1 == tb) {
 832             *ptb = tb1->page_next[n1];
 833             break;
 834         }
 835         ptb = &tb1->page_next[n1];
 836     }
 837 }
 838
 839 static inline void tb_jmp_remove(TranslationBlock *tb, int n)
 840 {
 841     TranslationBlock *tb1, **ptb;
 842     unsigned int n1;
 843
 844     ptb = &tb->jmp_next[n];
 845     tb1 = *ptb;
 846     if (tb1) {
 847         /* find tb(n) in circular list */
 848         for (;;) {
 849             tb1 = *ptb;
 850             n1 = (uintptr_t)tb1 & 3;
 851             tb1 = (TranslationBlock *)((uintptr_t)tb1 & ~3);
 852             if (n1 == n && tb1 == tb) {
 853                 break;
 854             }
 855             if (n1 == 2) {
 856                 ptb = &tb1->jmp_first;
 857             } else {
 858                 ptb = &tb1->jmp_next[n1];
 859             }
 860         }
 861         /* now we can suppress tb(n) from the list */
 862         *ptb = tb->jmp_next[n];
 863
 864         tb->jmp_next[n] = NULL;
 865     }
 866 }
 867
 868 /* reset the jump entry 'n' of a TB so that it is not chained to
 869    another TB */
 870 static inline void tb_reset_jump(TranslationBlock *tb, int n)
 871 {
 872     tb_set_jmp_target(tb, n, (uintptr_t)(tb->tc_ptr + tb->tb_next_offset[n]));
 873 }
 874
 875 /* invalidate one TB */
 876 void tb_phys_invalidate(TranslationBlock *tb, tb_page_addr_t page_addr)
 877 {
 878     CPUState *cpu;
 879     PageDesc *p;
 880     unsigned int h, n1;
 881     tb_page_addr_t phys_pc;
 882     TranslationBlock *tb1, *tb2;
 883
 884     /* remove the TB from the hash list */
 885     phys_pc = tb->page_addr[0] + (tb->pc & ~TARGET_PAGE_MASK);
 886     h = tb_phys_hash_func(phys_pc);
 887     tb_hash_remove(&tcg_ctx.tb_ctx.tb_phys_hash[h], tb);
 888
 889     /* remove the TB from the page list */
 890     if (tb->page_addr[0] != page_addr) {
 891         p = page_find(tb->page_addr[0] >> TARGET_PAGE_BITS);
 892         tb_page_remove(&p->first_tb, tb);
 893         invalidate_page_bitmap(p);
 894     }
 895     if (tb->page_addr[1] != -1 && tb->page_addr[1] != page_addr) {
 896         p = page_find(tb->page_addr[1] >> TARGET_PAGE_BITS);
 897         tb_page_remove(&p->first_tb, tb);
 898         invalidate_page_bitmap(p);
 899     }
 900
 901     tcg_ctx.tb_ctx.tb_invalidated_flag = 1;
 902
 903     /* remove the TB from the hash list */
 904     h = tb_jmp_cache_hash_func(tb->pc);
 905     CPU_FOREACH(cpu) {
 906         if (cpu->tb_jmp_cache[h] == tb) {
 907             cpu->tb_jmp_cache[h] = NULL;
 908         }
 909     }
 910
 911     /* suppress this TB from the two jump lists */
 912     tb_jmp_remove(tb, 0);
 913     tb_jmp_remove(tb, 1);
 914
 915     /* suppress any remaining jumps to this TB */
 916     tb1 = tb->jmp_first;
 917     for (;;) {
 918         n1 = (uintptr_t)tb1 & 3;
 919         if (n1 == 2) {
 920             break;
 921         }
 922         tb1 = (TranslationBlock *)((uintptr_t)tb1 & ~3);
 923         tb2 = tb1->jmp_next[n1];
 924         tb_reset_jump(tb1, n1);
 925         tb1->jmp_next[n1] = NULL;
 926         tb1 = tb2;
 927     }
 928     tb->jmp_first = (TranslationBlock *)((uintptr_t)tb | 2); /* fail safe */
 929
 930     tcg_ctx.tb_ctx.tb_phys_invalidate_count++;
 931 }
 932
 933 static void build_page_bitmap(PageDesc *p)
 934 {
 935     int n, tb_start, tb_end;
 936     TranslationBlock *tb;
 937
 938     p->code_bitmap = bitmap_new(TARGET_PAGE_SIZE);
 939
 940     tb = p->first_tb;
 941     while (tb != NULL) {
 942         n = (uintptr_t)tb & 3;
 943         tb = (TranslationBlock *)((uintptr_t)tb & ~3);
 944         /* NOTE: this is subtle as a TB may span two physical pages */
 945         if (n == 0) {
 946             /* NOTE: tb_end may be after the end of the page, but
 947                it is not a problem */
 948             tb_start = tb->pc & ~TARGET_PAGE_MASK;
 949             tb_end = tb_start + tb->size;
 950             if (tb_end > TARGET_PAGE_SIZE) {
 951                 tb_end = TARGET_PAGE_SIZE;
 952             }
 953         } else {
 954             tb_start = 0;
 955             tb_end = ((tb->pc + tb->size) & ~TARGET_PAGE_MASK);
 956         }
 957         bitmap_set(p->code_bitmap, tb_start, tb_end - tb_start);
 958         tb = tb->page_next[n];
 959     }
 960 }
 961
 962 /* Called with mmap_lock held for user mode emulation.  */
 963 TranslationBlock *tb_gen_code(CPUState *cpu,
 964                               target_ulong pc, target_ulong cs_base,
 965                               int flags, int cflags)
 966 {
 967     CPUArchState *env = cpu->env_ptr;
 968     TranslationBlock *tb;
 969     tb_page_addr_t phys_pc, phys_page2;
 970     target_ulong virt_page2;
 971     tcg_insn_unit *gen_code_buf;
 972     int gen_code_size;
 973 #ifdef CONFIG_PROFILER
 974     int64_t ti;
 975 #endif
 976
 977     phys_pc = get_page_addr_code(env, pc);
 978     if (use_icount) {
 979         cflags |= CF_USE_ICOUNT;
 980     }
 981     tb = tb_alloc(pc);
 982     if (!tb) {
 983         /* flush must be done */
 984         tb_flush(cpu);
 985         /* cannot fail at this point */
 986         tb = tb_alloc(pc);
 987         /* Don't forget to invalidate previous TB info.  */
 988         tcg_ctx.tb_ctx.tb_invalidated_flag = 1;
 989     }
 990
 991     gen_code_buf = tcg_ctx.code_gen_ptr;
 992     tb->tc_ptr = gen_code_buf;
 993     tb->cs_base = cs_base;
 994     tb->flags = flags;
 995     tb->cflags = cflags;
 996
 997 #ifdef CONFIG_PROFILER
 998     tcg_ctx.tb_count1++; /* includes aborted translations because of
 999                        exceptions */
1000     ti = profile_getclock();
1001 #endif
1002
1003     tcg_func_start(&tcg_ctx);
1004
1005     gen_intermediate_code(env, tb);
1006
1007     trace_translate_block(tb, tb->pc, tb->tc_ptr);
1008
1009     /* generate machine code */
1010     tb->tb_next_offset[0] = 0xffff;
1011     tb->tb_next_offset[1] = 0xffff;
1012     tcg_ctx.tb_next_offset = tb->tb_next_offset;
1013 #ifdef USE_DIRECT_JUMP
1014     tcg_ctx.tb_jmp_offset = tb->tb_jmp_offset;
1015     tcg_ctx.tb_next = NULL;
1016 #else
1017     tcg_ctx.tb_jmp_offset = NULL;
1018     tcg_ctx.tb_next = tb->tb_next;
1019 #endif
1020
1021 #ifdef CONFIG_PROFILER
1022     tcg_ctx.tb_count++;
1023     tcg_ctx.interm_time += profile_getclock() - ti;
1024     tcg_ctx.code_time -= profile_getclock();
1025 #endif
1026
1027     gen_code_size = tcg_gen_code(&tcg_ctx, gen_code_buf);
1028
1029 #ifdef CONFIG_PROFILER
1030     tcg_ctx.code_time += profile_getclock();
1031     tcg_ctx.code_in_len += tb->size;
1032     tcg_ctx.code_out_len += gen_code_size;
1033 #endif
1034
1035 #ifdef DEBUG_DISAS
1036     if (qemu_loglevel_mask(CPU_LOG_TB_OUT_ASM)) {
1037         qemu_log("OUT: [size=%d]\n", gen_code_size);
1038         log_disas(tb->tc_ptr, gen_code_size);
1039         qemu_log("\n");
1040         qemu_log_flush();
1041     }
1042 #endif
1043
1044     tcg_ctx.code_gen_ptr = (void *)(((uintptr_t)gen_code_buf +
1045             gen_code_size + CODE_GEN_ALIGN - 1) & ~(CODE_GEN_ALIGN - 1));
1046
1047     /* check next page if needed */
1048     virt_page2 = (pc + tb->size - 1) & TARGET_PAGE_MASK;
1049     phys_page2 = -1;
1050     if ((pc & TARGET_PAGE_MASK) != virt_page2) {
1051         phys_page2 = get_page_addr_code(env, virt_page2);
1052     }
1053     tb_link_page(tb, phys_pc, phys_page2);
1054     return tb;
1055 }
1056
1057 /*
1058  * Invalidate all TBs which intersect with the target physical address range
1059  * [start;end[. NOTE: start and end may refer to *different* physical pages.
1060  * 'is_cpu_write_access' should be true if called from a real cpu write
1061  * access: the virtual CPU will exit the current TB if code is modified inside
1062  * this TB.
1063  *
1064  * Called with mmap_lock held for user-mode emulation
1065  */
1066 void tb_invalidate_phys_range(tb_page_addr_t start, tb_page_addr_t end)
1067 {
1068     while (start < end) {
1069         tb_invalidate_phys_page_range(start, end, 0);
1070         start &= TARGET_PAGE_MASK;
1071         start += TARGET_PAGE_SIZE;
1072     }
1073 }
1074
1075 /*
1076  * Invalidate all TBs which intersect with the target physical address range
1077  * [start;end[. NOTE: start and end must refer to the *same* physical page.
1078  * 'is_cpu_write_access' should be true if called from a real cpu write
1079  * access: the virtual CPU will exit the current TB if code is modified inside
1080  * this TB.
1081  *
1082  * Called with mmap_lock held for user-mode emulation
1083  */
1084 void tb_invalidate_phys_page_range(tb_page_addr_t start, tb_page_addr_t end,
1085                                    int is_cpu_write_access)
1086 {
1087     TranslationBlock *tb, *tb_next, *saved_tb;
1088     CPUState *cpu = current_cpu;
1089 #if defined(TARGET_HAS_PRECISE_SMC)
1090     CPUArchState *env = NULL;
1091 #endif
1092     tb_page_addr_t tb_start, tb_end;
1093     PageDesc *p;
1094     int n;
1095 #ifdef TARGET_HAS_PRECISE_SMC
1096     int current_tb_not_found = is_cpu_write_access;
1097     TranslationBlock *current_tb = NULL;
1098     int current_tb_modified = 0;
1099     target_ulong current_pc = 0;
1100     target_ulong current_cs_base = 0;
1101     int current_flags = 0;
1102 #endif /* TARGET_HAS_PRECISE_SMC */
1103
1104     p = page_find(start >> TARGET_PAGE_BITS);
1105     if (!p) {
1106         return;
1107     }
1108 #if defined(TARGET_HAS_PRECISE_SMC)
1109     if (cpu != NULL) {
1110         env = cpu->env_ptr;
1111     }
1112 #endif
1113
1114     /* we remove all the TBs in the range [start, end[ */
1115     /* XXX: see if in some cases it could be faster to invalidate all
1116        the code */
1117     tb = p->first_tb;
1118     while (tb != NULL) {
1119         n = (uintptr_t)tb & 3;
1120         tb = (TranslationBlock *)((uintptr_t)tb & ~3);
1121         tb_next = tb->page_next[n];
1122         /* NOTE: this is subtle as a TB may span two physical pages */
1123         if (n == 0) {
1124             /* NOTE: tb_end may be after the end of the page, but
1125                it is not a problem */
1126             tb_start = tb->page_addr[0] + (tb->pc & ~TARGET_PAGE_MASK);
1127             tb_end = tb_start + tb->size;
1128         } else {
1129             tb_start = tb->page_addr[1];
1130             tb_end = tb_start + ((tb->pc + tb->size) & ~TARGET_PAGE_MASK);
1131         }
1132         if (!(tb_end <= start || tb_start >= end)) {
1133 #ifdef TARGET_HAS_PRECISE_SMC
1134             if (current_tb_not_found) {
1135                 current_tb_not_found = 0;
1136                 current_tb = NULL;
1137                 if (cpu->mem_io_pc) {
1138                     /* now we have a real cpu fault */
1139                     current_tb = tb_find_pc(cpu->mem_io_pc);
1140                 }
1141             }
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_from_tb(cpu, current_tb, cpu->mem_io_pc);
1152                 cpu_get_tb_cpu_state(env, &current_pc, &current_cs_base,
1153                                      &current_flags);
1154             }
1155 #endif /* TARGET_HAS_PRECISE_SMC */
1156             /* we need to do that to handle the case where a signal
1157                occurs while doing tb_phys_invalidate() */
1158             saved_tb = NULL;
1159             if (cpu != NULL) {
1160                 saved_tb = cpu->current_tb;
1161                 cpu->current_tb = NULL;
1162             }
1163             tb_phys_invalidate(tb, -1);
1164             if (cpu != NULL) {
1165                 cpu->current_tb = saved_tb;
1166                 if (cpu->interrupt_request && cpu->current_tb) {
1167                     cpu_interrupt(cpu, cpu->interrupt_request);
1168                 }
1169             }
1170         }
1171         tb = tb_next;
1172     }
1173 #if !defined(CONFIG_USER_ONLY)
1174     /* if no code remaining, no need to continue to use slow writes */
1175     if (!p->first_tb) {
1176         invalidate_page_bitmap(p);
1177         tlb_unprotect_code(start);
1178     }
1179 #endif
1180 #ifdef TARGET_HAS_PRECISE_SMC
1181     if (current_tb_modified) {
1182         /* we generate a block containing just the instruction
1183            modifying the memory. It will ensure that it cannot modify
1184            itself */
1185         cpu->current_tb = NULL;
1186         tb_gen_code(cpu, current_pc, current_cs_base, current_flags, 1);
1187         cpu_resume_from_signal(cpu, NULL);
1188     }
1189 #endif
1190 }
1191
1192 /* len must be <= 8 and start must be a multiple of len */
1193 void tb_invalidate_phys_page_fast(tb_page_addr_t start, int len)
1194 {
1195     PageDesc *p;
1196
1197 #if 0
1198     if (1) {
1199         qemu_log("modifying code at 0x%x size=%d EIP=%x PC=%08x\n",
1200                   cpu_single_env->mem_io_vaddr, len,
1201                   cpu_single_env->eip,
1202                   cpu_single_env->eip +
1203                   (intptr_t)cpu_single_env->segs[R_CS].base);
1204     }
1205 #endif
1206     p = page_find(start >> TARGET_PAGE_BITS);
1207     if (!p) {
1208         return;
1209     }
1210     if (!p->code_bitmap &&
1211         ++p->code_write_count >= SMC_BITMAP_USE_THRESHOLD) {
1212         /* build code bitmap */
1213         build_page_bitmap(p);
1214     }
1215     if (p->code_bitmap) {
1216         unsigned int nr;
1217         unsigned long b;
1218
1219         nr = start & ~TARGET_PAGE_MASK;
1220         b = p->code_bitmap[BIT_WORD(nr)] >> (nr & (BITS_PER_LONG - 1));
1221         if (b & ((1 << len) - 1)) {
1222             goto do_invalidate;
1223         }
1224     } else {
1225     do_invalidate:
1226         tb_invalidate_phys_page_range(start, start + len, 1);
1227     }
1228 }
1229
1230 #if !defined(CONFIG_SOFTMMU)
1231 /* Called with mmap_lock held.  */
1232 static void tb_invalidate_phys_page(tb_page_addr_t addr,
1233                                     uintptr_t pc, void *puc,
1234                                     bool locked)
1235 {
1236     TranslationBlock *tb;
1237     PageDesc *p;
1238     int n;
1239 #ifdef TARGET_HAS_PRECISE_SMC
1240     TranslationBlock *current_tb = NULL;
1241     CPUState *cpu = current_cpu;
1242     CPUArchState *env = NULL;
1243     int current_tb_modified = 0;
1244     target_ulong current_pc = 0;
1245     target_ulong current_cs_base = 0;
1246     int current_flags = 0;
1247 #endif
1248
1249     addr &= TARGET_PAGE_MASK;
1250     p = page_find(addr >> TARGET_PAGE_BITS);
1251     if (!p) {
1252         return;
1253     }
1254     tb = p->first_tb;
1255 #ifdef TARGET_HAS_PRECISE_SMC
1256     if (tb && pc != 0) {
1257         current_tb = tb_find_pc(pc);
1258     }
1259     if (cpu != NULL) {
1260         env = cpu->env_ptr;
1261     }
1262 #endif
1263     while (tb != NULL) {
1264         n = (uintptr_t)tb & 3;
1265         tb = (TranslationBlock *)((uintptr_t)tb & ~3);
1266 #ifdef TARGET_HAS_PRECISE_SMC
1267         if (current_tb == tb &&
1268             (current_tb->cflags & CF_COUNT_MASK) != 1) {
1269                 /* If we are modifying the current TB, we must stop
1270                    its execution. We could be more precise by checking
1271                    that the modification is after the current PC, but it
1272                    would require a specialized function to partially
1273                    restore the CPU state */
1274
1275             current_tb_modified = 1;
1276             cpu_restore_state_from_tb(cpu, current_tb, pc);
1277             cpu_get_tb_cpu_state(env, &current_pc, &current_cs_base,
1278                                  &current_flags);
1279         }
1280 #endif /* TARGET_HAS_PRECISE_SMC */
1281         tb_phys_invalidate(tb, addr);
1282         tb = tb->page_next[n];
1283     }
1284     p->first_tb = NULL;
1285 #ifdef TARGET_HAS_PRECISE_SMC
1286     if (current_tb_modified) {
1287         /* we generate a block containing just the instruction
1288            modifying the memory. It will ensure that it cannot modify
1289            itself */
1290         cpu->current_tb = NULL;
1291         tb_gen_code(cpu, current_pc, current_cs_base, current_flags, 1);
1292         if (locked) {
1293             mmap_unlock();
1294         }
1295         cpu_resume_from_signal(cpu, puc);
1296     }
1297 #endif
1298 }
1299 #endif
1300
1301 /* add the tb in the target page and protect it if necessary
1302  *
1303  * Called with mmap_lock held for user-mode emulation.
1304  */
1305 static inline void tb_alloc_page(TranslationBlock *tb,
1306                                  unsigned int n, tb_page_addr_t page_addr)
1307 {
1308     PageDesc *p;
1309 #ifndef CONFIG_USER_ONLY
1310     bool page_already_protected;
1311 #endif
1312
1313     tb->page_addr[n] = page_addr;
1314     p = page_find_alloc(page_addr >> TARGET_PAGE_BITS, 1);
1315     tb->page_next[n] = p->first_tb;
1316 #ifndef CONFIG_USER_ONLY
1317     page_already_protected = p->first_tb != NULL;
1318 #endif
1319     p->first_tb = (TranslationBlock *)((uintptr_t)tb | n);
1320     invalidate_page_bitmap(p);
1321
1322 #if defined(CONFIG_USER_ONLY)
1323     if (p->flags & PAGE_WRITE) {
1324         target_ulong addr;
1325         PageDesc *p2;
1326         int prot;
1327
1328         /* force the host page as non writable (writes will have a
1329            page fault + mprotect overhead) */
1330         page_addr &= qemu_host_page_mask;
1331         prot = 0;
1332         for (addr = page_addr; addr < page_addr + qemu_host_page_size;
1333             addr += TARGET_PAGE_SIZE) {
1334
1335             p2 = page_find(addr >> TARGET_PAGE_BITS);
1336             if (!p2) {
1337                 continue;
1338             }
1339             prot |= p2->flags;
1340             p2->flags &= ~PAGE_WRITE;
1341           }
1342         mprotect(g2h(page_addr), qemu_host_page_size,
1343                  (prot & PAGE_BITS) & ~PAGE_WRITE);
1344 #ifdef DEBUG_TB_INVALIDATE
1345         printf("protecting code page: 0x" TARGET_FMT_lx "\n",
1346                page_addr);
1347 #endif
1348     }
1349 #else
1350     /* if some code is already present, then the pages are already
1351        protected. So we handle the case where only the first TB is
1352        allocated in a physical page */
1353     if (!page_already_protected) {
1354         tlb_protect_code(page_addr);
1355     }
1356 #endif
1357 }
1358
1359 /* add a new TB and link it to the physical page tables. phys_page2 is
1360  * (-1) to indicate that only one page contains the TB.
1361  *
1362  * Called with mmap_lock held for user-mode emulation.
1363  */
1364 static void tb_link_page(TranslationBlock *tb, tb_page_addr_t phys_pc,
1365                          tb_page_addr_t phys_page2)
1366 {
1367     unsigned int h;
1368     TranslationBlock **ptb;
1369
1370     /* add in the physical hash table */
1371     h = tb_phys_hash_func(phys_pc);
1372     ptb = &tcg_ctx.tb_ctx.tb_phys_hash[h];
1373     tb->phys_hash_next = *ptb;
1374     *ptb = tb;
1375
1376     /* add in the page list */
1377     tb_alloc_page(tb, 0, phys_pc & TARGET_PAGE_MASK);
1378     if (phys_page2 != -1) {
1379         tb_alloc_page(tb, 1, phys_page2);
1380     } else {
1381         tb->page_addr[1] = -1;
1382     }
1383
1384     tb->jmp_first = (TranslationBlock *)((uintptr_t)tb | 2);
1385     tb->jmp_next[0] = NULL;
1386     tb->jmp_next[1] = NULL;
1387
1388     /* init original jump addresses */
1389     if (tb->tb_next_offset[0] != 0xffff) {
1390         tb_reset_jump(tb, 0);
1391     }
1392     if (tb->tb_next_offset[1] != 0xffff) {
1393         tb_reset_jump(tb, 1);
1394     }
1395
1396 #ifdef DEBUG_TB_CHECK
1397     tb_page_check();
1398 #endif
1399 }
1400
1401 /* find the TB 'tb' such that tb[0].tc_ptr <= tc_ptr <
1402    tb[1].tc_ptr. Return NULL if not found */
1403 static TranslationBlock *tb_find_pc(uintptr_t tc_ptr)
1404 {
1405     int m_min, m_max, m;
1406     uintptr_t v;
1407     TranslationBlock *tb;
1408
1409     if (tcg_ctx.tb_ctx.nb_tbs <= 0) {
1410         return NULL;
1411     }
1412     if (tc_ptr < (uintptr_t)tcg_ctx.code_gen_buffer ||
1413         tc_ptr >= (uintptr_t)tcg_ctx.code_gen_ptr) {
1414         return NULL;
1415     }
1416     /* binary search (cf Knuth) */
1417     m_min = 0;
1418     m_max = tcg_ctx.tb_ctx.nb_tbs - 1;
1419     while (m_min <= m_max) {
1420         m = (m_min + m_max) >> 1;
1421         tb = &tcg_ctx.tb_ctx.tbs[m];
1422         v = (uintptr_t)tb->tc_ptr;
1423         if (v == tc_ptr) {
1424             return tb;
1425         } else if (tc_ptr < v) {
1426             m_max = m - 1;
1427         } else {
1428             m_min = m + 1;
1429         }
1430     }
1431     return &tcg_ctx.tb_ctx.tbs[m_max];
1432 }
1433
1434 #if !defined(CONFIG_USER_ONLY)
1435 void tb_invalidate_phys_addr(AddressSpace *as, hwaddr addr)
1436 {
1437     ram_addr_t ram_addr;
1438     MemoryRegion *mr;
1439     hwaddr l = 1;
1440
1441     rcu_read_lock();
1442     mr = address_space_translate(as, addr, &addr, &l, false);
1443     if (!(memory_region_is_ram(mr)
1444           || memory_region_is_romd(mr))) {
1445         rcu_read_unlock();
1446         return;
1447     }
1448     ram_addr = (memory_region_get_ram_addr(mr) & TARGET_PAGE_MASK)
1449         + addr;
1450     tb_invalidate_phys_page_range(ram_addr, ram_addr + 1, 0);
1451     rcu_read_unlock();
1452 }
1453 #endif /* !defined(CONFIG_USER_ONLY) */
1454
1455 void tb_check_watchpoint(CPUState *cpu)
1456 {
1457     TranslationBlock *tb;
1458
1459     tb = tb_find_pc(cpu->mem_io_pc);
1460     if (tb) {
1461         /* We can use retranslation to find the PC.  */
1462         cpu_restore_state_from_tb(cpu, tb, cpu->mem_io_pc);
1463         tb_phys_invalidate(tb, -1);
1464     } else {
1465         /* The exception probably happened in a helper.  The CPU state should
1466            have been saved before calling it. Fetch the PC from there.  */
1467         CPUArchState *env = cpu->env_ptr;
1468         target_ulong pc, cs_base;
1469         tb_page_addr_t addr;
1470         int flags;
1471
1472         cpu_get_tb_cpu_state(env, &pc, &cs_base, &flags);
1473         addr = get_page_addr_code(env, pc);
1474         tb_invalidate_phys_range(addr, addr + 1);
1475     }
1476 }
1477
1478 #ifndef CONFIG_USER_ONLY
1479 /* in deterministic execution mode, instructions doing device I/Os
1480    must be at the end of the TB */
1481 void cpu_io_recompile(CPUState *cpu, uintptr_t retaddr)
1482 {
1483 #if defined(TARGET_MIPS) || defined(TARGET_SH4)
1484     CPUArchState *env = cpu->env_ptr;
1485 #endif
1486     TranslationBlock *tb;
1487     uint32_t n, cflags;
1488     target_ulong pc, cs_base;
1489     uint64_t flags;
1490
1491     tb = tb_find_pc(retaddr);
1492     if (!tb) {
1493         cpu_abort(cpu, "cpu_io_recompile: could not find TB for pc=%p",
1494                   (void *)retaddr);
1495     }
1496     n = cpu->icount_decr.u16.low + tb->icount;
1497     cpu_restore_state_from_tb(cpu, tb, retaddr);
1498     /* Calculate how many instructions had been executed before the fault
1499        occurred.  */
1500     n = n - cpu->icount_decr.u16.low;
1501     /* Generate a new TB ending on the I/O insn.  */
1502     n++;
1503     /* On MIPS and SH, delay slot instructions can only be restarted if
1504        they were already the first instruction in the TB.  If this is not
1505        the first instruction in a TB then re-execute the preceding
1506        branch.  */
1507 #if defined(TARGET_MIPS)
1508     if ((env->hflags & MIPS_HFLAG_BMASK) != 0 && n > 1) {
1509         env->active_tc.PC -= (env->hflags & MIPS_HFLAG_B16 ? 2 : 4);
1510         cpu->icount_decr.u16.low++;
1511         env->hflags &= ~MIPS_HFLAG_BMASK;
1512     }
1513 #elif defined(TARGET_SH4)
1514     if ((env->flags & ((DELAY_SLOT | DELAY_SLOT_CONDITIONAL))) != 0
1515             && n > 1) {
1516         env->pc -= 2;
1517         cpu->icount_decr.u16.low++;
1518         env->flags &= ~(DELAY_SLOT | DELAY_SLOT_CONDITIONAL);
1519     }
1520 #endif
1521     /* This should never happen.  */
1522     if (n > CF_COUNT_MASK) {
1523         cpu_abort(cpu, "TB too big during recompile");
1524     }
1525
1526     cflags = n | CF_LAST_IO;
1527     pc = tb->pc;
1528     cs_base = tb->cs_base;
1529     flags = tb->flags;
1530     tb_phys_invalidate(tb, -1);
1531     if (tb->cflags & CF_NOCACHE) {
1532         if (tb->orig_tb) {
1533             /* Invalidate original TB if this TB was generated in
1534              * cpu_exec_nocache() */
1535             tb_phys_invalidate(tb->orig_tb, -1);
1536         }
1537         tb_free(tb);
1538     }
1539     /* FIXME: In theory this could raise an exception.  In practice
1540        we have already translated the block once so it's probably ok.  */
1541     tb_gen_code(cpu, pc, cs_base, flags, cflags);
1542     /* TODO: If env->pc != tb->pc (i.e. the faulting instruction was not
1543        the first in the TB) then we end up generating a whole new TB and
1544        repeating the fault, which is horribly inefficient.
1545        Better would be to execute just this insn uncached, or generate a
1546        second new TB.  */
1547     cpu_resume_from_signal(cpu, NULL);
1548 }
1549
1550 void tb_flush_jmp_cache(CPUState *cpu, target_ulong addr)
1551 {
1552     unsigned int i;
1553
1554     /* Discard jump cache entries for any tb which might potentially
1555        overlap the flushed page.  */
1556     i = tb_jmp_cache_hash_page(addr - TARGET_PAGE_SIZE);
1557     memset(&cpu->tb_jmp_cache[i], 0,
1558            TB_JMP_PAGE_SIZE * sizeof(TranslationBlock *));
1559
1560     i = tb_jmp_cache_hash_page(addr);
1561     memset(&cpu->tb_jmp_cache[i], 0,
1562            TB_JMP_PAGE_SIZE * sizeof(TranslationBlock *));
1563 }
1564
1565 void dump_exec_info(FILE *f, fprintf_function cpu_fprintf)
1566 {
1567     int i, target_code_size, max_target_code_size;
1568     int direct_jmp_count, direct_jmp2_count, cross_page;
1569     TranslationBlock *tb;
1570
1571     target_code_size = 0;
1572     max_target_code_size = 0;
1573     cross_page = 0;
1574     direct_jmp_count = 0;
1575     direct_jmp2_count = 0;
1576     for (i = 0; i < tcg_ctx.tb_ctx.nb_tbs; i++) {
1577         tb = &tcg_ctx.tb_ctx.tbs[i];
1578         target_code_size += tb->size;
1579         if (tb->size > max_target_code_size) {
1580             max_target_code_size = tb->size;
1581         }
1582         if (tb->page_addr[1] != -1) {
1583             cross_page++;
1584         }
1585         if (tb->tb_next_offset[0] != 0xffff) {
1586             direct_jmp_count++;
1587             if (tb->tb_next_offset[1] != 0xffff) {
1588                 direct_jmp2_count++;
1589             }
1590         }
1591     }
1592     /* XXX: avoid using doubles ? */
1593     cpu_fprintf(f, "Translation buffer state:\n");
1594     cpu_fprintf(f, "gen code size       %td/%zd\n",
1595                 tcg_ctx.code_gen_ptr - tcg_ctx.code_gen_buffer,
1596                 tcg_ctx.code_gen_buffer_max_size);
1597     cpu_fprintf(f, "TB count            %d/%d\n",
1598             tcg_ctx.tb_ctx.nb_tbs, tcg_ctx.code_gen_max_blocks);
1599     cpu_fprintf(f, "TB avg target size  %d max=%d bytes\n",
1600             tcg_ctx.tb_ctx.nb_tbs ? target_code_size /
1601                     tcg_ctx.tb_ctx.nb_tbs : 0,
1602             max_target_code_size);
1603     cpu_fprintf(f, "TB avg host size    %td bytes (expansion ratio: %0.1f)\n",
1604             tcg_ctx.tb_ctx.nb_tbs ? (tcg_ctx.code_gen_ptr -
1605                                      tcg_ctx.code_gen_buffer) /
1606                                      tcg_ctx.tb_ctx.nb_tbs : 0,
1607                 target_code_size ? (double) (tcg_ctx.code_gen_ptr -
1608                                              tcg_ctx.code_gen_buffer) /
1609                                              target_code_size : 0);
1610     cpu_fprintf(f, "cross page TB count %d (%d%%)\n", cross_page,
1611             tcg_ctx.tb_ctx.nb_tbs ? (cross_page * 100) /
1612                                     tcg_ctx.tb_ctx.nb_tbs : 0);
1613     cpu_fprintf(f, "direct jump count   %d (%d%%) (2 jumps=%d %d%%)\n",
1614                 direct_jmp_count,
1615                 tcg_ctx.tb_ctx.nb_tbs ? (direct_jmp_count * 100) /
1616                         tcg_ctx.tb_ctx.nb_tbs : 0,
1617                 direct_jmp2_count,
1618                 tcg_ctx.tb_ctx.nb_tbs ? (direct_jmp2_count * 100) /
1619                         tcg_ctx.tb_ctx.nb_tbs : 0);
1620     cpu_fprintf(f, "\nStatistics:\n");
1621     cpu_fprintf(f, "TB flush count      %d\n", tcg_ctx.tb_ctx.tb_flush_count);
1622     cpu_fprintf(f, "TB invalidate count %d\n",
1623             tcg_ctx.tb_ctx.tb_phys_invalidate_count);
1624     cpu_fprintf(f, "TLB flush count     %d\n", tlb_flush_count);
1625     tcg_dump_info(f, cpu_fprintf);
1626 }
1627
1628 void dump_opcount_info(FILE *f, fprintf_function cpu_fprintf)
1629 {
1630     tcg_dump_op_count(f, cpu_fprintf);
1631 }
1632
1633 #else /* CONFIG_USER_ONLY */
1634
1635 void cpu_interrupt(CPUState *cpu, int mask)
1636 {
1637     cpu->interrupt_request |= mask;
1638     cpu->tcg_exit_req = 1;
1639 }
1640
1641 /*
1642  * Walks guest process memory "regions" one by one
1643  * and calls callback function 'fn' for each region.
1644  */
1645 struct walk_memory_regions_data {
1646     walk_memory_regions_fn fn;
1647     void *priv;
1648     target_ulong start;
1649     int prot;
1650 };
1651
1652 static int walk_memory_regions_end(struct walk_memory_regions_data *data,
1653                                    target_ulong end, int new_prot)
1654 {
1655     if (data->start != -1u) {
1656         int rc = data->fn(data->priv, data->start, end, data->prot);
1657         if (rc != 0) {
1658             return rc;
1659         }
1660     }
1661
1662     data->start = (new_prot ? end : -1u);
1663     data->prot = new_prot;
1664
1665     return 0;
1666 }
1667
1668 static int walk_memory_regions_1(struct walk_memory_regions_data *data,
1669                                  target_ulong base, int level, void **lp)
1670 {
1671     target_ulong pa;
1672     int i, rc;
1673
1674     if (*lp == NULL) {
1675         return walk_memory_regions_end(data, base, 0);
1676     }
1677
1678     if (level == 0) {
1679         PageDesc *pd = *lp;
1680
1681         for (i = 0; i < V_L2_SIZE; ++i) {
1682             int prot = pd[i].flags;
1683
1684             pa = base | (i << TARGET_PAGE_BITS);
1685             if (prot != data->prot) {
1686                 rc = walk_memory_regions_end(data, pa, prot);
1687                 if (rc != 0) {
1688                     return rc;
1689                 }
1690             }
1691         }
1692     } else {
1693         void **pp = *lp;
1694
1695         for (i = 0; i < V_L2_SIZE; ++i) {
1696             pa = base | ((target_ulong)i <<
1697                 (TARGET_PAGE_BITS + V_L2_BITS * level));
1698             rc = walk_memory_regions_1(data, pa, level - 1, pp + i);
1699             if (rc != 0) {
1700                 return rc;
1701             }
1702         }
1703     }
1704
1705     return 0;
1706 }
1707
1708 int walk_memory_regions(void *priv, walk_memory_regions_fn fn)
1709 {
1710     struct walk_memory_regions_data data;
1711     uintptr_t i;
1712
1713     data.fn = fn;
1714     data.priv = priv;
1715     data.start = -1u;
1716     data.prot = 0;
1717
1718     for (i = 0; i < V_L1_SIZE; i++) {
1719         int rc = walk_memory_regions_1(&data, (target_ulong)i << (V_L1_SHIFT + TARGET_PAGE_BITS),
1720                                        V_L1_SHIFT / V_L2_BITS - 1, l1_map + i);
1721         if (rc != 0) {
1722             return rc;
1723         }
1724     }
1725
1726     return walk_memory_regions_end(&data, 0, 0);
1727 }
1728
1729 static int dump_region(void *priv, target_ulong start,
1730     target_ulong end, unsigned long prot)
1731 {
1732     FILE *f = (FILE *)priv;
1733
1734     (void) fprintf(f, TARGET_FMT_lx"-"TARGET_FMT_lx
1735         " "TARGET_FMT_lx" %c%c%c\n",
1736         start, end, end - start,
1737         ((prot & PAGE_READ) ? 'r' : '-'),
1738         ((prot & PAGE_WRITE) ? 'w' : '-'),
1739         ((prot & PAGE_EXEC) ? 'x' : '-'));
1740
1741     return 0;
1742 }
1743
1744 /* dump memory mappings */
1745 void page_dump(FILE *f)
1746 {
1747     const int length = sizeof(target_ulong) * 2;
1748     (void) fprintf(f, "%-*s %-*s %-*s %s\n",
1749             length, "start", length, "end", length, "size", "prot");
1750     walk_memory_regions(f, dump_region);
1751 }
1752
1753 int page_get_flags(target_ulong address)
1754 {
1755     PageDesc *p;
1756
1757     p = page_find(address >> TARGET_PAGE_BITS);
1758     if (!p) {
1759         return 0;
1760     }
1761     return p->flags;
1762 }
1763
1764 /* Modify the flags of a page and invalidate the code if necessary.
1765    The flag PAGE_WRITE_ORG is positioned automatically depending
1766    on PAGE_WRITE.  The mmap_lock should already be held.  */
1767 void page_set_flags(target_ulong start, target_ulong end, int flags)
1768 {
1769     target_ulong addr, len;
1770
1771     /* This function should never be called with addresses outside the
1772        guest address space.  If this assert fires, it probably indicates
1773        a missing call to h2g_valid.  */
1774 #if TARGET_ABI_BITS > L1_MAP_ADDR_SPACE_BITS
1775     assert(end < ((target_ulong)1 << L1_MAP_ADDR_SPACE_BITS));
1776 #endif
1777     assert(start < end);
1778
1779     start = start & TARGET_PAGE_MASK;
1780     end = TARGET_PAGE_ALIGN(end);
1781
1782     if (flags & PAGE_WRITE) {
1783         flags |= PAGE_WRITE_ORG;
1784     }
1785
1786     for (addr = start, len = end - start;
1787          len != 0;
1788          len -= TARGET_PAGE_SIZE, addr += TARGET_PAGE_SIZE) {
1789         PageDesc *p = page_find_alloc(addr >> TARGET_PAGE_BITS, 1);
1790
1791         /* If the write protection bit is set, then we invalidate
1792            the code inside.  */
1793         if (!(p->flags & PAGE_WRITE) &&
1794             (flags & PAGE_WRITE) &&
1795             p->first_tb) {
1796             tb_invalidate_phys_page(addr, 0, NULL, false);
1797         }
1798         p->flags = flags;
1799     }
1800 }
1801
1802 int page_check_range(target_ulong start, target_ulong len, int flags)
1803 {
1804     PageDesc *p;
1805     target_ulong end;
1806     target_ulong addr;
1807
1808     /* This function should never be called with addresses outside the
1809        guest address space.  If this assert fires, it probably indicates
1810        a missing call to h2g_valid.  */
1811 #if TARGET_ABI_BITS > L1_MAP_ADDR_SPACE_BITS
1812     assert(start < ((target_ulong)1 << L1_MAP_ADDR_SPACE_BITS));
1813 #endif
1814
1815     if (len == 0) {
1816         return 0;
1817     }
1818     if (start + len - 1 < start) {
1819         /* We've wrapped around.  */
1820         return -1;
1821     }
1822
1823     /* must do before we loose bits in the next step */
1824     end = TARGET_PAGE_ALIGN(start + len);
1825     start = start & TARGET_PAGE_MASK;
1826
1827     for (addr = start, len = end - start;
1828          len != 0;
1829          len -= TARGET_PAGE_SIZE, addr += TARGET_PAGE_SIZE) {
1830         p = page_find(addr >> TARGET_PAGE_BITS);
1831         if (!p) {
1832             return -1;
1833         }
1834         if (!(p->flags & PAGE_VALID)) {
1835             return -1;
1836         }
1837
1838         if ((flags & PAGE_READ) && !(p->flags & PAGE_READ)) {
1839             return -1;
1840         }
1841         if (flags & PAGE_WRITE) {
1842             if (!(p->flags & PAGE_WRITE_ORG)) {
1843                 return -1;
1844             }
1845             /* unprotect the page if it was put read-only because it
1846                contains translated code */
1847             if (!(p->flags & PAGE_WRITE)) {
1848                 if (!page_unprotect(addr, 0, NULL)) {
1849                     return -1;
1850                 }
1851             }
1852         }
1853     }
1854     return 0;
1855 }
1856
1857 /* called from signal handler: invalidate the code and unprotect the
1858    page. Return TRUE if the fault was successfully handled. */
1859 int page_unprotect(target_ulong address, uintptr_t pc, void *puc)
1860 {
1861     unsigned int prot;
1862     PageDesc *p;
1863     target_ulong host_start, host_end, addr;
1864
1865     /* Technically this isn't safe inside a signal handler.  However we
1866        know this only ever happens in a synchronous SEGV handler, so in
1867        practice it seems to be ok.  */
1868     mmap_lock();
1869
1870     p = page_find(address >> TARGET_PAGE_BITS);
1871     if (!p) {
1872         mmap_unlock();
1873         return 0;
1874     }
1875
1876     /* if the page was really writable, then we change its
1877        protection back to writable */
1878     if ((p->flags & PAGE_WRITE_ORG) && !(p->flags & PAGE_WRITE)) {
1879         host_start = address & qemu_host_page_mask;
1880         host_end = host_start + qemu_host_page_size;
1881
1882         prot = 0;
1883         for (addr = host_start ; addr < host_end ; addr += TARGET_PAGE_SIZE) {
1884             p = page_find(addr >> TARGET_PAGE_BITS);
1885             p->flags |= PAGE_WRITE;
1886             prot |= p->flags;
1887
1888             /* and since the content will be modified, we must invalidate
1889                the corresponding translated code. */
1890             tb_invalidate_phys_page(addr, pc, puc, true);
1891 #ifdef DEBUG_TB_CHECK
1892             tb_invalidate_check(addr);
1893 #endif
1894         }
1895         mprotect((void *)g2h(host_start), qemu_host_page_size,
1896                  prot & PAGE_BITS);
1897
1898         mmap_unlock();
1899         return 1;
1900     }
1901     mmap_unlock();
1902     return 0;
1903 }
1904 #endif /* CONFIG_USER_ONLY */