vcs.maemo.org Git - qemu/blob - exec.c

   1 /*
   2  *  virtual page mapping and translated block handling
   3  *
   4  *  Copyright (c) 2003 Fabrice Bellard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20 #include "config.h"
  21 #ifdef _WIN32
  22 #include <windows.h>
  23 #else
  24 #include <sys/types.h>
  25 #include <sys/mman.h>
  26 #endif
  27 #include <stdlib.h>
  28 #include <stdio.h>
  29 #include <stdarg.h>
  30 #include <string.h>
  31 #include <errno.h>
  32 #include <unistd.h>
  33 #include <inttypes.h>
  34
  35 #include "cpu.h"
  36 #include "exec-all.h"
  37 #if defined(CONFIG_USER_ONLY)
  38 #include <qemu.h>
  39 #endif
  40
  41 //#define DEBUG_TB_INVALIDATE
  42 //#define DEBUG_FLUSH
  43 //#define DEBUG_TLB
  44 //#define DEBUG_UNASSIGNED
  45
  46 /* make various TB consistency checks */
  47 //#define DEBUG_TB_CHECK
  48 //#define DEBUG_TLB_CHECK
  49
  50 //#define DEBUG_IOPORT
  51 //#define DEBUG_SUBPAGE
  52
  53 #if !defined(CONFIG_USER_ONLY)
  54 /* TB consistency checks only implemented for usermode emulation.  */
  55 #undef DEBUG_TB_CHECK
  56 #endif
  57
  58 /* threshold to flush the translated code buffer */
  59 #define CODE_GEN_BUFFER_MAX_SIZE (CODE_GEN_BUFFER_SIZE - CODE_GEN_MAX_SIZE)
  60
  61 #define SMC_BITMAP_USE_THRESHOLD 10
  62
  63 #define MMAP_AREA_START        0x00000000
  64 #define MMAP_AREA_END          0xa8000000
  65
  66 #if defined(TARGET_SPARC64)
  67 #define TARGET_PHYS_ADDR_SPACE_BITS 41
  68 #elif defined(TARGET_SPARC)
  69 #define TARGET_PHYS_ADDR_SPACE_BITS 36
  70 #elif defined(TARGET_ALPHA)
  71 #define TARGET_PHYS_ADDR_SPACE_BITS 42
  72 #define TARGET_VIRT_ADDR_SPACE_BITS 42
  73 #elif defined(TARGET_PPC64)
  74 #define TARGET_PHYS_ADDR_SPACE_BITS 42
  75 #else
  76 /* Note: for compatibility with kqemu, we use 32 bits for x86_64 */
  77 #define TARGET_PHYS_ADDR_SPACE_BITS 32
  78 #endif
  79
  80 TranslationBlock tbs[CODE_GEN_MAX_BLOCKS];
  81 TranslationBlock *tb_phys_hash[CODE_GEN_PHYS_HASH_SIZE];
  82 int nb_tbs;
  83 /* any access to the tbs or the page table must use this lock */
  84 spinlock_t tb_lock = SPIN_LOCK_UNLOCKED;
  85
  86 uint8_t code_gen_buffer[CODE_GEN_BUFFER_SIZE] __attribute__((aligned (32)));
  87 uint8_t *code_gen_ptr;
  88
  89 int phys_ram_size;
  90 int phys_ram_fd;
  91 uint8_t *phys_ram_base;
  92 uint8_t *phys_ram_dirty;
  93 static ram_addr_t phys_ram_alloc_offset = 0;
  94
  95 CPUState *first_cpu;
  96 /* current CPU in the current thread. It is only valid inside
  97    cpu_exec() */
  98 CPUState *cpu_single_env;
  99
 100 typedef struct PageDesc {
 101     /* list of TBs intersecting this ram page */
 102     TranslationBlock *first_tb;
 103     /* in order to optimize self modifying code, we count the number
 104        of lookups we do to a given page to use a bitmap */
 105     unsigned int code_write_count;
 106     uint8_t *code_bitmap;
 107 #if defined(CONFIG_USER_ONLY)
 108     unsigned long flags;
 109 #endif
 110 } PageDesc;
 111
 112 typedef struct PhysPageDesc {
 113     /* offset in host memory of the page + io_index in the low 12 bits */
 114     uint32_t phys_offset;
 115 } PhysPageDesc;
 116
 117 #define L2_BITS 10
 118 #if defined(CONFIG_USER_ONLY) && defined(TARGET_VIRT_ADDR_SPACE_BITS)
 119 /* XXX: this is a temporary hack for alpha target.
 120  *      In the future, this is to be replaced by a multi-level table
 121  *      to actually be able to handle the complete 64 bits address space.
 122  */
 123 #define L1_BITS (TARGET_VIRT_ADDR_SPACE_BITS - L2_BITS - TARGET_PAGE_BITS)
 124 #else
 125 #define L1_BITS (32 - L2_BITS - TARGET_PAGE_BITS)
 126 #endif
 127
 128 #define L1_SIZE (1 << L1_BITS)
 129 #define L2_SIZE (1 << L2_BITS)
 130
 131 static void io_mem_init(void);
 132
 133 unsigned long qemu_real_host_page_size;
 134 unsigned long qemu_host_page_bits;
 135 unsigned long qemu_host_page_size;
 136 unsigned long qemu_host_page_mask;
 137
 138 /* XXX: for system emulation, it could just be an array */
 139 static PageDesc *l1_map[L1_SIZE];
 140 PhysPageDesc **l1_phys_map;
 141
 142 /* io memory support */
 143 CPUWriteMemoryFunc *io_mem_write[IO_MEM_NB_ENTRIES][4];
 144 CPUReadMemoryFunc *io_mem_read[IO_MEM_NB_ENTRIES][4];
 145 void *io_mem_opaque[IO_MEM_NB_ENTRIES];
 146 static int io_mem_nb;
 147 #if defined(CONFIG_SOFTMMU)
 148 static int io_mem_watch;
 149 #endif
 150
 151 /* log support */
 152 char *logfilename = "/tmp/qemu.log";
 153 FILE *logfile;
 154 int loglevel;
 155 static int log_append = 0;
 156
 157 /* statistics */
 158 static int tlb_flush_count;
 159 static int tb_flush_count;
 160 static int tb_phys_invalidate_count;
 161
 162 #define SUBPAGE_IDX(addr) ((addr) & ~TARGET_PAGE_MASK)
 163 typedef struct subpage_t {
 164     target_phys_addr_t base;
 165     CPUReadMemoryFunc **mem_read[TARGET_PAGE_SIZE];
 166     CPUWriteMemoryFunc **mem_write[TARGET_PAGE_SIZE];
 167     void *opaque[TARGET_PAGE_SIZE];
 168 } subpage_t;
 169
 170 static void page_init(void)
 171 {
 172     /* NOTE: we can always suppose that qemu_host_page_size >=
 173        TARGET_PAGE_SIZE */
 174 #ifdef _WIN32
 175     {
 176         SYSTEM_INFO system_info;
 177         DWORD old_protect;
 178
 179         GetSystemInfo(&system_info);
 180         qemu_real_host_page_size = system_info.dwPageSize;
 181
 182         VirtualProtect(code_gen_buffer, sizeof(code_gen_buffer),
 183                        PAGE_EXECUTE_READWRITE, &old_protect);
 184     }
 185 #else
 186     qemu_real_host_page_size = getpagesize();
 187     {
 188         unsigned long start, end;
 189
 190         start = (unsigned long)code_gen_buffer;
 191         start &= ~(qemu_real_host_page_size - 1);
 192
 193         end = (unsigned long)code_gen_buffer + sizeof(code_gen_buffer);
 194         end += qemu_real_host_page_size - 1;
 195         end &= ~(qemu_real_host_page_size - 1);
 196
 197         mprotect((void *)start, end - start,
 198                  PROT_READ | PROT_WRITE | PROT_EXEC);
 199     }
 200 #endif
 201
 202     if (qemu_host_page_size == 0)
 203         qemu_host_page_size = qemu_real_host_page_size;
 204     if (qemu_host_page_size < TARGET_PAGE_SIZE)
 205         qemu_host_page_size = TARGET_PAGE_SIZE;
 206     qemu_host_page_bits = 0;
 207     while ((1 << qemu_host_page_bits) < qemu_host_page_size)
 208         qemu_host_page_bits++;
 209     qemu_host_page_mask = ~(qemu_host_page_size - 1);
 210     l1_phys_map = qemu_vmalloc(L1_SIZE * sizeof(void *));
 211     memset(l1_phys_map, 0, L1_SIZE * sizeof(void *));
 212 }
 213
 214 static inline PageDesc *page_find_alloc(unsigned int index)
 215 {
 216     PageDesc **lp, *p;
 217
 218     lp = &l1_map[index >> L2_BITS];
 219     p = *lp;
 220     if (!p) {
 221         /* allocate if not found */
 222         p = qemu_malloc(sizeof(PageDesc) * L2_SIZE);
 223         memset(p, 0, sizeof(PageDesc) * L2_SIZE);
 224         *lp = p;
 225     }
 226     return p + (index & (L2_SIZE - 1));
 227 }
 228
 229 static inline PageDesc *page_find(unsigned int index)
 230 {
 231     PageDesc *p;
 232
 233     p = l1_map[index >> L2_BITS];
 234     if (!p)
 235         return 0;
 236     return p + (index & (L2_SIZE - 1));
 237 }
 238
 239 static PhysPageDesc *phys_page_find_alloc(target_phys_addr_t index, int alloc)
 240 {
 241     void **lp, **p;
 242     PhysPageDesc *pd;
 243
 244     p = (void **)l1_phys_map;
 245 #if TARGET_PHYS_ADDR_SPACE_BITS > 32
 246
 247 #if TARGET_PHYS_ADDR_SPACE_BITS > (32 + L1_BITS)
 248 #error unsupported TARGET_PHYS_ADDR_SPACE_BITS
 249 #endif
 250     lp = p + ((index >> (L1_BITS + L2_BITS)) & (L1_SIZE - 1));
 251     p = *lp;
 252     if (!p) {
 253         /* allocate if not found */
 254         if (!alloc)
 255             return NULL;
 256         p = qemu_vmalloc(sizeof(void *) * L1_SIZE);
 257         memset(p, 0, sizeof(void *) * L1_SIZE);
 258         *lp = p;
 259     }
 260 #endif
 261     lp = p + ((index >> L2_BITS) & (L1_SIZE - 1));
 262     pd = *lp;
 263     if (!pd) {
 264         int i;
 265         /* allocate if not found */
 266         if (!alloc)
 267             return NULL;
 268         pd = qemu_vmalloc(sizeof(PhysPageDesc) * L2_SIZE);
 269         *lp = pd;
 270         for (i = 0; i < L2_SIZE; i++)
 271           pd[i].phys_offset = IO_MEM_UNASSIGNED;
 272     }
 273     return ((PhysPageDesc *)pd) + (index & (L2_SIZE - 1));
 274 }
 275
 276 static inline PhysPageDesc *phys_page_find(target_phys_addr_t index)
 277 {
 278     return phys_page_find_alloc(index, 0);
 279 }
 280
 281 #if !defined(CONFIG_USER_ONLY)
 282 static void tlb_protect_code(ram_addr_t ram_addr);
 283 static void tlb_unprotect_code_phys(CPUState *env, ram_addr_t ram_addr,
 284                                     target_ulong vaddr);
 285 #endif
 286
 287 void cpu_exec_init(CPUState *env)
 288 {
 289     CPUState **penv;
 290     int cpu_index;
 291
 292     if (!code_gen_ptr) {
 293         code_gen_ptr = code_gen_buffer;
 294         page_init();
 295         io_mem_init();
 296     }
 297     env->next_cpu = NULL;
 298     penv = &first_cpu;
 299     cpu_index = 0;
 300     while (*penv != NULL) {
 301         penv = (CPUState **)&(*penv)->next_cpu;
 302         cpu_index++;
 303     }
 304     env->cpu_index = cpu_index;
 305     env->nb_watchpoints = 0;
 306     *penv = env;
 307 }
 308
 309 static inline void invalidate_page_bitmap(PageDesc *p)
 310 {
 311     if (p->code_bitmap) {
 312         qemu_free(p->code_bitmap);
 313         p->code_bitmap = NULL;
 314     }
 315     p->code_write_count = 0;
 316 }
 317
 318 /* set to NULL all the 'first_tb' fields in all PageDescs */
 319 static void page_flush_tb(void)
 320 {
 321     int i, j;
 322     PageDesc *p;
 323
 324     for(i = 0; i < L1_SIZE; i++) {
 325         p = l1_map[i];
 326         if (p) {
 327             for(j = 0; j < L2_SIZE; j++) {
 328                 p->first_tb = NULL;
 329                 invalidate_page_bitmap(p);
 330                 p++;
 331             }
 332         }
 333     }
 334 }
 335
 336 /* flush all the translation blocks */
 337 /* XXX: tb_flush is currently not thread safe */
 338 void tb_flush(CPUState *env1)
 339 {
 340     CPUState *env;
 341 #if defined(DEBUG_FLUSH)
 342     printf("qemu: flush code_size=%d nb_tbs=%d avg_tb_size=%d\n",
 343            code_gen_ptr - code_gen_buffer,
 344            nb_tbs,
 345            nb_tbs > 0 ? (code_gen_ptr - code_gen_buffer) / nb_tbs : 0);
 346 #endif
 347     nb_tbs = 0;
 348
 349     for(env = first_cpu; env != NULL; env = env->next_cpu) {
 350         memset (env->tb_jmp_cache, 0, TB_JMP_CACHE_SIZE * sizeof (void *));
 351     }
 352
 353     memset (tb_phys_hash, 0, CODE_GEN_PHYS_HASH_SIZE * sizeof (void *));
 354     page_flush_tb();
 355
 356     code_gen_ptr = code_gen_buffer;
 357     /* XXX: flush processor icache at this point if cache flush is
 358        expensive */
 359     tb_flush_count++;
 360 }
 361
 362 #ifdef DEBUG_TB_CHECK
 363
 364 static void tb_invalidate_check(target_ulong address)
 365 {
 366     TranslationBlock *tb;
 367     int i;
 368     address &= TARGET_PAGE_MASK;
 369     for(i = 0;i < CODE_GEN_PHYS_HASH_SIZE; i++) {
 370         for(tb = tb_phys_hash[i]; tb != NULL; tb = tb->phys_hash_next) {
 371             if (!(address + TARGET_PAGE_SIZE <= tb->pc ||
 372                   address >= tb->pc + tb->size)) {
 373                 printf("ERROR invalidate: address=%08lx PC=%08lx size=%04x\n",
 374                        address, (long)tb->pc, tb->size);
 375             }
 376         }
 377     }
 378 }
 379
 380 /* verify that all the pages have correct rights for code */
 381 static void tb_page_check(void)
 382 {
 383     TranslationBlock *tb;
 384     int i, flags1, flags2;
 385
 386     for(i = 0;i < CODE_GEN_PHYS_HASH_SIZE; i++) {
 387         for(tb = tb_phys_hash[i]; tb != NULL; tb = tb->phys_hash_next) {
 388             flags1 = page_get_flags(tb->pc);
 389             flags2 = page_get_flags(tb->pc + tb->size - 1);
 390             if ((flags1 & PAGE_WRITE) || (flags2 & PAGE_WRITE)) {
 391                 printf("ERROR page flags: PC=%08lx size=%04x f1=%x f2=%x\n",
 392                        (long)tb->pc, tb->size, flags1, flags2);
 393             }
 394         }
 395     }
 396 }
 397
 398 void tb_jmp_check(TranslationBlock *tb)
 399 {
 400     TranslationBlock *tb1;
 401     unsigned int n1;
 402
 403     /* suppress any remaining jumps to this TB */
 404     tb1 = tb->jmp_first;
 405     for(;;) {
 406         n1 = (long)tb1 & 3;
 407         tb1 = (TranslationBlock *)((long)tb1 & ~3);
 408         if (n1 == 2)
 409             break;
 410         tb1 = tb1->jmp_next[n1];
 411     }
 412     /* check end of list */
 413     if (tb1 != tb) {
 414         printf("ERROR: jmp_list from 0x%08lx\n", (long)tb);
 415     }
 416 }
 417
 418 #endif
 419
 420 /* invalidate one TB */
 421 static inline void tb_remove(TranslationBlock **ptb, TranslationBlock *tb,
 422                              int next_offset)
 423 {
 424     TranslationBlock *tb1;
 425     for(;;) {
 426         tb1 = *ptb;
 427         if (tb1 == tb) {
 428             *ptb = *(TranslationBlock **)((char *)tb1 + next_offset);
 429             break;
 430         }
 431         ptb = (TranslationBlock **)((char *)tb1 + next_offset);
 432     }
 433 }
 434
 435 static inline void tb_page_remove(TranslationBlock **ptb, TranslationBlock *tb)
 436 {
 437     TranslationBlock *tb1;
 438     unsigned int n1;
 439
 440     for(;;) {
 441         tb1 = *ptb;
 442         n1 = (long)tb1 & 3;
 443         tb1 = (TranslationBlock *)((long)tb1 & ~3);
 444         if (tb1 == tb) {
 445             *ptb = tb1->page_next[n1];
 446             break;
 447         }
 448         ptb = &tb1->page_next[n1];
 449     }
 450 }
 451
 452 static inline void tb_jmp_remove(TranslationBlock *tb, int n)
 453 {
 454     TranslationBlock *tb1, **ptb;
 455     unsigned int n1;
 456
 457     ptb = &tb->jmp_next[n];
 458     tb1 = *ptb;
 459     if (tb1) {
 460         /* find tb(n) in circular list */
 461         for(;;) {
 462             tb1 = *ptb;
 463             n1 = (long)tb1 & 3;
 464             tb1 = (TranslationBlock *)((long)tb1 & ~3);
 465             if (n1 == n && tb1 == tb)
 466                 break;
 467             if (n1 == 2) {
 468                 ptb = &tb1->jmp_first;
 469             } else {
 470                 ptb = &tb1->jmp_next[n1];
 471             }
 472         }
 473         /* now we can suppress tb(n) from the list */
 474         *ptb = tb->jmp_next[n];
 475
 476         tb->jmp_next[n] = NULL;
 477     }
 478 }
 479
 480 /* reset the jump entry 'n' of a TB so that it is not chained to
 481    another TB */
 482 static inline void tb_reset_jump(TranslationBlock *tb, int n)
 483 {
 484     tb_set_jmp_target(tb, n, (unsigned long)(tb->tc_ptr + tb->tb_next_offset[n]));
 485 }
 486
 487 static inline void tb_phys_invalidate(TranslationBlock *tb, unsigned int page_addr)
 488 {
 489     CPUState *env;
 490     PageDesc *p;
 491     unsigned int h, n1;
 492     target_ulong phys_pc;
 493     TranslationBlock *tb1, *tb2;
 494
 495     /* remove the TB from the hash list */
 496     phys_pc = tb->page_addr[0] + (tb->pc & ~TARGET_PAGE_MASK);
 497     h = tb_phys_hash_func(phys_pc);
 498     tb_remove(&tb_phys_hash[h], tb,
 499               offsetof(TranslationBlock, phys_hash_next));
 500
 501     /* remove the TB from the page list */
 502     if (tb->page_addr[0] != page_addr) {
 503         p = page_find(tb->page_addr[0] >> TARGET_PAGE_BITS);
 504         tb_page_remove(&p->first_tb, tb);
 505         invalidate_page_bitmap(p);
 506     }
 507     if (tb->page_addr[1] != -1 && tb->page_addr[1] != page_addr) {
 508         p = page_find(tb->page_addr[1] >> TARGET_PAGE_BITS);
 509         tb_page_remove(&p->first_tb, tb);
 510         invalidate_page_bitmap(p);
 511     }
 512
 513     tb_invalidated_flag = 1;
 514
 515     /* remove the TB from the hash list */
 516     h = tb_jmp_cache_hash_func(tb->pc);
 517     for(env = first_cpu; env != NULL; env = env->next_cpu) {
 518         if (env->tb_jmp_cache[h] == tb)
 519             env->tb_jmp_cache[h] = NULL;
 520     }
 521
 522     /* suppress this TB from the two jump lists */
 523     tb_jmp_remove(tb, 0);
 524     tb_jmp_remove(tb, 1);
 525
 526     /* suppress any remaining jumps to this TB */
 527     tb1 = tb->jmp_first;
 528     for(;;) {
 529         n1 = (long)tb1 & 3;
 530         if (n1 == 2)
 531             break;
 532         tb1 = (TranslationBlock *)((long)tb1 & ~3);
 533         tb2 = tb1->jmp_next[n1];
 534         tb_reset_jump(tb1, n1);
 535         tb1->jmp_next[n1] = NULL;
 536         tb1 = tb2;
 537     }
 538     tb->jmp_first = (TranslationBlock *)((long)tb | 2); /* fail safe */
 539
 540     tb_phys_invalidate_count++;
 541 }
 542
 543 static inline void set_bits(uint8_t *tab, int start, int len)
 544 {
 545     int end, mask, end1;
 546
 547     end = start + len;
 548     tab += start >> 3;
 549     mask = 0xff << (start & 7);
 550     if ((start & ~7) == (end & ~7)) {
 551         if (start < end) {
 552             mask &= ~(0xff << (end & 7));
 553             *tab |= mask;
 554         }
 555     } else {
 556         *tab++ |= mask;
 557         start = (start + 8) & ~7;
 558         end1 = end & ~7;
 559         while (start < end1) {
 560             *tab++ = 0xff;
 561             start += 8;
 562         }
 563         if (start < end) {
 564             mask = ~(0xff << (end & 7));
 565             *tab |= mask;
 566         }
 567     }
 568 }
 569
 570 static void build_page_bitmap(PageDesc *p)
 571 {
 572     int n, tb_start, tb_end;
 573     TranslationBlock *tb;
 574
 575     p->code_bitmap = qemu_malloc(TARGET_PAGE_SIZE / 8);
 576     if (!p->code_bitmap)
 577         return;
 578     memset(p->code_bitmap, 0, TARGET_PAGE_SIZE / 8);
 579
 580     tb = p->first_tb;
 581     while (tb != NULL) {
 582         n = (long)tb & 3;
 583         tb = (TranslationBlock *)((long)tb & ~3);
 584         /* NOTE: this is subtle as a TB may span two physical pages */
 585         if (n == 0) {
 586             /* NOTE: tb_end may be after the end of the page, but
 587                it is not a problem */
 588             tb_start = tb->pc & ~TARGET_PAGE_MASK;
 589             tb_end = tb_start + tb->size;
 590             if (tb_end > TARGET_PAGE_SIZE)
 591                 tb_end = TARGET_PAGE_SIZE;
 592         } else {
 593             tb_start = 0;
 594             tb_end = ((tb->pc + tb->size) & ~TARGET_PAGE_MASK);
 595         }
 596         set_bits(p->code_bitmap, tb_start, tb_end - tb_start);
 597         tb = tb->page_next[n];
 598     }
 599 }
 600
 601 #ifdef TARGET_HAS_PRECISE_SMC
 602
 603 static void tb_gen_code(CPUState *env,
 604                         target_ulong pc, target_ulong cs_base, int flags,
 605                         int cflags)
 606 {
 607     TranslationBlock *tb;
 608     uint8_t *tc_ptr;
 609     target_ulong phys_pc, phys_page2, virt_page2;
 610     int code_gen_size;
 611
 612     phys_pc = get_phys_addr_code(env, pc);
 613     tb = tb_alloc(pc);
 614     if (!tb) {
 615         /* flush must be done */
 616         tb_flush(env);
 617         /* cannot fail at this point */
 618         tb = tb_alloc(pc);
 619     }
 620     tc_ptr = code_gen_ptr;
 621     tb->tc_ptr = tc_ptr;
 622     tb->cs_base = cs_base;
 623     tb->flags = flags;
 624     tb->cflags = cflags;
 625     cpu_gen_code(env, tb, CODE_GEN_MAX_SIZE, &code_gen_size);
 626     code_gen_ptr = (void *)(((unsigned long)code_gen_ptr + code_gen_size + CODE_GEN_ALIGN - 1) & ~(CODE_GEN_ALIGN - 1));
 627
 628     /* check next page if needed */
 629     virt_page2 = (pc + tb->size - 1) & TARGET_PAGE_MASK;
 630     phys_page2 = -1;
 631     if ((pc & TARGET_PAGE_MASK) != virt_page2) {
 632         phys_page2 = get_phys_addr_code(env, virt_page2);
 633     }
 634     tb_link_phys(tb, phys_pc, phys_page2);
 635 }
 636 #endif
 637
 638 /* invalidate all TBs which intersect with the target physical page
 639    starting in range [start;end[. NOTE: start and end must refer to
 640    the same physical page. 'is_cpu_write_access' should be true if called
 641    from a real cpu write access: the virtual CPU will exit the current
 642    TB if code is modified inside this TB. */
 643 void tb_invalidate_phys_page_range(target_ulong start, target_ulong end,
 644                                    int is_cpu_write_access)
 645 {
 646     int n, current_tb_modified, current_tb_not_found, current_flags;
 647     CPUState *env = cpu_single_env;
 648     PageDesc *p;
 649     TranslationBlock *tb, *tb_next, *current_tb, *saved_tb;
 650     target_ulong tb_start, tb_end;
 651     target_ulong current_pc, current_cs_base;
 652
 653     p = page_find(start >> TARGET_PAGE_BITS);
 654     if (!p)
 655         return;
 656     if (!p->code_bitmap &&
 657         ++p->code_write_count >= SMC_BITMAP_USE_THRESHOLD &&
 658         is_cpu_write_access) {
 659         /* build code bitmap */
 660         build_page_bitmap(p);
 661     }
 662
 663     /* we remove all the TBs in the range [start, end[ */
 664     /* XXX: see if in some cases it could be faster to invalidate all the code */
 665     current_tb_not_found = is_cpu_write_access;
 666     current_tb_modified = 0;
 667     current_tb = NULL; /* avoid warning */
 668     current_pc = 0; /* avoid warning */
 669     current_cs_base = 0; /* avoid warning */
 670     current_flags = 0; /* avoid warning */
 671     tb = p->first_tb;
 672     while (tb != NULL) {
 673         n = (long)tb & 3;
 674         tb = (TranslationBlock *)((long)tb & ~3);
 675         tb_next = tb->page_next[n];
 676         /* NOTE: this is subtle as a TB may span two physical pages */
 677         if (n == 0) {
 678             /* NOTE: tb_end may be after the end of the page, but
 679                it is not a problem */
 680             tb_start = tb->page_addr[0] + (tb->pc & ~TARGET_PAGE_MASK);
 681             tb_end = tb_start + tb->size;
 682         } else {
 683             tb_start = tb->page_addr[1];
 684             tb_end = tb_start + ((tb->pc + tb->size) & ~TARGET_PAGE_MASK);
 685         }
 686         if (!(tb_end <= start || tb_start >= end)) {
 687 #ifdef TARGET_HAS_PRECISE_SMC
 688             if (current_tb_not_found) {
 689                 current_tb_not_found = 0;
 690                 current_tb = NULL;
 691                 if (env->mem_write_pc) {
 692                     /* now we have a real cpu fault */
 693                     current_tb = tb_find_pc(env->mem_write_pc);
 694                 }
 695             }
 696             if (current_tb == tb &&
 697                 !(current_tb->cflags & CF_SINGLE_INSN)) {
 698                 /* If we are modifying the current TB, we must stop
 699                 its execution. We could be more precise by checking
 700                 that the modification is after the current PC, but it
 701                 would require a specialized function to partially
 702                 restore the CPU state */
 703
 704                 current_tb_modified = 1;
 705                 cpu_restore_state(current_tb, env,
 706                                   env->mem_write_pc, NULL);
 707 #if defined(TARGET_I386)
 708                 current_flags = env->hflags;
 709                 current_flags |= (env->eflags & (IOPL_MASK | TF_MASK | VM_MASK));
 710                 current_cs_base = (target_ulong)env->segs[R_CS].base;
 711                 current_pc = current_cs_base + env->eip;
 712 #else
 713 #error unsupported CPU
 714 #endif
 715             }
 716 #endif /* TARGET_HAS_PRECISE_SMC */
 717             /* we need to do that to handle the case where a signal
 718                occurs while doing tb_phys_invalidate() */
 719             saved_tb = NULL;
 720             if (env) {
 721                 saved_tb = env->current_tb;
 722                 env->current_tb = NULL;
 723             }
 724             tb_phys_invalidate(tb, -1);
 725             if (env) {
 726                 env->current_tb = saved_tb;
 727                 if (env->interrupt_request && env->current_tb)
 728                     cpu_interrupt(env, env->interrupt_request);
 729             }
 730         }
 731         tb = tb_next;
 732     }
 733 #if !defined(CONFIG_USER_ONLY)
 734     /* if no code remaining, no need to continue to use slow writes */
 735     if (!p->first_tb) {
 736         invalidate_page_bitmap(p);
 737         if (is_cpu_write_access) {
 738             tlb_unprotect_code_phys(env, start, env->mem_write_vaddr);
 739         }
 740     }
 741 #endif
 742 #ifdef TARGET_HAS_PRECISE_SMC
 743     if (current_tb_modified) {
 744         /* we generate a block containing just the instruction
 745            modifying the memory. It will ensure that it cannot modify
 746            itself */
 747         env->current_tb = NULL;
 748         tb_gen_code(env, current_pc, current_cs_base, current_flags,
 749                     CF_SINGLE_INSN);
 750         cpu_resume_from_signal(env, NULL);
 751     }
 752 #endif
 753 }
 754
 755 /* len must be <= 8 and start must be a multiple of len */
 756 static inline void tb_invalidate_phys_page_fast(target_ulong start, int len)
 757 {
 758     PageDesc *p;
 759     int offset, b;
 760 #if 0
 761     if (1) {
 762         if (loglevel) {
 763             fprintf(logfile, "modifying code at 0x%x size=%d EIP=%x PC=%08x\n",
 764                    cpu_single_env->mem_write_vaddr, len,
 765                    cpu_single_env->eip,
 766                    cpu_single_env->eip + (long)cpu_single_env->segs[R_CS].base);
 767         }
 768     }
 769 #endif
 770     p = page_find(start >> TARGET_PAGE_BITS);
 771     if (!p)
 772         return;
 773     if (p->code_bitmap) {
 774         offset = start & ~TARGET_PAGE_MASK;
 775         b = p->code_bitmap[offset >> 3] >> (offset & 7);
 776         if (b & ((1 << len) - 1))
 777             goto do_invalidate;
 778     } else {
 779     do_invalidate:
 780         tb_invalidate_phys_page_range(start, start + len, 1);
 781     }
 782 }
 783
 784 #if !defined(CONFIG_SOFTMMU)
 785 static void tb_invalidate_phys_page(target_ulong addr,
 786                                     unsigned long pc, void *puc)
 787 {
 788     int n, current_flags, current_tb_modified;
 789     target_ulong current_pc, current_cs_base;
 790     PageDesc *p;
 791     TranslationBlock *tb, *current_tb;
 792 #ifdef TARGET_HAS_PRECISE_SMC
 793     CPUState *env = cpu_single_env;
 794 #endif
 795
 796     addr &= TARGET_PAGE_MASK;
 797     p = page_find(addr >> TARGET_PAGE_BITS);
 798     if (!p)
 799         return;
 800     tb = p->first_tb;
 801     current_tb_modified = 0;
 802     current_tb = NULL;
 803     current_pc = 0; /* avoid warning */
 804     current_cs_base = 0; /* avoid warning */
 805     current_flags = 0; /* avoid warning */
 806 #ifdef TARGET_HAS_PRECISE_SMC
 807     if (tb && pc != 0) {
 808         current_tb = tb_find_pc(pc);
 809     }
 810 #endif
 811     while (tb != NULL) {
 812         n = (long)tb & 3;
 813         tb = (TranslationBlock *)((long)tb & ~3);
 814 #ifdef TARGET_HAS_PRECISE_SMC
 815         if (current_tb == tb &&
 816             !(current_tb->cflags & CF_SINGLE_INSN)) {
 817                 /* If we are modifying the current TB, we must stop
 818                    its execution. We could be more precise by checking
 819                    that the modification is after the current PC, but it
 820                    would require a specialized function to partially
 821                    restore the CPU state */
 822
 823             current_tb_modified = 1;
 824             cpu_restore_state(current_tb, env, pc, puc);
 825 #if defined(TARGET_I386)
 826             current_flags = env->hflags;
 827             current_flags |= (env->eflags & (IOPL_MASK | TF_MASK | VM_MASK));
 828             current_cs_base = (target_ulong)env->segs[R_CS].base;
 829             current_pc = current_cs_base + env->eip;
 830 #else
 831 #error unsupported CPU
 832 #endif
 833         }
 834 #endif /* TARGET_HAS_PRECISE_SMC */
 835         tb_phys_invalidate(tb, addr);
 836         tb = tb->page_next[n];
 837     }
 838     p->first_tb = NULL;
 839 #ifdef TARGET_HAS_PRECISE_SMC
 840     if (current_tb_modified) {
 841         /* we generate a block containing just the instruction
 842            modifying the memory. It will ensure that it cannot modify
 843            itself */
 844         env->current_tb = NULL;
 845         tb_gen_code(env, current_pc, current_cs_base, current_flags,
 846                     CF_SINGLE_INSN);
 847         cpu_resume_from_signal(env, puc);
 848     }
 849 #endif
 850 }
 851 #endif
 852
 853 /* add the tb in the target page and protect it if necessary */
 854 static inline void tb_alloc_page(TranslationBlock *tb,
 855                                  unsigned int n, target_ulong page_addr)
 856 {
 857     PageDesc *p;
 858     TranslationBlock *last_first_tb;
 859
 860     tb->page_addr[n] = page_addr;
 861     p = page_find_alloc(page_addr >> TARGET_PAGE_BITS);
 862     tb->page_next[n] = p->first_tb;
 863     last_first_tb = p->first_tb;
 864     p->first_tb = (TranslationBlock *)((long)tb | n);
 865     invalidate_page_bitmap(p);
 866
 867 #if defined(TARGET_HAS_SMC) || 1
 868
 869 #if defined(CONFIG_USER_ONLY)
 870     if (p->flags & PAGE_WRITE) {
 871         target_ulong addr;
 872         PageDesc *p2;
 873         int prot;
 874
 875         /* force the host page as non writable (writes will have a
 876            page fault + mprotect overhead) */
 877         page_addr &= qemu_host_page_mask;
 878         prot = 0;
 879         for(addr = page_addr; addr < page_addr + qemu_host_page_size;
 880             addr += TARGET_PAGE_SIZE) {
 881
 882             p2 = page_find (addr >> TARGET_PAGE_BITS);
 883             if (!p2)
 884                 continue;
 885             prot |= p2->flags;
 886             p2->flags &= ~PAGE_WRITE;
 887             page_get_flags(addr);
 888           }
 889         mprotect(g2h(page_addr), qemu_host_page_size,
 890                  (prot & PAGE_BITS) & ~PAGE_WRITE);
 891 #ifdef DEBUG_TB_INVALIDATE
 892         printf("protecting code page: 0x%08lx\n",
 893                page_addr);
 894 #endif
 895     }
 896 #else
 897     /* if some code is already present, then the pages are already
 898        protected. So we handle the case where only the first TB is
 899        allocated in a physical page */
 900     if (!last_first_tb) {
 901         tlb_protect_code(page_addr);
 902     }
 903 #endif
 904
 905 #endif /* TARGET_HAS_SMC */
 906 }
 907
 908 /* Allocate a new translation block. Flush the translation buffer if
 909    too many translation blocks or too much generated code. */
 910 TranslationBlock *tb_alloc(target_ulong pc)
 911 {
 912     TranslationBlock *tb;
 913
 914     if (nb_tbs >= CODE_GEN_MAX_BLOCKS ||
 915         (code_gen_ptr - code_gen_buffer) >= CODE_GEN_BUFFER_MAX_SIZE)
 916         return NULL;
 917     tb = &tbs[nb_tbs++];
 918     tb->pc = pc;
 919     tb->cflags = 0;
 920     return tb;
 921 }
 922
 923 /* add a new TB and link it to the physical page tables. phys_page2 is
 924    (-1) to indicate that only one page contains the TB. */
 925 void tb_link_phys(TranslationBlock *tb,
 926                   target_ulong phys_pc, target_ulong phys_page2)
 927 {
 928     unsigned int h;
 929     TranslationBlock **ptb;
 930
 931     /* add in the physical hash table */
 932     h = tb_phys_hash_func(phys_pc);
 933     ptb = &tb_phys_hash[h];
 934     tb->phys_hash_next = *ptb;
 935     *ptb = tb;
 936
 937     /* add in the page list */
 938     tb_alloc_page(tb, 0, phys_pc & TARGET_PAGE_MASK);
 939     if (phys_page2 != -1)
 940         tb_alloc_page(tb, 1, phys_page2);
 941     else
 942         tb->page_addr[1] = -1;
 943
 944     tb->jmp_first = (TranslationBlock *)((long)tb | 2);
 945     tb->jmp_next[0] = NULL;
 946     tb->jmp_next[1] = NULL;
 947 #ifdef USE_CODE_COPY
 948     tb->cflags &= ~CF_FP_USED;
 949     if (tb->cflags & CF_TB_FP_USED)
 950         tb->cflags |= CF_FP_USED;
 951 #endif
 952
 953     /* init original jump addresses */
 954     if (tb->tb_next_offset[0] != 0xffff)
 955         tb_reset_jump(tb, 0);
 956     if (tb->tb_next_offset[1] != 0xffff)
 957         tb_reset_jump(tb, 1);
 958
 959 #ifdef DEBUG_TB_CHECK
 960     tb_page_check();
 961 #endif
 962 }
 963
 964 /* find the TB 'tb' such that tb[0].tc_ptr <= tc_ptr <
 965    tb[1].tc_ptr. Return NULL if not found */
 966 TranslationBlock *tb_find_pc(unsigned long tc_ptr)
 967 {
 968     int m_min, m_max, m;
 969     unsigned long v;
 970     TranslationBlock *tb;
 971
 972     if (nb_tbs <= 0)
 973         return NULL;
 974     if (tc_ptr < (unsigned long)code_gen_buffer ||
 975         tc_ptr >= (unsigned long)code_gen_ptr)
 976         return NULL;
 977     /* binary search (cf Knuth) */
 978     m_min = 0;
 979     m_max = nb_tbs - 1;
 980     while (m_min <= m_max) {
 981         m = (m_min + m_max) >> 1;
 982         tb = &tbs[m];
 983         v = (unsigned long)tb->tc_ptr;
 984         if (v == tc_ptr)
 985             return tb;
 986         else if (tc_ptr < v) {
 987             m_max = m - 1;
 988         } else {
 989             m_min = m + 1;
 990         }
 991     }
 992     return &tbs[m_max];
 993 }
 994
 995 static void tb_reset_jump_recursive(TranslationBlock *tb);
 996
 997 static inline void tb_reset_jump_recursive2(TranslationBlock *tb, int n)
 998 {
 999     TranslationBlock *tb1, *tb_next, **ptb;
1000     unsigned int n1;
1001
1002     tb1 = tb->jmp_next[n];
1003     if (tb1 != NULL) {
1004         /* find head of list */
1005         for(;;) {
1006             n1 = (long)tb1 & 3;
1007             tb1 = (TranslationBlock *)((long)tb1 & ~3);
1008             if (n1 == 2)
1009                 break;
1010             tb1 = tb1->jmp_next[n1];
1011         }
1012         /* we are now sure now that tb jumps to tb1 */
1013         tb_next = tb1;
1014
1015         /* remove tb from the jmp_first list */
1016         ptb = &tb_next->jmp_first;
1017         for(;;) {
1018             tb1 = *ptb;
1019             n1 = (long)tb1 & 3;
1020             tb1 = (TranslationBlock *)((long)tb1 & ~3);
1021             if (n1 == n && tb1 == tb)
1022                 break;
1023             ptb = &tb1->jmp_next[n1];
1024         }
1025         *ptb = tb->jmp_next[n];
1026         tb->jmp_next[n] = NULL;
1027
1028         /* suppress the jump to next tb in generated code */
1029         tb_reset_jump(tb, n);
1030
1031         /* suppress jumps in the tb on which we could have jumped */
1032         tb_reset_jump_recursive(tb_next);
1033     }
1034 }
1035
1036 static void tb_reset_jump_recursive(TranslationBlock *tb)
1037 {
1038     tb_reset_jump_recursive2(tb, 0);
1039     tb_reset_jump_recursive2(tb, 1);
1040 }
1041
1042 #if defined(TARGET_HAS_ICE)
1043 static void breakpoint_invalidate(CPUState *env, target_ulong pc)
1044 {
1045     target_phys_addr_t addr;
1046     target_ulong pd;
1047     ram_addr_t ram_addr;
1048     PhysPageDesc *p;
1049
1050     addr = cpu_get_phys_page_debug(env, pc);
1051     p = phys_page_find(addr >> TARGET_PAGE_BITS);
1052     if (!p) {
1053         pd = IO_MEM_UNASSIGNED;
1054     } else {
1055         pd = p->phys_offset;
1056     }
1057     ram_addr = (pd & TARGET_PAGE_MASK) | (pc & ~TARGET_PAGE_MASK);
1058     tb_invalidate_phys_page_range(ram_addr, ram_addr + 1, 0);
1059 }
1060 #endif
1061
1062 /* Add a watchpoint.  */
1063 int  cpu_watchpoint_insert(CPUState *env, target_ulong addr)
1064 {
1065     int i;
1066
1067     for (i = 0; i < env->nb_watchpoints; i++) {
1068         if (addr == env->watchpoint[i].vaddr)
1069             return 0;
1070     }
1071     if (env->nb_watchpoints >= MAX_WATCHPOINTS)
1072         return -1;
1073
1074     i = env->nb_watchpoints++;
1075     env->watchpoint[i].vaddr = addr;
1076     tlb_flush_page(env, addr);
1077     /* FIXME: This flush is needed because of the hack to make memory ops
1078        terminate the TB.  It can be removed once the proper IO trap and
1079        re-execute bits are in.  */
1080     tb_flush(env);
1081     return i;
1082 }
1083
1084 /* Remove a watchpoint.  */
1085 int cpu_watchpoint_remove(CPUState *env, target_ulong addr)
1086 {
1087     int i;
1088
1089     for (i = 0; i < env->nb_watchpoints; i++) {
1090         if (addr == env->watchpoint[i].vaddr) {
1091             env->nb_watchpoints--;
1092             env->watchpoint[i] = env->watchpoint[env->nb_watchpoints];
1093             tlb_flush_page(env, addr);
1094             return 0;
1095         }
1096     }
1097     return -1;
1098 }
1099
1100 /* add a breakpoint. EXCP_DEBUG is returned by the CPU loop if a
1101    breakpoint is reached */
1102 int cpu_breakpoint_insert(CPUState *env, target_ulong pc)
1103 {
1104 #if defined(TARGET_HAS_ICE)
1105     int i;
1106
1107     for(i = 0; i < env->nb_breakpoints; i++) {
1108         if (env->breakpoints[i] == pc)
1109             return 0;
1110     }
1111
1112     if (env->nb_breakpoints >= MAX_BREAKPOINTS)
1113         return -1;
1114     env->breakpoints[env->nb_breakpoints++] = pc;
1115
1116     breakpoint_invalidate(env, pc);
1117     return 0;
1118 #else
1119     return -1;
1120 #endif
1121 }
1122
1123 /* remove a breakpoint */
1124 int cpu_breakpoint_remove(CPUState *env, target_ulong pc)
1125 {
1126 #if defined(TARGET_HAS_ICE)
1127     int i;
1128     for(i = 0; i < env->nb_breakpoints; i++) {
1129         if (env->breakpoints[i] == pc)
1130             goto found;
1131     }
1132     return -1;
1133  found:
1134     env->nb_breakpoints--;
1135     if (i < env->nb_breakpoints)
1136       env->breakpoints[i] = env->breakpoints[env->nb_breakpoints];
1137
1138     breakpoint_invalidate(env, pc);
1139     return 0;
1140 #else
1141     return -1;
1142 #endif
1143 }
1144
1145 /* enable or disable single step mode. EXCP_DEBUG is returned by the
1146    CPU loop after each instruction */
1147 void cpu_single_step(CPUState *env, int enabled)
1148 {
1149 #if defined(TARGET_HAS_ICE)
1150     if (env->singlestep_enabled != enabled) {
1151         env->singlestep_enabled = enabled;
1152         /* must flush all the translated code to avoid inconsistancies */
1153         /* XXX: only flush what is necessary */
1154         tb_flush(env);
1155     }
1156 #endif
1157 }
1158
1159 /* enable or disable low levels log */
1160 void cpu_set_log(int log_flags)
1161 {
1162     loglevel = log_flags;
1163     if (loglevel && !logfile) {
1164         logfile = fopen(logfilename, log_append ? "a" : "w");
1165         if (!logfile) {
1166             perror(logfilename);
1167             _exit(1);
1168         }
1169 #if !defined(CONFIG_SOFTMMU)
1170         /* must avoid mmap() usage of glibc by setting a buffer "by hand" */
1171         {
1172             static uint8_t logfile_buf[4096];
1173             setvbuf(logfile, logfile_buf, _IOLBF, sizeof(logfile_buf));
1174         }
1175 #else
1176         setvbuf(logfile, NULL, _IOLBF, 0);
1177 #endif
1178         log_append = 1;
1179     }
1180     if (!loglevel && logfile) {
1181         fclose(logfile);
1182         logfile = NULL;
1183     }
1184 }
1185
1186 void cpu_set_log_filename(const char *filename)
1187 {
1188     logfilename = strdup(filename);
1189     if (logfile) {
1190         fclose(logfile);
1191         logfile = NULL;
1192     }
1193     cpu_set_log(loglevel);
1194 }
1195
1196 /* mask must never be zero, except for A20 change call */
1197 void cpu_interrupt(CPUState *env, int mask)
1198 {
1199     TranslationBlock *tb;
1200     static int interrupt_lock;
1201
1202     env->interrupt_request |= mask;
1203     /* if the cpu is currently executing code, we must unlink it and
1204        all the potentially executing TB */
1205     tb = env->current_tb;
1206     if (tb && !testandset(&interrupt_lock)) {
1207         env->current_tb = NULL;
1208         tb_reset_jump_recursive(tb);
1209         interrupt_lock = 0;
1210     }
1211 }
1212
1213 void cpu_reset_interrupt(CPUState *env, int mask)
1214 {
1215     env->interrupt_request &= ~mask;
1216 }
1217
1218 CPULogItem cpu_log_items[] = {
1219     { CPU_LOG_TB_OUT_ASM, "out_asm",
1220       "show generated host assembly code for each compiled TB" },
1221     { CPU_LOG_TB_IN_ASM, "in_asm",
1222       "show target assembly code for each compiled TB" },
1223     { CPU_LOG_TB_OP, "op",
1224       "show micro ops for each compiled TB (only usable if 'in_asm' used)" },
1225 #ifdef TARGET_I386
1226     { CPU_LOG_TB_OP_OPT, "op_opt",
1227       "show micro ops after optimization for each compiled TB" },
1228 #endif
1229     { CPU_LOG_INT, "int",
1230       "show interrupts/exceptions in short format" },
1231     { CPU_LOG_EXEC, "exec",
1232       "show trace before each executed TB (lots of logs)" },
1233     { CPU_LOG_TB_CPU, "cpu",
1234       "show CPU state before block translation" },
1235 #ifdef TARGET_I386
1236     { CPU_LOG_PCALL, "pcall",
1237       "show protected mode far calls/returns/exceptions" },
1238 #endif
1239 #ifdef DEBUG_IOPORT
1240     { CPU_LOG_IOPORT, "ioport",
1241       "show all i/o ports accesses" },
1242 #endif
1243     { 0, NULL, NULL },
1244 };
1245
1246 static int cmp1(const char *s1, int n, const char *s2)
1247 {
1248     if (strlen(s2) != n)
1249         return 0;
1250     return memcmp(s1, s2, n) == 0;
1251 }
1252
1253 /* takes a comma separated list of log masks. Return 0 if error. */
1254 int cpu_str_to_log_mask(const char *str)
1255 {
1256     CPULogItem *item;
1257     int mask;
1258     const char *p, *p1;
1259
1260     p = str;
1261     mask = 0;
1262     for(;;) {
1263         p1 = strchr(p, ',');
1264         if (!p1)
1265             p1 = p + strlen(p);
1266         if(cmp1(p,p1-p,"all")) {
1267                 for(item = cpu_log_items; item->mask != 0; item++) {
1268                         mask |= item->mask;
1269                 }
1270         } else {
1271         for(item = cpu_log_items; item->mask != 0; item++) {
1272             if (cmp1(p, p1 - p, item->name))
1273                 goto found;
1274         }
1275         return 0;
1276         }
1277     found:
1278         mask |= item->mask;
1279         if (*p1 != ',')
1280             break;
1281         p = p1 + 1;
1282     }
1283     return mask;
1284 }
1285
1286 void cpu_abort(CPUState *env, const char *fmt, ...)
1287 {
1288     va_list ap;
1289
1290     va_start(ap, fmt);
1291     fprintf(stderr, "qemu: fatal: ");
1292     vfprintf(stderr, fmt, ap);
1293     fprintf(stderr, "\n");
1294 #ifdef TARGET_I386
1295     if(env->intercept & INTERCEPT_SVM_MASK) {
1296         /* most probably the virtual machine should not
1297            be shut down but rather caught by the VMM */
1298         vmexit(SVM_EXIT_SHUTDOWN, 0);
1299     }
1300     cpu_dump_state(env, stderr, fprintf, X86_DUMP_FPU | X86_DUMP_CCOP);
1301 #else
1302     cpu_dump_state(env, stderr, fprintf, 0);
1303 #endif
1304     if (logfile) {
1305         fprintf(logfile, "qemu: fatal: ");
1306         vfprintf(logfile, fmt, ap);
1307         fprintf(logfile, "\n");
1308 #ifdef TARGET_I386
1309         cpu_dump_state(env, logfile, fprintf, X86_DUMP_FPU | X86_DUMP_CCOP);
1310 #else
1311         cpu_dump_state(env, logfile, fprintf, 0);
1312 #endif
1313         fflush(logfile);
1314         fclose(logfile);
1315     }
1316     va_end(ap);
1317     abort();
1318 }
1319
1320 CPUState *cpu_copy(CPUState *env)
1321 {
1322     CPUState *new_env = cpu_init();
1323     /* preserve chaining and index */
1324     CPUState *next_cpu = new_env->next_cpu;
1325     int cpu_index = new_env->cpu_index;
1326     memcpy(new_env, env, sizeof(CPUState));
1327     new_env->next_cpu = next_cpu;
1328     new_env->cpu_index = cpu_index;
1329     return new_env;
1330 }
1331
1332 #if !defined(CONFIG_USER_ONLY)
1333
1334 /* NOTE: if flush_global is true, also flush global entries (not
1335    implemented yet) */
1336 void tlb_flush(CPUState *env, int flush_global)
1337 {
1338     int i;
1339
1340 #if defined(DEBUG_TLB)
1341     printf("tlb_flush:\n");
1342 #endif
1343     /* must reset current TB so that interrupts cannot modify the
1344        links while we are modifying them */
1345     env->current_tb = NULL;
1346
1347     for(i = 0; i < CPU_TLB_SIZE; i++) {
1348         env->tlb_table[0][i].addr_read = -1;
1349         env->tlb_table[0][i].addr_write = -1;
1350         env->tlb_table[0][i].addr_code = -1;
1351         env->tlb_table[1][i].addr_read = -1;
1352         env->tlb_table[1][i].addr_write = -1;
1353         env->tlb_table[1][i].addr_code = -1;
1354 #if (NB_MMU_MODES >= 3)
1355         env->tlb_table[2][i].addr_read = -1;
1356         env->tlb_table[2][i].addr_write = -1;
1357         env->tlb_table[2][i].addr_code = -1;
1358 #if (NB_MMU_MODES == 4)
1359         env->tlb_table[3][i].addr_read = -1;
1360         env->tlb_table[3][i].addr_write = -1;
1361         env->tlb_table[3][i].addr_code = -1;
1362 #endif
1363 #endif
1364     }
1365
1366     memset (env->tb_jmp_cache, 0, TB_JMP_CACHE_SIZE * sizeof (void *));
1367
1368 #if !defined(CONFIG_SOFTMMU)
1369     munmap((void *)MMAP_AREA_START, MMAP_AREA_END - MMAP_AREA_START);
1370 #endif
1371 #ifdef USE_KQEMU
1372     if (env->kqemu_enabled) {
1373         kqemu_flush(env, flush_global);
1374     }
1375 #endif
1376     tlb_flush_count++;
1377 }
1378
1379 static inline void tlb_flush_entry(CPUTLBEntry *tlb_entry, target_ulong addr)
1380 {
1381     if (addr == (tlb_entry->addr_read &
1382                  (TARGET_PAGE_MASK | TLB_INVALID_MASK)) ||
1383         addr == (tlb_entry->addr_write &
1384                  (TARGET_PAGE_MASK | TLB_INVALID_MASK)) ||
1385         addr == (tlb_entry->addr_code &
1386                  (TARGET_PAGE_MASK | TLB_INVALID_MASK))) {
1387         tlb_entry->addr_read = -1;
1388         tlb_entry->addr_write = -1;
1389         tlb_entry->addr_code = -1;
1390     }
1391 }
1392
1393 void tlb_flush_page(CPUState *env, target_ulong addr)
1394 {
1395     int i;
1396     TranslationBlock *tb;
1397
1398 #if defined(DEBUG_TLB)
1399     printf("tlb_flush_page: " TARGET_FMT_lx "\n", addr);
1400 #endif
1401     /* must reset current TB so that interrupts cannot modify the
1402        links while we are modifying them */
1403     env->current_tb = NULL;
1404
1405     addr &= TARGET_PAGE_MASK;
1406     i = (addr >> TARGET_PAGE_BITS) & (CPU_TLB_SIZE - 1);
1407     tlb_flush_entry(&env->tlb_table[0][i], addr);
1408     tlb_flush_entry(&env->tlb_table[1][i], addr);
1409 #if (NB_MMU_MODES >= 3)
1410     tlb_flush_entry(&env->tlb_table[2][i], addr);
1411 #if (NB_MMU_MODES == 4)
1412     tlb_flush_entry(&env->tlb_table[3][i], addr);
1413 #endif
1414 #endif
1415
1416     /* Discard jump cache entries for any tb which might potentially
1417        overlap the flushed page.  */
1418     i = tb_jmp_cache_hash_page(addr - TARGET_PAGE_SIZE);
1419     memset (&env->tb_jmp_cache[i], 0, TB_JMP_PAGE_SIZE * sizeof(tb));
1420
1421     i = tb_jmp_cache_hash_page(addr);
1422     memset (&env->tb_jmp_cache[i], 0, TB_JMP_PAGE_SIZE * sizeof(tb));
1423
1424 #if !defined(CONFIG_SOFTMMU)
1425     if (addr < MMAP_AREA_END)
1426         munmap((void *)addr, TARGET_PAGE_SIZE);
1427 #endif
1428 #ifdef USE_KQEMU
1429     if (env->kqemu_enabled) {
1430         kqemu_flush_page(env, addr);
1431     }
1432 #endif
1433 }
1434
1435 /* update the TLBs so that writes to code in the virtual page 'addr'
1436    can be detected */
1437 static void tlb_protect_code(ram_addr_t ram_addr)
1438 {
1439     cpu_physical_memory_reset_dirty(ram_addr,
1440                                     ram_addr + TARGET_PAGE_SIZE,
1441                                     CODE_DIRTY_FLAG);
1442 }
1443
1444 /* update the TLB so that writes in physical page 'phys_addr' are no longer
1445    tested for self modifying code */
1446 static void tlb_unprotect_code_phys(CPUState *env, ram_addr_t ram_addr,
1447                                     target_ulong vaddr)
1448 {
1449     phys_ram_dirty[ram_addr >> TARGET_PAGE_BITS] |= CODE_DIRTY_FLAG;
1450 }
1451
1452 static inline void tlb_reset_dirty_range(CPUTLBEntry *tlb_entry,
1453                                          unsigned long start, unsigned long length)
1454 {
1455     unsigned long addr;
1456     if ((tlb_entry->addr_write & ~TARGET_PAGE_MASK) == IO_MEM_RAM) {
1457         addr = (tlb_entry->addr_write & TARGET_PAGE_MASK) + tlb_entry->addend;
1458         if ((addr - start) < length) {
1459             tlb_entry->addr_write = (tlb_entry->addr_write & TARGET_PAGE_MASK) | IO_MEM_NOTDIRTY;
1460         }
1461     }
1462 }
1463
1464 void cpu_physical_memory_reset_dirty(ram_addr_t start, ram_addr_t end,
1465                                      int dirty_flags)
1466 {
1467     CPUState *env;
1468     unsigned long length, start1;
1469     int i, mask, len;
1470     uint8_t *p;
1471
1472     start &= TARGET_PAGE_MASK;
1473     end = TARGET_PAGE_ALIGN(end);
1474
1475     length = end - start;
1476     if (length == 0)
1477         return;
1478     len = length >> TARGET_PAGE_BITS;
1479 #ifdef USE_KQEMU
1480     /* XXX: should not depend on cpu context */
1481     env = first_cpu;
1482     if (env->kqemu_enabled) {
1483         ram_addr_t addr;
1484         addr = start;
1485         for(i = 0; i < len; i++) {
1486             kqemu_set_notdirty(env, addr);
1487             addr += TARGET_PAGE_SIZE;
1488         }
1489     }
1490 #endif
1491     mask = ~dirty_flags;
1492     p = phys_ram_dirty + (start >> TARGET_PAGE_BITS);
1493     for(i = 0; i < len; i++)
1494         p[i] &= mask;
1495
1496     /* we modify the TLB cache so that the dirty bit will be set again
1497        when accessing the range */
1498     start1 = start + (unsigned long)phys_ram_base;
1499     for(env = first_cpu; env != NULL; env = env->next_cpu) {
1500         for(i = 0; i < CPU_TLB_SIZE; i++)
1501             tlb_reset_dirty_range(&env->tlb_table[0][i], start1, length);
1502         for(i = 0; i < CPU_TLB_SIZE; i++)
1503             tlb_reset_dirty_range(&env->tlb_table[1][i], start1, length);
1504 #if (NB_MMU_MODES >= 3)
1505         for(i = 0; i < CPU_TLB_SIZE; i++)
1506             tlb_reset_dirty_range(&env->tlb_table[2][i], start1, length);
1507 #if (NB_MMU_MODES == 4)
1508         for(i = 0; i < CPU_TLB_SIZE; i++)
1509             tlb_reset_dirty_range(&env->tlb_table[3][i], start1, length);
1510 #endif
1511 #endif
1512     }
1513
1514 #if !defined(CONFIG_SOFTMMU)
1515     /* XXX: this is expensive */
1516     {
1517         VirtPageDesc *p;
1518         int j;
1519         target_ulong addr;
1520
1521         for(i = 0; i < L1_SIZE; i++) {
1522             p = l1_virt_map[i];
1523             if (p) {
1524                 addr = i << (TARGET_PAGE_BITS + L2_BITS);
1525                 for(j = 0; j < L2_SIZE; j++) {
1526                     if (p->valid_tag == virt_valid_tag &&
1527                         p->phys_addr >= start && p->phys_addr < end &&
1528                         (p->prot & PROT_WRITE)) {
1529                         if (addr < MMAP_AREA_END) {
1530                             mprotect((void *)addr, TARGET_PAGE_SIZE,
1531                                      p->prot & ~PROT_WRITE);
1532                         }
1533                     }
1534                     addr += TARGET_PAGE_SIZE;
1535                     p++;
1536                 }
1537             }
1538         }
1539     }
1540 #endif
1541 }
1542
1543 static inline void tlb_update_dirty(CPUTLBEntry *tlb_entry)
1544 {
1545     ram_addr_t ram_addr;
1546
1547     if ((tlb_entry->addr_write & ~TARGET_PAGE_MASK) == IO_MEM_RAM) {
1548         ram_addr = (tlb_entry->addr_write & TARGET_PAGE_MASK) +
1549             tlb_entry->addend - (unsigned long)phys_ram_base;
1550         if (!cpu_physical_memory_is_dirty(ram_addr)) {
1551             tlb_entry->addr_write |= IO_MEM_NOTDIRTY;
1552         }
1553     }
1554 }
1555
1556 /* update the TLB according to the current state of the dirty bits */
1557 void cpu_tlb_update_dirty(CPUState *env)
1558 {
1559     int i;
1560     for(i = 0; i < CPU_TLB_SIZE; i++)
1561         tlb_update_dirty(&env->tlb_table[0][i]);
1562     for(i = 0; i < CPU_TLB_SIZE; i++)
1563         tlb_update_dirty(&env->tlb_table[1][i]);
1564 #if (NB_MMU_MODES >= 3)
1565     for(i = 0; i < CPU_TLB_SIZE; i++)
1566         tlb_update_dirty(&env->tlb_table[2][i]);
1567 #if (NB_MMU_MODES == 4)
1568     for(i = 0; i < CPU_TLB_SIZE; i++)
1569         tlb_update_dirty(&env->tlb_table[3][i]);
1570 #endif
1571 #endif
1572 }
1573
1574 static inline void tlb_set_dirty1(CPUTLBEntry *tlb_entry,
1575                                   unsigned long start)
1576 {
1577     unsigned long addr;
1578     if ((tlb_entry->addr_write & ~TARGET_PAGE_MASK) == IO_MEM_NOTDIRTY) {
1579         addr = (tlb_entry->addr_write & TARGET_PAGE_MASK) + tlb_entry->addend;
1580         if (addr == start) {
1581             tlb_entry->addr_write = (tlb_entry->addr_write & TARGET_PAGE_MASK) | IO_MEM_RAM;
1582         }
1583     }
1584 }
1585
1586 /* update the TLB corresponding to virtual page vaddr and phys addr
1587    addr so that it is no longer dirty */
1588 static inline void tlb_set_dirty(CPUState *env,
1589                                  unsigned long addr, target_ulong vaddr)
1590 {
1591     int i;
1592
1593     addr &= TARGET_PAGE_MASK;
1594     i = (vaddr >> TARGET_PAGE_BITS) & (CPU_TLB_SIZE - 1);
1595     tlb_set_dirty1(&env->tlb_table[0][i], addr);
1596     tlb_set_dirty1(&env->tlb_table[1][i], addr);
1597 #if (NB_MMU_MODES >= 3)
1598     tlb_set_dirty1(&env->tlb_table[2][i], addr);
1599 #if (NB_MMU_MODES == 4)
1600     tlb_set_dirty1(&env->tlb_table[3][i], addr);
1601 #endif
1602 #endif
1603 }
1604
1605 /* add a new TLB entry. At most one entry for a given virtual address
1606    is permitted. Return 0 if OK or 2 if the page could not be mapped
1607    (can only happen in non SOFTMMU mode for I/O pages or pages
1608    conflicting with the host address space). */
1609 int tlb_set_page_exec(CPUState *env, target_ulong vaddr,
1610                       target_phys_addr_t paddr, int prot,
1611                       int is_user, int is_softmmu)
1612 {
1613     PhysPageDesc *p;
1614     unsigned long pd;
1615     unsigned int index;
1616     target_ulong address;
1617     target_phys_addr_t addend;
1618     int ret;
1619     CPUTLBEntry *te;
1620     int i;
1621
1622     p = phys_page_find(paddr >> TARGET_PAGE_BITS);
1623     if (!p) {
1624         pd = IO_MEM_UNASSIGNED;
1625     } else {
1626         pd = p->phys_offset;
1627     }
1628 #if defined(DEBUG_TLB)
1629     printf("tlb_set_page: vaddr=" TARGET_FMT_lx " paddr=0x%08x prot=%x u=%d smmu=%d pd=0x%08lx\n",
1630            vaddr, (int)paddr, prot, is_user, is_softmmu, pd);
1631 #endif
1632
1633     ret = 0;
1634 #if !defined(CONFIG_SOFTMMU)
1635     if (is_softmmu)
1636 #endif
1637     {
1638         if ((pd & ~TARGET_PAGE_MASK) > IO_MEM_ROM && !(pd & IO_MEM_ROMD)) {
1639             /* IO memory case */
1640             address = vaddr | pd;
1641             addend = paddr;
1642         } else {
1643             /* standard memory */
1644             address = vaddr;
1645             addend = (unsigned long)phys_ram_base + (pd & TARGET_PAGE_MASK);
1646         }
1647
1648         /* Make accesses to pages with watchpoints go via the
1649            watchpoint trap routines.  */
1650         for (i = 0; i < env->nb_watchpoints; i++) {
1651             if (vaddr == (env->watchpoint[i].vaddr & TARGET_PAGE_MASK)) {
1652                 if (address & ~TARGET_PAGE_MASK) {
1653                     env->watchpoint[i].addend = 0;
1654                     address = vaddr | io_mem_watch;
1655                 } else {
1656                     env->watchpoint[i].addend = pd - paddr +
1657                         (unsigned long) phys_ram_base;
1658                     /* TODO: Figure out how to make read watchpoints coexist
1659                        with code.  */
1660                     pd = (pd & TARGET_PAGE_MASK) | io_mem_watch | IO_MEM_ROMD;
1661                 }
1662             }
1663         }
1664
1665         index = (vaddr >> TARGET_PAGE_BITS) & (CPU_TLB_SIZE - 1);
1666         addend -= vaddr;
1667         te = &env->tlb_table[is_user][index];
1668         te->addend = addend;
1669         if (prot & PAGE_READ) {
1670             te->addr_read = address;
1671         } else {
1672             te->addr_read = -1;
1673         }
1674         if (prot & PAGE_EXEC) {
1675             te->addr_code = address;
1676         } else {
1677             te->addr_code = -1;
1678         }
1679         if (prot & PAGE_WRITE) {
1680             if ((pd & ~TARGET_PAGE_MASK) == IO_MEM_ROM ||
1681                 (pd & IO_MEM_ROMD)) {
1682                 /* write access calls the I/O callback */
1683                 te->addr_write = vaddr |
1684                     (pd & ~(TARGET_PAGE_MASK | IO_MEM_ROMD));
1685             } else if ((pd & ~TARGET_PAGE_MASK) == IO_MEM_RAM &&
1686                        !cpu_physical_memory_is_dirty(pd)) {
1687                 te->addr_write = vaddr | IO_MEM_NOTDIRTY;
1688             } else {
1689                 te->addr_write = address;
1690             }
1691         } else {
1692             te->addr_write = -1;
1693         }
1694     }
1695 #if !defined(CONFIG_SOFTMMU)
1696     else {
1697         if ((pd & ~TARGET_PAGE_MASK) > IO_MEM_ROM) {
1698             /* IO access: no mapping is done as it will be handled by the
1699                soft MMU */
1700             if (!(env->hflags & HF_SOFTMMU_MASK))
1701                 ret = 2;
1702         } else {
1703             void *map_addr;
1704
1705             if (vaddr >= MMAP_AREA_END) {
1706                 ret = 2;
1707             } else {
1708                 if (prot & PROT_WRITE) {
1709                     if ((pd & ~TARGET_PAGE_MASK) == IO_MEM_ROM ||
1710 #if defined(TARGET_HAS_SMC) || 1
1711                         first_tb ||
1712 #endif
1713                         ((pd & ~TARGET_PAGE_MASK) == IO_MEM_RAM &&
1714                          !cpu_physical_memory_is_dirty(pd))) {
1715                         /* ROM: we do as if code was inside */
1716                         /* if code is present, we only map as read only and save the
1717                            original mapping */
1718                         VirtPageDesc *vp;
1719
1720                         vp = virt_page_find_alloc(vaddr >> TARGET_PAGE_BITS, 1);
1721                         vp->phys_addr = pd;
1722                         vp->prot = prot;
1723                         vp->valid_tag = virt_valid_tag;
1724                         prot &= ~PAGE_WRITE;
1725                     }
1726                 }
1727                 map_addr = mmap((void *)vaddr, TARGET_PAGE_SIZE, prot,
1728                                 MAP_SHARED | MAP_FIXED, phys_ram_fd, (pd & TARGET_PAGE_MASK));
1729                 if (map_addr == MAP_FAILED) {
1730                     cpu_abort(env, "mmap failed when mapped physical address 0x%08x to virtual address 0x%08x\n",
1731                               paddr, vaddr);
1732                 }
1733             }
1734         }
1735     }
1736 #endif
1737     return ret;
1738 }
1739
1740 /* called from signal handler: invalidate the code and unprotect the
1741    page. Return TRUE if the fault was succesfully handled. */
1742 int page_unprotect(target_ulong addr, unsigned long pc, void *puc)
1743 {
1744 #if !defined(CONFIG_SOFTMMU)
1745     VirtPageDesc *vp;
1746
1747 #if defined(DEBUG_TLB)
1748     printf("page_unprotect: addr=0x%08x\n", addr);
1749 #endif
1750     addr &= TARGET_PAGE_MASK;
1751
1752     /* if it is not mapped, no need to worry here */
1753     if (addr >= MMAP_AREA_END)
1754         return 0;
1755     vp = virt_page_find(addr >> TARGET_PAGE_BITS);
1756     if (!vp)
1757         return 0;
1758     /* NOTE: in this case, validate_tag is _not_ tested as it
1759        validates only the code TLB */
1760     if (vp->valid_tag != virt_valid_tag)
1761         return 0;
1762     if (!(vp->prot & PAGE_WRITE))
1763         return 0;
1764 #if defined(DEBUG_TLB)
1765     printf("page_unprotect: addr=0x%08x phys_addr=0x%08x prot=%x\n",
1766            addr, vp->phys_addr, vp->prot);
1767 #endif
1768     if (mprotect((void *)addr, TARGET_PAGE_SIZE, vp->prot) < 0)
1769         cpu_abort(cpu_single_env, "error mprotect addr=0x%lx prot=%d\n",
1770                   (unsigned long)addr, vp->prot);
1771     /* set the dirty bit */
1772     phys_ram_dirty[vp->phys_addr >> TARGET_PAGE_BITS] = 0xff;
1773     /* flush the code inside */
1774     tb_invalidate_phys_page(vp->phys_addr, pc, puc);
1775     return 1;
1776 #else
1777     return 0;
1778 #endif
1779 }
1780
1781 #else
1782
1783 void tlb_flush(CPUState *env, int flush_global)
1784 {
1785 }
1786
1787 void tlb_flush_page(CPUState *env, target_ulong addr)
1788 {
1789 }
1790
1791 int tlb_set_page_exec(CPUState *env, target_ulong vaddr,
1792                       target_phys_addr_t paddr, int prot,
1793                       int is_user, int is_softmmu)
1794 {
1795     return 0;
1796 }
1797
1798 /* dump memory mappings */
1799 void page_dump(FILE *f)
1800 {
1801     unsigned long start, end;
1802     int i, j, prot, prot1;
1803     PageDesc *p;
1804
1805     fprintf(f, "%-8s %-8s %-8s %s\n",
1806             "start", "end", "size", "prot");
1807     start = -1;
1808     end = -1;
1809     prot = 0;
1810     for(i = 0; i <= L1_SIZE; i++) {
1811         if (i < L1_SIZE)
1812             p = l1_map[i];
1813         else
1814             p = NULL;
1815         for(j = 0;j < L2_SIZE; j++) {
1816             if (!p)
1817                 prot1 = 0;
1818             else
1819                 prot1 = p[j].flags;
1820             if (prot1 != prot) {
1821                 end = (i << (32 - L1_BITS)) | (j << TARGET_PAGE_BITS);
1822                 if (start != -1) {
1823                     fprintf(f, "%08lx-%08lx %08lx %c%c%c\n",
1824                             start, end, end - start,
1825                             prot & PAGE_READ ? 'r' : '-',
1826                             prot & PAGE_WRITE ? 'w' : '-',
1827                             prot & PAGE_EXEC ? 'x' : '-');
1828                 }
1829                 if (prot1 != 0)
1830                     start = end;
1831                 else
1832                     start = -1;
1833                 prot = prot1;
1834             }
1835             if (!p)
1836                 break;
1837         }
1838     }
1839 }
1840
1841 int page_get_flags(target_ulong address)
1842 {
1843     PageDesc *p;
1844
1845     p = page_find(address >> TARGET_PAGE_BITS);
1846     if (!p)
1847         return 0;
1848     return p->flags;
1849 }
1850
1851 /* modify the flags of a page and invalidate the code if
1852    necessary. The flag PAGE_WRITE_ORG is positionned automatically
1853    depending on PAGE_WRITE */
1854 void page_set_flags(target_ulong start, target_ulong end, int flags)
1855 {
1856     PageDesc *p;
1857     target_ulong addr;
1858
1859     start = start & TARGET_PAGE_MASK;
1860     end = TARGET_PAGE_ALIGN(end);
1861     if (flags & PAGE_WRITE)
1862         flags |= PAGE_WRITE_ORG;
1863     spin_lock(&tb_lock);
1864     for(addr = start; addr < end; addr += TARGET_PAGE_SIZE) {
1865         p = page_find_alloc(addr >> TARGET_PAGE_BITS);
1866         /* if the write protection is set, then we invalidate the code
1867            inside */
1868         if (!(p->flags & PAGE_WRITE) &&
1869             (flags & PAGE_WRITE) &&
1870             p->first_tb) {
1871             tb_invalidate_phys_page(addr, 0, NULL);
1872         }
1873         p->flags = flags;
1874     }
1875     spin_unlock(&tb_lock);
1876 }
1877
1878 /* called from signal handler: invalidate the code and unprotect the
1879    page. Return TRUE if the fault was succesfully handled. */
1880 int page_unprotect(target_ulong address, unsigned long pc, void *puc)
1881 {
1882     unsigned int page_index, prot, pindex;
1883     PageDesc *p, *p1;
1884     target_ulong host_start, host_end, addr;
1885
1886     host_start = address & qemu_host_page_mask;
1887     page_index = host_start >> TARGET_PAGE_BITS;
1888     p1 = page_find(page_index);
1889     if (!p1)
1890         return 0;
1891     host_end = host_start + qemu_host_page_size;
1892     p = p1;
1893     prot = 0;
1894     for(addr = host_start;addr < host_end; addr += TARGET_PAGE_SIZE) {
1895         prot |= p->flags;
1896         p++;
1897     }
1898     /* if the page was really writable, then we change its
1899        protection back to writable */
1900     if (prot & PAGE_WRITE_ORG) {
1901         pindex = (address - host_start) >> TARGET_PAGE_BITS;
1902         if (!(p1[pindex].flags & PAGE_WRITE)) {
1903             mprotect((void *)g2h(host_start), qemu_host_page_size,
1904                      (prot & PAGE_BITS) | PAGE_WRITE);
1905             p1[pindex].flags |= PAGE_WRITE;
1906             /* and since the content will be modified, we must invalidate
1907                the corresponding translated code. */
1908             tb_invalidate_phys_page(address, pc, puc);
1909 #ifdef DEBUG_TB_CHECK
1910             tb_invalidate_check(address);
1911 #endif
1912             return 1;
1913         }
1914     }
1915     return 0;
1916 }
1917
1918 /* call this function when system calls directly modify a memory area */
1919 /* ??? This should be redundant now we have lock_user.  */
1920 void page_unprotect_range(target_ulong data, target_ulong data_size)
1921 {
1922     target_ulong start, end, addr;
1923
1924     start = data;
1925     end = start + data_size;
1926     start &= TARGET_PAGE_MASK;
1927     end = TARGET_PAGE_ALIGN(end);
1928     for(addr = start; addr < end; addr += TARGET_PAGE_SIZE) {
1929         page_unprotect(addr, 0, NULL);
1930     }
1931 }
1932
1933 static inline void tlb_set_dirty(CPUState *env,
1934                                  unsigned long addr, target_ulong vaddr)
1935 {
1936 }
1937 #endif /* defined(CONFIG_USER_ONLY) */
1938
1939 static int subpage_register (subpage_t *mmio, uint32_t start, uint32_t end,
1940                              int memory);
1941 static void *subpage_init (target_phys_addr_t base, uint32_t *phys,
1942                            int orig_memory);
1943 #define CHECK_SUBPAGE(addr, start_addr, start_addr2, end_addr, end_addr2, \
1944                       need_subpage)                                     \
1945     do {                                                                \
1946         if (addr > start_addr)                                          \
1947             start_addr2 = 0;                                            \
1948         else {                                                          \
1949             start_addr2 = start_addr & ~TARGET_PAGE_MASK;               \
1950             if (start_addr2 > 0)                                        \
1951                 need_subpage = 1;                                       \
1952         }                                                               \
1953                                                                         \
1954         if ((start_addr + orig_size) - addr >= TARGET_PAGE_SIZE)        \
1955             end_addr2 = TARGET_PAGE_SIZE - 1;                           \
1956         else {                                                          \
1957             end_addr2 = (start_addr + orig_size - 1) & ~TARGET_PAGE_MASK; \
1958             if (end_addr2 < TARGET_PAGE_SIZE - 1)                       \
1959                 need_subpage = 1;                                       \
1960         }                                                               \
1961     } while (0)
1962
1963 /* register physical memory. 'size' must be a multiple of the target
1964    page size. If (phys_offset & ~TARGET_PAGE_MASK) != 0, then it is an
1965    io memory page */
1966 void cpu_register_physical_memory(target_phys_addr_t start_addr,
1967                                   unsigned long size,
1968                                   unsigned long phys_offset)
1969 {
1970     target_phys_addr_t addr, end_addr;
1971     PhysPageDesc *p;
1972     CPUState *env;
1973     unsigned long orig_size = size;
1974     void *subpage;
1975
1976     size = (size + TARGET_PAGE_SIZE - 1) & TARGET_PAGE_MASK;
1977     end_addr = start_addr + (target_phys_addr_t)size;
1978     for(addr = start_addr; addr != end_addr; addr += TARGET_PAGE_SIZE) {
1979         p = phys_page_find(addr >> TARGET_PAGE_BITS);
1980         if (p && p->phys_offset != IO_MEM_UNASSIGNED) {
1981             unsigned long orig_memory = p->phys_offset;
1982             target_phys_addr_t start_addr2, end_addr2;
1983             int need_subpage = 0;
1984
1985             CHECK_SUBPAGE(addr, start_addr, start_addr2, end_addr, end_addr2,
1986                           need_subpage);
1987             if (need_subpage) {
1988                 if (!(orig_memory & IO_MEM_SUBPAGE)) {
1989                     subpage = subpage_init((addr & TARGET_PAGE_MASK),
1990                                            &p->phys_offset, orig_memory);
1991                 } else {
1992                     subpage = io_mem_opaque[(orig_memory & ~TARGET_PAGE_MASK)
1993                                             >> IO_MEM_SHIFT];
1994                 }
1995                 subpage_register(subpage, start_addr2, end_addr2, phys_offset);
1996             } else {
1997                 p->phys_offset = phys_offset;
1998                 if ((phys_offset & ~TARGET_PAGE_MASK) <= IO_MEM_ROM ||
1999                     (phys_offset & IO_MEM_ROMD))
2000                     phys_offset += TARGET_PAGE_SIZE;
2001             }
2002         } else {
2003             p = phys_page_find_alloc(addr >> TARGET_PAGE_BITS, 1);
2004             p->phys_offset = phys_offset;
2005             if ((phys_offset & ~TARGET_PAGE_MASK) <= IO_MEM_ROM ||
2006                 (phys_offset & IO_MEM_ROMD))
2007                 phys_offset += TARGET_PAGE_SIZE;
2008             else {
2009                 target_phys_addr_t start_addr2, end_addr2;
2010                 int need_subpage = 0;
2011
2012                 CHECK_SUBPAGE(addr, start_addr, start_addr2, end_addr,
2013                               end_addr2, need_subpage);
2014
2015                 if (need_subpage) {
2016                     subpage = subpage_init((addr & TARGET_PAGE_MASK),
2017                                            &p->phys_offset, IO_MEM_UNASSIGNED);
2018                     subpage_register(subpage, start_addr2, end_addr2,
2019                                      phys_offset);
2020                 }
2021             }
2022         }
2023     }
2024
2025     /* since each CPU stores ram addresses in its TLB cache, we must
2026        reset the modified entries */
2027     /* XXX: slow ! */
2028     for(env = first_cpu; env != NULL; env = env->next_cpu) {
2029         tlb_flush(env, 1);
2030     }
2031 }
2032
2033 /* XXX: temporary until new memory mapping API */
2034 uint32_t cpu_get_physical_page_desc(target_phys_addr_t addr)
2035 {
2036     PhysPageDesc *p;
2037
2038     p = phys_page_find(addr >> TARGET_PAGE_BITS);
2039     if (!p)
2040         return IO_MEM_UNASSIGNED;
2041     return p->phys_offset;
2042 }
2043
2044 /* XXX: better than nothing */
2045 ram_addr_t qemu_ram_alloc(unsigned int size)
2046 {
2047     ram_addr_t addr;
2048     if ((phys_ram_alloc_offset + size) >= phys_ram_size) {
2049         fprintf(stderr, "Not enough memory (requested_size = %u, max memory = %d)\n",
2050                 size, phys_ram_size);
2051         abort();
2052     }
2053     addr = phys_ram_alloc_offset;
2054     phys_ram_alloc_offset = TARGET_PAGE_ALIGN(phys_ram_alloc_offset + size);
2055     return addr;
2056 }
2057
2058 void qemu_ram_free(ram_addr_t addr)
2059 {
2060 }
2061
2062 static uint32_t unassigned_mem_readb(void *opaque, target_phys_addr_t addr)
2063 {
2064 #ifdef DEBUG_UNASSIGNED
2065     printf("Unassigned mem read " TARGET_FMT_lx "\n", addr);
2066 #endif
2067 #ifdef TARGET_SPARC
2068     do_unassigned_access(addr, 0, 0, 0);
2069 #endif
2070     return 0;
2071 }
2072
2073 static void unassigned_mem_writeb(void *opaque, target_phys_addr_t addr, uint32_t val)
2074 {
2075 #ifdef DEBUG_UNASSIGNED
2076     printf("Unassigned mem write " TARGET_FMT_lx " = 0x%x\n", addr, val);
2077 #endif
2078 #ifdef TARGET_SPARC
2079     do_unassigned_access(addr, 1, 0, 0);
2080 #endif
2081 }
2082
2083 static CPUReadMemoryFunc *unassigned_mem_read[3] = {
2084     unassigned_mem_readb,
2085     unassigned_mem_readb,
2086     unassigned_mem_readb,
2087 };
2088
2089 static CPUWriteMemoryFunc *unassigned_mem_write[3] = {
2090     unassigned_mem_writeb,
2091     unassigned_mem_writeb,
2092     unassigned_mem_writeb,
2093 };
2094
2095 static void notdirty_mem_writeb(void *opaque, target_phys_addr_t addr, uint32_t val)
2096 {
2097     unsigned long ram_addr;
2098     int dirty_flags;
2099     ram_addr = addr - (unsigned long)phys_ram_base;
2100     dirty_flags = phys_ram_dirty[ram_addr >> TARGET_PAGE_BITS];
2101     if (!(dirty_flags & CODE_DIRTY_FLAG)) {
2102 #if !defined(CONFIG_USER_ONLY)
2103         tb_invalidate_phys_page_fast(ram_addr, 1);
2104         dirty_flags = phys_ram_dirty[ram_addr >> TARGET_PAGE_BITS];
2105 #endif
2106     }
2107     stb_p((uint8_t *)(long)addr, val);
2108 #ifdef USE_KQEMU
2109     if (cpu_single_env->kqemu_enabled &&
2110         (dirty_flags & KQEMU_MODIFY_PAGE_MASK) != KQEMU_MODIFY_PAGE_MASK)
2111         kqemu_modify_page(cpu_single_env, ram_addr);
2112 #endif
2113     dirty_flags |= (0xff & ~CODE_DIRTY_FLAG);
2114     phys_ram_dirty[ram_addr >> TARGET_PAGE_BITS] = dirty_flags;
2115     /* we remove the notdirty callback only if the code has been
2116        flushed */
2117     if (dirty_flags == 0xff)
2118         tlb_set_dirty(cpu_single_env, addr, cpu_single_env->mem_write_vaddr);
2119 }
2120
2121 static void notdirty_mem_writew(void *opaque, target_phys_addr_t addr, uint32_t val)
2122 {
2123     unsigned long ram_addr;
2124     int dirty_flags;
2125     ram_addr = addr - (unsigned long)phys_ram_base;
2126     dirty_flags = phys_ram_dirty[ram_addr >> TARGET_PAGE_BITS];
2127     if (!(dirty_flags & CODE_DIRTY_FLAG)) {
2128 #if !defined(CONFIG_USER_ONLY)
2129         tb_invalidate_phys_page_fast(ram_addr, 2);
2130         dirty_flags = phys_ram_dirty[ram_addr >> TARGET_PAGE_BITS];
2131 #endif
2132     }
2133     stw_p((uint8_t *)(long)addr, val);
2134 #ifdef USE_KQEMU
2135     if (cpu_single_env->kqemu_enabled &&
2136         (dirty_flags & KQEMU_MODIFY_PAGE_MASK) != KQEMU_MODIFY_PAGE_MASK)
2137         kqemu_modify_page(cpu_single_env, ram_addr);
2138 #endif
2139     dirty_flags |= (0xff & ~CODE_DIRTY_FLAG);
2140     phys_ram_dirty[ram_addr >> TARGET_PAGE_BITS] = dirty_flags;
2141     /* we remove the notdirty callback only if the code has been
2142        flushed */
2143     if (dirty_flags == 0xff)
2144         tlb_set_dirty(cpu_single_env, addr, cpu_single_env->mem_write_vaddr);
2145 }
2146
2147 static void notdirty_mem_writel(void *opaque, target_phys_addr_t addr, uint32_t val)
2148 {
2149     unsigned long ram_addr;
2150     int dirty_flags;
2151     ram_addr = addr - (unsigned long)phys_ram_base;
2152     dirty_flags = phys_ram_dirty[ram_addr >> TARGET_PAGE_BITS];
2153     if (!(dirty_flags & CODE_DIRTY_FLAG)) {
2154 #if !defined(CONFIG_USER_ONLY)
2155         tb_invalidate_phys_page_fast(ram_addr, 4);
2156         dirty_flags = phys_ram_dirty[ram_addr >> TARGET_PAGE_BITS];
2157 #endif
2158     }
2159     stl_p((uint8_t *)(long)addr, val);
2160 #ifdef USE_KQEMU
2161     if (cpu_single_env->kqemu_enabled &&
2162         (dirty_flags & KQEMU_MODIFY_PAGE_MASK) != KQEMU_MODIFY_PAGE_MASK)
2163         kqemu_modify_page(cpu_single_env, ram_addr);
2164 #endif
2165     dirty_flags |= (0xff & ~CODE_DIRTY_FLAG);
2166     phys_ram_dirty[ram_addr >> TARGET_PAGE_BITS] = dirty_flags;
2167     /* we remove the notdirty callback only if the code has been
2168        flushed */
2169     if (dirty_flags == 0xff)
2170         tlb_set_dirty(cpu_single_env, addr, cpu_single_env->mem_write_vaddr);
2171 }
2172
2173 static CPUReadMemoryFunc *error_mem_read[3] = {
2174     NULL, /* never used */
2175     NULL, /* never used */
2176     NULL, /* never used */
2177 };
2178
2179 static CPUWriteMemoryFunc *notdirty_mem_write[3] = {
2180     notdirty_mem_writeb,
2181     notdirty_mem_writew,
2182     notdirty_mem_writel,
2183 };
2184
2185 #if defined(CONFIG_SOFTMMU)
2186 /* Watchpoint access routines.  Watchpoints are inserted using TLB tricks,
2187    so these check for a hit then pass through to the normal out-of-line
2188    phys routines.  */
2189 static uint32_t watch_mem_readb(void *opaque, target_phys_addr_t addr)
2190 {
2191     return ldub_phys(addr);
2192 }
2193
2194 static uint32_t watch_mem_readw(void *opaque, target_phys_addr_t addr)
2195 {
2196     return lduw_phys(addr);
2197 }
2198
2199 static uint32_t watch_mem_readl(void *opaque, target_phys_addr_t addr)
2200 {
2201     return ldl_phys(addr);
2202 }
2203
2204 /* Generate a debug exception if a watchpoint has been hit.
2205    Returns the real physical address of the access.  addr will be a host
2206    address in case of a RAM location.  */
2207 static target_ulong check_watchpoint(target_phys_addr_t addr)
2208 {
2209     CPUState *env = cpu_single_env;
2210     target_ulong watch;
2211     target_ulong retaddr;
2212     int i;
2213
2214     retaddr = addr;
2215     for (i = 0; i < env->nb_watchpoints; i++) {
2216         watch = env->watchpoint[i].vaddr;
2217         if (((env->mem_write_vaddr ^ watch) & TARGET_PAGE_MASK) == 0) {
2218             retaddr = addr - env->watchpoint[i].addend;
2219             if (((addr ^ watch) & ~TARGET_PAGE_MASK) == 0) {
2220                 cpu_single_env->watchpoint_hit = i + 1;
2221                 cpu_interrupt(cpu_single_env, CPU_INTERRUPT_DEBUG);
2222                 break;
2223             }
2224         }
2225     }
2226     return retaddr;
2227 }
2228
2229 static void watch_mem_writeb(void *opaque, target_phys_addr_t addr,
2230                              uint32_t val)
2231 {
2232     addr = check_watchpoint(addr);
2233     stb_phys(addr, val);
2234 }
2235
2236 static void watch_mem_writew(void *opaque, target_phys_addr_t addr,
2237                              uint32_t val)
2238 {
2239     addr = check_watchpoint(addr);
2240     stw_phys(addr, val);
2241 }
2242
2243 static void watch_mem_writel(void *opaque, target_phys_addr_t addr,
2244                              uint32_t val)
2245 {
2246     addr = check_watchpoint(addr);
2247     stl_phys(addr, val);
2248 }
2249
2250 static CPUReadMemoryFunc *watch_mem_read[3] = {
2251     watch_mem_readb,
2252     watch_mem_readw,
2253     watch_mem_readl,
2254 };
2255
2256 static CPUWriteMemoryFunc *watch_mem_write[3] = {
2257     watch_mem_writeb,
2258     watch_mem_writew,
2259     watch_mem_writel,
2260 };
2261 #endif
2262
2263 static inline uint32_t subpage_readlen (subpage_t *mmio, target_phys_addr_t addr,
2264                                  unsigned int len)
2265 {
2266     CPUReadMemoryFunc **mem_read;
2267     uint32_t ret;
2268     unsigned int idx;
2269
2270     idx = SUBPAGE_IDX(addr - mmio->base);
2271 #if defined(DEBUG_SUBPAGE)
2272     printf("%s: subpage %p len %d addr " TARGET_FMT_plx " idx %d\n", __func__,
2273            mmio, len, addr, idx);
2274 #endif
2275     mem_read = mmio->mem_read[idx];
2276     ret = (*mem_read[len])(mmio->opaque[idx], addr);
2277
2278     return ret;
2279 }
2280
2281 static inline void subpage_writelen (subpage_t *mmio, target_phys_addr_t addr,
2282                               uint32_t value, unsigned int len)
2283 {
2284     CPUWriteMemoryFunc **mem_write;
2285     unsigned int idx;
2286
2287     idx = SUBPAGE_IDX(addr - mmio->base);
2288 #if defined(DEBUG_SUBPAGE)
2289     printf("%s: subpage %p len %d addr " TARGET_FMT_plx " idx %d value %08x\n", __func__,
2290            mmio, len, addr, idx, value);
2291 #endif
2292     mem_write = mmio->mem_write[idx];
2293     (*mem_write[len])(mmio->opaque[idx], addr, value);
2294 }
2295
2296 static uint32_t subpage_readb (void *opaque, target_phys_addr_t addr)
2297 {
2298 #if defined(DEBUG_SUBPAGE)
2299     printf("%s: addr " TARGET_FMT_plx "\n", __func__, addr);
2300 #endif
2301
2302     return subpage_readlen(opaque, addr, 0);
2303 }
2304
2305 static void subpage_writeb (void *opaque, target_phys_addr_t addr,
2306                             uint32_t value)
2307 {
2308 #if defined(DEBUG_SUBPAGE)
2309     printf("%s: addr " TARGET_FMT_plx " val %08x\n", __func__, addr, value);
2310 #endif
2311     subpage_writelen(opaque, addr, value, 0);
2312 }
2313
2314 static uint32_t subpage_readw (void *opaque, target_phys_addr_t addr)
2315 {
2316 #if defined(DEBUG_SUBPAGE)
2317     printf("%s: addr " TARGET_FMT_plx "\n", __func__, addr);
2318 #endif
2319
2320     return subpage_readlen(opaque, addr, 1);
2321 }
2322
2323 static void subpage_writew (void *opaque, target_phys_addr_t addr,
2324                             uint32_t value)
2325 {
2326 #if defined(DEBUG_SUBPAGE)
2327     printf("%s: addr " TARGET_FMT_plx " val %08x\n", __func__, addr, value);
2328 #endif
2329     subpage_writelen(opaque, addr, value, 1);
2330 }
2331
2332 static uint32_t subpage_readl (void *opaque, target_phys_addr_t addr)
2333 {
2334 #if defined(DEBUG_SUBPAGE)
2335     printf("%s: addr " TARGET_FMT_plx "\n", __func__, addr);
2336 #endif
2337
2338     return subpage_readlen(opaque, addr, 2);
2339 }
2340
2341 static void subpage_writel (void *opaque,
2342                          target_phys_addr_t addr, uint32_t value)
2343 {
2344 #if defined(DEBUG_SUBPAGE)
2345     printf("%s: addr " TARGET_FMT_plx " val %08x\n", __func__, addr, value);
2346 #endif
2347     subpage_writelen(opaque, addr, value, 2);
2348 }
2349
2350 static CPUReadMemoryFunc *subpage_read[] = {
2351     &subpage_readb,
2352     &subpage_readw,
2353     &subpage_readl,
2354 };
2355
2356 static CPUWriteMemoryFunc *subpage_write[] = {
2357     &subpage_writeb,
2358     &subpage_writew,
2359     &subpage_writel,
2360 };
2361
2362 static int subpage_register (subpage_t *mmio, uint32_t start, uint32_t end,
2363                              int memory)
2364 {
2365     int idx, eidx;
2366
2367     if (start >= TARGET_PAGE_SIZE || end >= TARGET_PAGE_SIZE)
2368         return -1;
2369     idx = SUBPAGE_IDX(start);
2370     eidx = SUBPAGE_IDX(end);
2371 #if defined(DEBUG_SUBPAGE)
2372     printf("%s: %p start %08x end %08x idx %08x eidx %08x mem %d\n", __func__,
2373            mmio, start, end, idx, eidx, memory);
2374 #endif
2375     memory >>= IO_MEM_SHIFT;
2376     for (; idx <= eidx; idx++) {
2377         mmio->mem_read[idx] = io_mem_read[memory];
2378         mmio->mem_write[idx] = io_mem_write[memory];
2379         mmio->opaque[idx] = io_mem_opaque[memory];
2380     }
2381
2382     return 0;
2383 }
2384
2385 static void *subpage_init (target_phys_addr_t base, uint32_t *phys,
2386                            int orig_memory)
2387 {
2388     subpage_t *mmio;
2389     int subpage_memory;
2390
2391     mmio = qemu_mallocz(sizeof(subpage_t));
2392     if (mmio != NULL) {
2393         mmio->base = base;
2394         subpage_memory = cpu_register_io_memory(0, subpage_read, subpage_write, mmio);
2395 #if defined(DEBUG_SUBPAGE)
2396         printf("%s: %p base " TARGET_FMT_plx " len %08x %d\n", __func__,
2397                mmio, base, TARGET_PAGE_SIZE, subpage_memory);
2398 #endif
2399         *phys = subpage_memory | IO_MEM_SUBPAGE;
2400         subpage_register(mmio, 0, TARGET_PAGE_SIZE - 1, orig_memory);
2401     }
2402
2403     return mmio;
2404 }
2405
2406 static void io_mem_init(void)
2407 {
2408     cpu_register_io_memory(IO_MEM_ROM >> IO_MEM_SHIFT, error_mem_read, unassigned_mem_write, NULL);
2409     cpu_register_io_memory(IO_MEM_UNASSIGNED >> IO_MEM_SHIFT, unassigned_mem_read, unassigned_mem_write, NULL);
2410     cpu_register_io_memory(IO_MEM_NOTDIRTY >> IO_MEM_SHIFT, error_mem_read, notdirty_mem_write, NULL);
2411     io_mem_nb = 5;
2412
2413 #if defined(CONFIG_SOFTMMU)
2414     io_mem_watch = cpu_register_io_memory(-1, watch_mem_read,
2415                                           watch_mem_write, NULL);
2416 #endif
2417     /* alloc dirty bits array */
2418     phys_ram_dirty = qemu_vmalloc(phys_ram_size >> TARGET_PAGE_BITS);
2419     memset(phys_ram_dirty, 0xff, phys_ram_size >> TARGET_PAGE_BITS);
2420 }
2421
2422 /* mem_read and mem_write are arrays of functions containing the
2423    function to access byte (index 0), word (index 1) and dword (index
2424    2). All functions must be supplied. If io_index is non zero, the
2425    corresponding io zone is modified. If it is zero, a new io zone is
2426    allocated. The return value can be used with
2427    cpu_register_physical_memory(). (-1) is returned if error. */
2428 int cpu_register_io_memory(int io_index,
2429                            CPUReadMemoryFunc **mem_read,
2430                            CPUWriteMemoryFunc **mem_write,
2431                            void *opaque)
2432 {
2433     int i;
2434
2435     if (io_index <= 0) {
2436         if (io_mem_nb >= IO_MEM_NB_ENTRIES)
2437             return -1;
2438         io_index = io_mem_nb++;
2439     } else {
2440         if (io_index >= IO_MEM_NB_ENTRIES)
2441             return -1;
2442     }
2443
2444     for(i = 0;i < 3; i++) {
2445         io_mem_read[io_index][i] = mem_read[i];
2446         io_mem_write[io_index][i] = mem_write[i];
2447     }
2448     io_mem_opaque[io_index] = opaque;
2449     return io_index << IO_MEM_SHIFT;
2450 }
2451
2452 CPUWriteMemoryFunc **cpu_get_io_memory_write(int io_index)
2453 {
2454     return io_mem_write[io_index >> IO_MEM_SHIFT];
2455 }
2456
2457 CPUReadMemoryFunc **cpu_get_io_memory_read(int io_index)
2458 {
2459     return io_mem_read[io_index >> IO_MEM_SHIFT];
2460 }
2461
2462 /* physical memory access (slow version, mainly for debug) */
2463 #if defined(CONFIG_USER_ONLY)
2464 void cpu_physical_memory_rw(target_phys_addr_t addr, uint8_t *buf,
2465                             int len, int is_write)
2466 {
2467     int l, flags;
2468     target_ulong page;
2469     void * p;
2470
2471     while (len > 0) {
2472         page = addr & TARGET_PAGE_MASK;
2473         l = (page + TARGET_PAGE_SIZE) - addr;
2474         if (l > len)
2475             l = len;
2476         flags = page_get_flags(page);
2477         if (!(flags & PAGE_VALID))
2478             return;
2479         if (is_write) {
2480             if (!(flags & PAGE_WRITE))
2481                 return;
2482             p = lock_user(addr, len, 0);
2483             memcpy(p, buf, len);
2484             unlock_user(p, addr, len);
2485         } else {
2486             if (!(flags & PAGE_READ))
2487                 return;
2488             p = lock_user(addr, len, 1);
2489             memcpy(buf, p, len);
2490             unlock_user(p, addr, 0);
2491         }
2492         len -= l;
2493         buf += l;
2494         addr += l;
2495     }
2496 }
2497
2498 #else
2499 void cpu_physical_memory_rw(target_phys_addr_t addr, uint8_t *buf,
2500                             int len, int is_write)
2501 {
2502     int l, io_index;
2503     uint8_t *ptr;
2504     uint32_t val;
2505     target_phys_addr_t page;
2506     unsigned long pd;
2507     PhysPageDesc *p;
2508
2509     while (len > 0) {
2510         page = addr & TARGET_PAGE_MASK;
2511         l = (page + TARGET_PAGE_SIZE) - addr;
2512         if (l > len)
2513             l = len;
2514         p = phys_page_find(page >> TARGET_PAGE_BITS);
2515         if (!p) {
2516             pd = IO_MEM_UNASSIGNED;
2517         } else {
2518             pd = p->phys_offset;
2519         }
2520
2521         if (is_write) {
2522             if ((pd & ~TARGET_PAGE_MASK) != IO_MEM_RAM) {
2523                 io_index = (pd >> IO_MEM_SHIFT) & (IO_MEM_NB_ENTRIES - 1);
2524                 /* XXX: could force cpu_single_env to NULL to avoid
2525                    potential bugs */
2526                 if (l >= 4 && ((addr & 3) == 0)) {
2527                     /* 32 bit write access */
2528                     val = ldl_p(buf);
2529                     io_mem_write[io_index][2](io_mem_opaque[io_index], addr, val);
2530                     l = 4;
2531                 } else if (l >= 2 && ((addr & 1) == 0)) {
2532                     /* 16 bit write access */
2533                     val = lduw_p(buf);
2534                     io_mem_write[io_index][1](io_mem_opaque[io_index], addr, val);
2535                     l = 2;
2536                 } else {
2537                     /* 8 bit write access */
2538                     val = ldub_p(buf);
2539                     io_mem_write[io_index][0](io_mem_opaque[io_index], addr, val);
2540                     l = 1;
2541                 }
2542             } else {
2543                 unsigned long addr1;
2544                 addr1 = (pd & TARGET_PAGE_MASK) + (addr & ~TARGET_PAGE_MASK);
2545                 /* RAM case */
2546                 ptr = phys_ram_base + addr1;
2547                 memcpy(ptr, buf, l);
2548                 if (!cpu_physical_memory_is_dirty(addr1)) {
2549                     /* invalidate code */
2550                     tb_invalidate_phys_page_range(addr1, addr1 + l, 0);
2551                     /* set dirty bit */
2552                     phys_ram_dirty[addr1 >> TARGET_PAGE_BITS] |=
2553                         (0xff & ~CODE_DIRTY_FLAG);
2554                 }
2555             }
2556         } else {
2557             if ((pd & ~TARGET_PAGE_MASK) > IO_MEM_ROM &&
2558                 !(pd & IO_MEM_ROMD)) {
2559                 /* I/O case */
2560                 io_index = (pd >> IO_MEM_SHIFT) & (IO_MEM_NB_ENTRIES - 1);
2561                 if (l >= 4 && ((addr & 3) == 0)) {
2562                     /* 32 bit read access */
2563                     val = io_mem_read[io_index][2](io_mem_opaque[io_index], addr);
2564                     stl_p(buf, val);
2565                     l = 4;
2566                 } else if (l >= 2 && ((addr & 1) == 0)) {
2567                     /* 16 bit read access */
2568                     val = io_mem_read[io_index][1](io_mem_opaque[io_index], addr);
2569                     stw_p(buf, val);
2570                     l = 2;
2571                 } else {
2572                     /* 8 bit read access */
2573                     val = io_mem_read[io_index][0](io_mem_opaque[io_index], addr);
2574                     stb_p(buf, val);
2575                     l = 1;
2576                 }
2577             } else {
2578                 /* RAM case */
2579                 ptr = phys_ram_base + (pd & TARGET_PAGE_MASK) +
2580                     (addr & ~TARGET_PAGE_MASK);
2581                 memcpy(buf, ptr, l);
2582             }
2583         }
2584         len -= l;
2585         buf += l;
2586         addr += l;
2587     }
2588 }
2589
2590 /* used for ROM loading : can write in RAM and ROM */
2591 void cpu_physical_memory_write_rom(target_phys_addr_t addr,
2592                                    const uint8_t *buf, int len)
2593 {
2594     int l;
2595     uint8_t *ptr;
2596     target_phys_addr_t page;
2597     unsigned long pd;
2598     PhysPageDesc *p;
2599
2600     while (len > 0) {
2601         page = addr & TARGET_PAGE_MASK;
2602         l = (page + TARGET_PAGE_SIZE) - addr;
2603         if (l > len)
2604             l = len;
2605         p = phys_page_find(page >> TARGET_PAGE_BITS);
2606         if (!p) {
2607             pd = IO_MEM_UNASSIGNED;
2608         } else {
2609             pd = p->phys_offset;
2610         }
2611
2612         if ((pd & ~TARGET_PAGE_MASK) != IO_MEM_RAM &&
2613             (pd & ~TARGET_PAGE_MASK) != IO_MEM_ROM &&
2614             !(pd & IO_MEM_ROMD)) {
2615             /* do nothing */
2616         } else {
2617             unsigned long addr1;
2618             addr1 = (pd & TARGET_PAGE_MASK) + (addr & ~TARGET_PAGE_MASK);
2619             /* ROM/RAM case */
2620             ptr = phys_ram_base + addr1;
2621             memcpy(ptr, buf, l);
2622         }
2623         len -= l;
2624         buf += l;
2625         addr += l;
2626     }
2627 }
2628
2629
2630 /* warning: addr must be aligned */
2631 uint32_t ldl_phys(target_phys_addr_t addr)
2632 {
2633     int io_index;
2634     uint8_t *ptr;
2635     uint32_t val;
2636     unsigned long pd;
2637     PhysPageDesc *p;
2638
2639     p = phys_page_find(addr >> TARGET_PAGE_BITS);
2640     if (!p) {
2641         pd = IO_MEM_UNASSIGNED;
2642     } else {
2643         pd = p->phys_offset;
2644     }
2645
2646     if ((pd & ~TARGET_PAGE_MASK) > IO_MEM_ROM &&
2647         !(pd & IO_MEM_ROMD)) {
2648         /* I/O case */
2649         io_index = (pd >> IO_MEM_SHIFT) & (IO_MEM_NB_ENTRIES - 1);
2650         val = io_mem_read[io_index][2](io_mem_opaque[io_index], addr);
2651     } else {
2652         /* RAM case */
2653         ptr = phys_ram_base + (pd & TARGET_PAGE_MASK) +
2654             (addr & ~TARGET_PAGE_MASK);
2655         val = ldl_p(ptr);
2656     }
2657     return val;
2658 }
2659
2660 /* warning: addr must be aligned */
2661 uint64_t ldq_phys(target_phys_addr_t addr)
2662 {
2663     int io_index;
2664     uint8_t *ptr;
2665     uint64_t val;
2666     unsigned long pd;
2667     PhysPageDesc *p;
2668
2669     p = phys_page_find(addr >> TARGET_PAGE_BITS);
2670     if (!p) {
2671         pd = IO_MEM_UNASSIGNED;
2672     } else {
2673         pd = p->phys_offset;
2674     }
2675
2676     if ((pd & ~TARGET_PAGE_MASK) > IO_MEM_ROM &&
2677         !(pd & IO_MEM_ROMD)) {
2678         /* I/O case */
2679         io_index = (pd >> IO_MEM_SHIFT) & (IO_MEM_NB_ENTRIES - 1);
2680 #ifdef TARGET_WORDS_BIGENDIAN
2681         val = (uint64_t)io_mem_read[io_index][2](io_mem_opaque[io_index], addr) << 32;
2682         val |= io_mem_read[io_index][2](io_mem_opaque[io_index], addr + 4);
2683 #else
2684         val = io_mem_read[io_index][2](io_mem_opaque[io_index], addr);
2685         val |= (uint64_t)io_mem_read[io_index][2](io_mem_opaque[io_index], addr + 4) << 32;
2686 #endif
2687     } else {
2688         /* RAM case */
2689         ptr = phys_ram_base + (pd & TARGET_PAGE_MASK) +
2690             (addr & ~TARGET_PAGE_MASK);
2691         val = ldq_p(ptr);
2692     }
2693     return val;
2694 }
2695
2696 /* XXX: optimize */
2697 uint32_t ldub_phys(target_phys_addr_t addr)
2698 {
2699     uint8_t val;
2700     cpu_physical_memory_read(addr, &val, 1);
2701     return val;
2702 }
2703
2704 /* XXX: optimize */
2705 uint32_t lduw_phys(target_phys_addr_t addr)
2706 {
2707     uint16_t val;
2708     cpu_physical_memory_read(addr, (uint8_t *)&val, 2);
2709     return tswap16(val);
2710 }
2711
2712 /* warning: addr must be aligned. The ram page is not masked as dirty
2713    and the code inside is not invalidated. It is useful if the dirty
2714    bits are used to track modified PTEs */
2715 void stl_phys_notdirty(target_phys_addr_t addr, uint32_t val)
2716 {
2717     int io_index;
2718     uint8_t *ptr;
2719     unsigned long pd;
2720     PhysPageDesc *p;
2721
2722     p = phys_page_find(addr >> TARGET_PAGE_BITS);
2723     if (!p) {
2724         pd = IO_MEM_UNASSIGNED;
2725     } else {
2726         pd = p->phys_offset;
2727     }
2728
2729     if ((pd & ~TARGET_PAGE_MASK) != IO_MEM_RAM) {
2730         io_index = (pd >> IO_MEM_SHIFT) & (IO_MEM_NB_ENTRIES - 1);
2731         io_mem_write[io_index][2](io_mem_opaque[io_index], addr, val);
2732     } else {
2733         ptr = phys_ram_base + (pd & TARGET_PAGE_MASK) +
2734             (addr & ~TARGET_PAGE_MASK);
2735         stl_p(ptr, val);
2736     }
2737 }
2738
2739 void stq_phys_notdirty(target_phys_addr_t addr, uint64_t val)
2740 {
2741     int io_index;
2742     uint8_t *ptr;
2743     unsigned long pd;
2744     PhysPageDesc *p;
2745
2746     p = phys_page_find(addr >> TARGET_PAGE_BITS);
2747     if (!p) {
2748         pd = IO_MEM_UNASSIGNED;
2749     } else {
2750         pd = p->phys_offset;
2751     }
2752
2753     if ((pd & ~TARGET_PAGE_MASK) != IO_MEM_RAM) {
2754         io_index = (pd >> IO_MEM_SHIFT) & (IO_MEM_NB_ENTRIES - 1);
2755 #ifdef TARGET_WORDS_BIGENDIAN
2756         io_mem_write[io_index][2](io_mem_opaque[io_index], addr, val >> 32);
2757         io_mem_write[io_index][2](io_mem_opaque[io_index], addr + 4, val);
2758 #else
2759         io_mem_write[io_index][2](io_mem_opaque[io_index], addr, val);
2760         io_mem_write[io_index][2](io_mem_opaque[io_index], addr + 4, val >> 32);
2761 #endif
2762     } else {
2763         ptr = phys_ram_base + (pd & TARGET_PAGE_MASK) +
2764             (addr & ~TARGET_PAGE_MASK);
2765         stq_p(ptr, val);
2766     }
2767 }
2768
2769 /* warning: addr must be aligned */
2770 void stl_phys(target_phys_addr_t addr, uint32_t val)
2771 {
2772     int io_index;
2773     uint8_t *ptr;
2774     unsigned long pd;
2775     PhysPageDesc *p;
2776
2777     p = phys_page_find(addr >> TARGET_PAGE_BITS);
2778     if (!p) {
2779         pd = IO_MEM_UNASSIGNED;
2780     } else {
2781         pd = p->phys_offset;
2782     }
2783
2784     if ((pd & ~TARGET_PAGE_MASK) != IO_MEM_RAM) {
2785         io_index = (pd >> IO_MEM_SHIFT) & (IO_MEM_NB_ENTRIES - 1);
2786         io_mem_write[io_index][2](io_mem_opaque[io_index], addr, val);
2787     } else {
2788         unsigned long addr1;
2789         addr1 = (pd & TARGET_PAGE_MASK) + (addr & ~TARGET_PAGE_MASK);
2790         /* RAM case */
2791         ptr = phys_ram_base + addr1;
2792         stl_p(ptr, val);
2793         if (!cpu_physical_memory_is_dirty(addr1)) {
2794             /* invalidate code */
2795             tb_invalidate_phys_page_range(addr1, addr1 + 4, 0);
2796             /* set dirty bit */
2797             phys_ram_dirty[addr1 >> TARGET_PAGE_BITS] |=
2798                 (0xff & ~CODE_DIRTY_FLAG);
2799         }
2800     }
2801 }
2802
2803 /* XXX: optimize */
2804 void stb_phys(target_phys_addr_t addr, uint32_t val)
2805 {
2806     uint8_t v = val;
2807     cpu_physical_memory_write(addr, &v, 1);
2808 }
2809
2810 /* XXX: optimize */
2811 void stw_phys(target_phys_addr_t addr, uint32_t val)
2812 {
2813     uint16_t v = tswap16(val);
2814     cpu_physical_memory_write(addr, (const uint8_t *)&v, 2);
2815 }
2816
2817 /* XXX: optimize */
2818 void stq_phys(target_phys_addr_t addr, uint64_t val)
2819 {
2820     val = tswap64(val);
2821     cpu_physical_memory_write(addr, (const uint8_t *)&val, 8);
2822 }
2823
2824 #endif
2825
2826 /* virtual memory access for debug */
2827 int cpu_memory_rw_debug(CPUState *env, target_ulong addr,
2828                         uint8_t *buf, int len, int is_write)
2829 {
2830     int l;
2831     target_phys_addr_t phys_addr;
2832     target_ulong page;
2833
2834     while (len > 0) {
2835         page = addr & TARGET_PAGE_MASK;
2836         phys_addr = cpu_get_phys_page_debug(env, page);
2837         /* if no physical page mapped, return an error */
2838         if (phys_addr == -1)
2839             return -1;
2840         l = (page + TARGET_PAGE_SIZE) - addr;
2841         if (l > len)
2842             l = len;
2843         cpu_physical_memory_rw(phys_addr + (addr & ~TARGET_PAGE_MASK),
2844                                buf, l, is_write);
2845         len -= l;
2846         buf += l;
2847         addr += l;
2848     }
2849     return 0;
2850 }
2851
2852 void dump_exec_info(FILE *f,
2853                     int (*cpu_fprintf)(FILE *f, const char *fmt, ...))
2854 {
2855     int i, target_code_size, max_target_code_size;
2856     int direct_jmp_count, direct_jmp2_count, cross_page;
2857     TranslationBlock *tb;
2858
2859     target_code_size = 0;
2860     max_target_code_size = 0;
2861     cross_page = 0;
2862     direct_jmp_count = 0;
2863     direct_jmp2_count = 0;
2864     for(i = 0; i < nb_tbs; i++) {
2865         tb = &tbs[i];
2866         target_code_size += tb->size;
2867         if (tb->size > max_target_code_size)
2868             max_target_code_size = tb->size;
2869         if (tb->page_addr[1] != -1)
2870             cross_page++;
2871         if (tb->tb_next_offset[0] != 0xffff) {
2872             direct_jmp_count++;
2873             if (tb->tb_next_offset[1] != 0xffff) {
2874                 direct_jmp2_count++;
2875             }
2876         }
2877     }
2878     /* XXX: avoid using doubles ? */
2879     cpu_fprintf(f, "TB count            %d\n", nb_tbs);
2880     cpu_fprintf(f, "TB avg target size  %d max=%d bytes\n",
2881                 nb_tbs ? target_code_size / nb_tbs : 0,
2882                 max_target_code_size);
2883     cpu_fprintf(f, "TB avg host size    %d bytes (expansion ratio: %0.1f)\n",
2884                 nb_tbs ? (code_gen_ptr - code_gen_buffer) / nb_tbs : 0,
2885                 target_code_size ? (double) (code_gen_ptr - code_gen_buffer) / target_code_size : 0);
2886     cpu_fprintf(f, "cross page TB count %d (%d%%)\n",
2887             cross_page,
2888             nb_tbs ? (cross_page * 100) / nb_tbs : 0);
2889     cpu_fprintf(f, "direct jump count   %d (%d%%) (2 jumps=%d %d%%)\n",
2890                 direct_jmp_count,
2891                 nb_tbs ? (direct_jmp_count * 100) / nb_tbs : 0,
2892                 direct_jmp2_count,
2893                 nb_tbs ? (direct_jmp2_count * 100) / nb_tbs : 0);
2894     cpu_fprintf(f, "TB flush count      %d\n", tb_flush_count);
2895     cpu_fprintf(f, "TB invalidate count %d\n", tb_phys_invalidate_count);
2896     cpu_fprintf(f, "TLB flush count     %d\n", tlb_flush_count);
2897 }
2898
2899 #if !defined(CONFIG_USER_ONLY)
2900
2901 #define MMUSUFFIX _cmmu
2902 #define GETPC() NULL
2903 #define env cpu_single_env
2904 #define SOFTMMU_CODE_ACCESS
2905
2906 #define SHIFT 0
2907 #include "softmmu_template.h"
2908
2909 #define SHIFT 1
2910 #include "softmmu_template.h"
2911
2912 #define SHIFT 2
2913 #include "softmmu_template.h"
2914
2915 #define SHIFT 3
2916 #include "softmmu_template.h"
2917
2918 #undef env
2919
2920 #endif