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