Changeset 36140 in vbox for trunk/src/recompiler/exec.c

Timestamp:

Mar 3, 2011 1:48:16 PM (14 years ago)

Author:

vboxsync

Message:

rem: Re-synced to ​svn://svn.savannah.nongnu.org/qemu/trunk@5495 (repo UUID c046a42c-6fe2-441c-8c8c-71466251a162).

File:

• trunk/src/recompiler/exec.c (modified) (61 diffs)

trunk/src/recompiler/exec.c

@@ -31 +31 @@
 #ifndef VBOX
 #ifdef _WIN32
+#define WIN32_LEAN_AND_MEAN
 #include <windows.h>
 #else
@@ -54 +55 @@
 #include "cpu.h"
 #include "exec-all.h"
+#include "qemu-common.h"
+#include "tcg.h"
+#ifndef VBOX
+#include "hw/hw.h"
+#endif
+#include "osdep.h"
 #if defined(CONFIG_USER_ONLY)
 #include <qemu.h>
@@ -66 +73 @@
 //#define DEBUG_TB_CHECK
 //#define DEBUG_TLB_CHECK
+
+//#define DEBUG_IOPORT
+//#define DEBUG_SUBPAGE
 
 #if !defined(CONFIG_USER_ONLY)
@@ -114 +124 @@
     __attribute__((aligned (32)))
 #endif
+
 uint8_t code_gen_prologue[1024] code_gen_section;
-
 #else /* VBOX */
 extern uint8_t* code_gen_prologue;
 #endif /* VBOX */
-
 static uint8_t *code_gen_buffer;
 static unsigned long code_gen_buffer_size;
@@ -171 +180 @@
 
 typedef struct PhysPageDesc {
-    /* offset in host memory of the page + io_index in the low 12 bits */
+    /* offset in host memory of the page + io_index in the low bits */
     ram_addr_t phys_offset;
 } PhysPageDesc;
@@ -194 +203 @@
 #define L1_SIZE (1 << L1_BITS)
 #define L2_SIZE (1 << L2_BITS)
-
-static void io_mem_init(void);
 
 unsigned long qemu_real_host_page_size;
@@ -252 +259 @@
 } subpage_t;
 
-
 #ifndef VBOX
 #ifdef _WIN32
@@ -279 +285 @@
 }
 #endif
-#else // VBOX
+#else /* VBOX */
 static void map_exec(void *addr, long size)
 {
@@ -285 +291 @@
                  RTMEM_PROT_EXEC | RTMEM_PROT_READ | RTMEM_PROT_WRITE);
 }
-#endif
+#endif /* VBOX */
 
 static void page_init(void)
@@ -325 +331 @@
     memset(l1_phys_map, 0, L1_SIZE * sizeof(void *));
 #endif
+
 #ifdef VBOX
     /* We use other means to set reserved bit on our pages */
-#else
+#else  /* !VBOX */
 #if !defined(_WIN32) && defined(CONFIG_USER_ONLY)
     {
@@ -355 +362 @@
     }
 #endif
-#endif
+#endif /* !VBOX */
 }
 
@@ -498 +505 @@
 #endif
 
-#ifdef VBOX
-/*
- * We don't need such huge codegen buffer size, as execute most of the code
- * in raw or hwacc mode
- */
+#ifdef VBOX /*  We don't need such huge codegen buffer size, as execute
+                most of the code  in raw or hwacc mode. */
 #define DEFAULT_CODE_GEN_BUFFER_SIZE (8 * 1024 * 1024)
-#else
+#else  /* !VBOX */
 #define DEFAULT_CODE_GEN_BUFFER_SIZE (32 * 1024 * 1024)
-#endif
+#endif /* !VBOX */
 
 #if defined(CONFIG_USER_ONLY)
-/* Currently it is not recommended to allocate big chunks of data in
+/* Currently it is not recommanded to allocate big chunks of data in
    user mode. It will change when a dedicated libc will be used */
 #define USE_STATIC_CODE_GEN_BUFFER
@@ -829 +833 @@
     }
 }
-#endif // DEBUG_TB_CHECK
+
+#endif
 
 /* invalidate one TB */
@@ -956 +961 @@
 
 #ifdef VBOX
+
 void tb_invalidate_virt(CPUState *env, uint32_t eip)
 {
@@ -998 +1004 @@
 }
 # endif /* VBOX_STRICT */
+
 #endif /* VBOX */
 
@@ -1032 +1039 @@
     TranslationBlock *tb;
 
-    p->code_bitmap = qemu_malloc(TARGET_PAGE_SIZE / 8);
+    p->code_bitmap = qemu_mallocz(TARGET_PAGE_SIZE / 8);
     if (!p->code_bitmap)
         return;
-    memset(p->code_bitmap, 0, TARGET_PAGE_SIZE / 8);
 
     tb = p->first_tb;
@@ -1516 +1522 @@
 static void breakpoint_invalidate(CPUState *env, target_ulong pc)
 {
-    target_ulong addr, pd;
+    target_phys_addr_t addr;
+    target_ulong pd;
     ram_addr_t ram_addr;
     PhysPageDesc *p;
@@ -1644 +1651 @@
     if (env->singlestep_enabled != enabled) {
         env->singlestep_enabled = enabled;
-        /* must flush all the translated code to avoid inconsistencies */
+        /* must flush all the translated code to avoid inconsistancies */
         /* XXX: only flush what is necessary */
         tb_flush(env);
@@ -1657 +1664 @@
     loglevel = log_flags;
     if (loglevel && !logfile) {
-        logfile = fopen(logfilename, "w");
+        logfile = fopen(logfilename, log_append ? "a" : "w");
         if (!logfile) {
             perror(logfilename);
@@ -1665 +1672 @@
         /* must avoid mmap() usage of glibc by setting a buffer "by hand" */
         {
-            static uint8_t logfile_buf[4096];
+            static char logfile_buf[4096];
             setvbuf(logfile, logfile_buf, _IOLBF, sizeof(logfile_buf));
         }
@@ -1671 +1678 @@
         setvbuf(logfile, NULL, _IOLBF, 0);
 #endif
+        log_append = 1;
+    }
+    if (!loglevel && logfile) {
+        fclose(logfile);
+        logfile = NULL;
     }
 }
@@ -1677 +1689 @@
 {
     logfilename = strdup(filename);
+    if (logfile) {
+        fclose(logfile);
+        logfile = NULL;
+    }
+    cpu_set_log(loglevel);
 }
 #endif /* !VBOX */
@@ -1747 +1764 @@
       "show target assembly code for each compiled TB" },
     { CPU_LOG_TB_OP, "op",
-      "show micro ops for each compiled TB (only usable if 'in_asm' used)" },
+      "show micro ops for each compiled TB" },
+    { CPU_LOG_TB_OP_OPT, "op_opt",
+      "show micro ops "
 #ifdef TARGET_I386
-    { CPU_LOG_TB_OP_OPT, "op_opt",
-      "show micro ops after optimization for each compiled TB" },
-#endif
+      "before eflags optimization and "
+#endif
+      "after liveness analysis" },
     { CPU_LOG_INT, "int",
       "show interrupts/exceptions in short format" },
@@ -1757 +1776 @@
       "show trace before each executed TB (lots of logs)" },
     { CPU_LOG_TB_CPU, "cpu",
-      "show CPU state before bloc translation" },
+      "show CPU state before block translation" },
 #ifdef TARGET_I386
     { CPU_LOG_PCALL, "pcall",
@@ -1779 +1798 @@
 int cpu_str_to_log_mask(const char *str)
 {
-    CPULogItem *item;
+    const CPULogItem *item;
     int mask;
     const char *p, *p1;
@@ -1814 +1833 @@
 {
     va_list ap;
+    va_list ap2;
 
     va_start(ap, fmt);
+    va_copy(ap2, ap);
     fprintf(stderr, "qemu: fatal: ");
     vfprintf(stderr, fmt, ap);
@@ -1824 +1845 @@
     cpu_dump_state(env, stderr, fprintf, 0);
 #endif
+    if (logfile) {
+        fprintf(logfile, "qemu: fatal: ");
+        vfprintf(logfile, fmt, ap2);
+        fprintf(logfile, "\n");
+#ifdef TARGET_I386
+        cpu_dump_state(env, logfile, fprintf, X86_DUMP_FPU | X86_DUMP_CCOP);
+#else
+        cpu_dump_state(env, logfile, fprintf, 0);
+#endif
+        fflush(logfile);
+        fclose(logfile);
+    }
+    va_end(ap2);
     va_end(ap);
     abort();
@@ -1841 +1875 @@
     return new_env;
 }
-#endif
+#endif /* !VBOX */
 
 #if !defined(CONFIG_USER_ONLY)
@@ -1865 +1899 @@
 }
 
+#ifdef VBOX
 static CPUTLBEntry s_cputlb_empty_entry = {
     .addr_read  = -1,
@@ -1871 +1906 @@
     .addend     = -1,
 };
+#endif /* VBOX */
 
 /* NOTE: if flush_global is true, also flush global entries (not
@@ -1886 +1922 @@
 
     for(i = 0; i < CPU_TLB_SIZE; i++) {
+#ifdef VBOX
         int mmu_idx;
         for (mmu_idx = 0; mmu_idx < NB_MMU_MODES; mmu_idx++) {
             env->tlb_table[mmu_idx][i] = s_cputlb_empty_entry;
         }
+#else  /* !VBOX */
+        env->tlb_table[0][i].addr_read = -1;
+        env->tlb_table[0][i].addr_write = -1;
+        env->tlb_table[0][i].addr_code = -1;
+        env->tlb_table[1][i].addr_read = -1;
+        env->tlb_table[1][i].addr_write = -1;
+        env->tlb_table[1][i].addr_code = -1;
+#if (NB_MMU_MODES >= 3)
+        env->tlb_table[2][i].addr_read = -1;
+        env->tlb_table[2][i].addr_write = -1;
+        env->tlb_table[2][i].addr_code = -1;
+#if (NB_MMU_MODES == 4)
+        env->tlb_table[3][i].addr_read = -1;
+        env->tlb_table[3][i].addr_write = -1;
+        env->tlb_table[3][i].addr_code = -1;
+#endif
+#endif
+#endif /* !VBOX */
     }
 
@@ -1987 +2042 @@
         addr = (tlb_entry->addr_write & TARGET_PAGE_MASK) + tlb_entry->addend;
         if ((addr - start) < length) {
-            tlb_entry->addr_write = (tlb_entry->addr_write & TARGET_PAGE_MASK) | IO_MEM_NOTDIRTY;
+            tlb_entry->addr_write = (tlb_entry->addr_write & TARGET_PAGE_MASK) | TLB_NOTDIRTY;
         }
     }
@@ -2129 +2184 @@
 }
 
-
-/* update the TLB corresponding to virtual page vaddr and phys addr
-   addr so that it is no longer dirty */
-static inline void tlb_set_dirty(CPUState *env,
-                                 unsigned long addr, target_ulong vaddr)
+/* update the TLB corresponding to virtual page vaddr
+   so that it is no longer dirty */
+static inline void tlb_set_dirty(CPUState *env, target_ulong vaddr)
 {
     int i;
 
-    addr &= TARGET_PAGE_MASK;
+    vaddr &= TARGET_PAGE_MASK;
     i = (vaddr >> TARGET_PAGE_BITS) & (CPU_TLB_SIZE - 1);
-    tlb_set_dirty1(&env->tlb_table[0][i], addr);
-    tlb_set_dirty1(&env->tlb_table[1][i], addr);
+    tlb_set_dirty1(&env->tlb_table[0][i], vaddr);
+    tlb_set_dirty1(&env->tlb_table[1][i], vaddr);
 #if (NB_MMU_MODES >= 3)
     tlb_set_dirty1(&env->tlb_table[2][i], vaddr);
@@ -2302 +2355 @@
     return ret;
 }
-#if 0
-/* called from signal handler: invalidate the code and unprotect the
-   page. Return TRUE if the fault was successfully handled. */
-int page_unprotect(target_ulong addr, unsigned long pc, void *puc)
-{
-#if !defined(CONFIG_SOFTMMU)
-    VirtPageDesc *vp;
-
-#if defined(DEBUG_TLB)
-    printf("page_unprotect: addr=0x%08x\n", addr);
-#endif
-    addr &= TARGET_PAGE_MASK;
-
-    /* if it is not mapped, no need to worry here */
-    if (addr >= MMAP_AREA_END)
-        return 0;
-    vp = virt_page_find(addr >> TARGET_PAGE_BITS);
-    if (!vp)
-        return 0;
-    /* NOTE: in this case, validate_tag is _not_ tested as it
-       validates only the code TLB */
-    if (vp->valid_tag != virt_valid_tag)
-        return 0;
-    if (!(vp->prot & PAGE_WRITE))
-        return 0;
-#if defined(DEBUG_TLB)
-    printf("page_unprotect: addr=0x%08x phys_addr=0x%08x prot=%x\n",
-           addr, vp->phys_addr, vp->prot);
-#endif
-    if (mprotect((void *)addr, TARGET_PAGE_SIZE, vp->prot) < 0)
-        cpu_abort(cpu_single_env, "error mprotect addr=0x%lx prot=%d\n",
-                  (unsigned long)addr, vp->prot);
-    /* set the dirty bit */
-    phys_ram_dirty[vp->phys_addr >> TARGET_PAGE_BITS] = 0xff;
-    /* flush the code inside */
-    tb_invalidate_phys_page(vp->phys_addr, pc, puc);
-    return 1;
-#elif defined(VBOX)
-    addr &= TARGET_PAGE_MASK;
-
-    /* if it is not mapped, no need to worry here */
-    if (addr >= MMAP_AREA_END)
-        return 0;
-    return 1;
-#else
-    return 0;
-#endif
-}
-#endif /* 0 */
 
 #else
@@ -2425 +2429 @@
 
 /* modify the flags of a page and invalidate the code if
-   necessary. The flag PAGE_WRITE_ORG is positioned automatically
+   necessary. The flag PAGE_WRITE_ORG is positionned automatically
    depending on PAGE_WRITE */
 void page_set_flags(target_ulong start, target_ulong end, int flags)
@@ -2432 +2436 @@
     target_ulong addr;
 
+    /* mmap_lock should already be held.  */
     start = start & TARGET_PAGE_MASK;
     end = TARGET_PAGE_ALIGN(end);
@@ -2439 +2444 @@
     AssertMsgFailed(("We shouldn't be here, and if we should, we must have an env to do the proper locking!\n"));
 #endif
-    spin_lock(&tb_lock);
     for(addr = start; addr < end; addr += TARGET_PAGE_SIZE) {
         p = page_find_alloc(addr >> TARGET_PAGE_BITS);
+        /* We may be called for host regions that are outside guest
+           address space.  */
+        if (!p)
+            return;
         /* if the write protection is set, then we invalidate the code
            inside */
@@ -2451 +2459 @@
         p->flags = flags;
     }
-    spin_unlock(&tb_lock);
 }
 
@@ -2491 +2498 @@
 
 /* called from signal handler: invalidate the code and unprotect the
-   page. Return TRUE if the fault was successfully handled. */
+   page. Return TRUE if the fault was succesfully handled. */
 int page_unprotect(target_ulong address, unsigned long pc, void *puc)
 {
@@ -2570 +2577 @@
     } while (0)
 
-
 /* register physical memory. 'size' must be a multiple of the target
    page size. If (phys_offset & ~TARGET_PAGE_MASK) != 0, then it is an
    io memory page */
 void cpu_register_physical_memory(target_phys_addr_t start_addr,
-                                  unsigned long size,
-                                  unsigned long phys_offset)
+                                  ram_addr_t size,
+                                  ram_addr_t phys_offset)
 {
     target_phys_addr_t addr, end_addr;
@@ -2613 +2619 @@
             } else {
                 p->phys_offset = phys_offset;
-        if ((phys_offset & ~TARGET_PAGE_MASK) <= IO_MEM_ROM ||
-            (phys_offset & IO_MEM_ROMD))
+                if ((phys_offset & ~TARGET_PAGE_MASK) <= IO_MEM_ROM ||
+                    (phys_offset & IO_MEM_ROMD))
                     phys_offset += TARGET_PAGE_SIZE;
             }
@@ -2620 +2626 @@
             p = phys_page_find_alloc(addr >> TARGET_PAGE_BITS, 1);
             p->phys_offset = phys_offset;
-        if ((phys_offset & ~TARGET_PAGE_MASK) <= IO_MEM_ROM ||
-            (phys_offset & IO_MEM_ROMD))
+            if ((phys_offset & ~TARGET_PAGE_MASK) <= IO_MEM_ROM ||
+                (phys_offset & IO_MEM_ROMD))
                 phys_offset += TARGET_PAGE_SIZE;
             else {
@@ -2639 +2645 @@
         }
     }
+
     /* since each CPU stores ram addresses in its TLB cache, we must
        reset the modified entries */
@@ -2648 +2655 @@
 
 /* XXX: temporary until new memory mapping API */
-uint32_t cpu_get_physical_page_desc(target_phys_addr_t addr)
+ram_addr_t cpu_get_physical_page_desc(target_phys_addr_t addr)
 {
     PhysPageDesc *p;
@@ -2676 +2683 @@
 {
 }
-#endif
-
+#endif /* !VBOX */
 
 static uint32_t unassigned_mem_readb(void *opaque, target_phys_addr_t addr)
 {
 #ifdef DEBUG_UNASSIGNED
-    printf("Unassigned mem read  0x%08x\n", (int)addr);
+    printf("Unassigned mem read " TARGET_FMT_plx "\n", addr);
 #endif
 #if defined(TARGET_SPARC) || defined(TARGET_CRIS)
@@ -2715 +2721 @@
 {
 #ifdef DEBUG_UNASSIGNED
-    printf("Unassigned mem write 0x%08x = 0x%x\n", (int)addr, val);
+    printf("Unassigned mem write " TARGET_FMT_plx " = 0x%x\n", addr, val);
+#endif
+#if defined(TARGET_SPARC) || defined(TARGET_CRIS)
+    do_unassigned_access(addr, 1, 0, 0, 1);
 #endif
 }
@@ -2738 +2747 @@
 #endif
 }
+
 static CPUReadMemoryFunc *unassigned_mem_read[3] = {
     unassigned_mem_readb,
@@ -2750 +2760 @@
 };
 
-static void notdirty_mem_writeb(void *opaque, target_phys_addr_t addr, uint32_t val)
-{
-    unsigned long ram_addr;
+static void notdirty_mem_writeb(void *opaque, target_phys_addr_t ram_addr,
+                                uint32_t val)
+{
     int dirty_flags;
-#if defined(VBOX)
-    ram_addr = addr;
-#else
-    ram_addr = addr - (unsigned long)phys_ram_base;
-#endif
 #ifdef VBOX
     if (RT_UNLIKELY((ram_addr >> TARGET_PAGE_BITS) >= phys_ram_dirty_size))
@@ -2777 +2782 @@
     }
 #if defined(VBOX) && !defined(REM_PHYS_ADDR_IN_TLB)
-    remR3PhysWriteU8(addr, val);
-#else
-    stb_p((uint8_t *)(long)addr, val);
+    remR3PhysWriteU8(ram_addr, val);
+#else
+    stb_p(phys_ram_base + ram_addr, val);
 #endif
 #ifdef USE_KQEMU
@@ -2794 +2799 @@
        flushed */
     if (dirty_flags == 0xff)
-        tlb_set_dirty(cpu_single_env, addr, cpu_single_env->mem_io_vaddr);
-}
-
-static void notdirty_mem_writew(void *opaque, target_phys_addr_t addr, uint32_t val)
-{
-    unsigned long ram_addr;
+        tlb_set_dirty(cpu_single_env, cpu_single_env->mem_io_vaddr);
+}
+
+static void notdirty_mem_writew(void *opaque, target_phys_addr_t ram_addr,
+                                uint32_t val)
+{
     int dirty_flags;
-#if defined(VBOX)
-    ram_addr = addr;
-#else
-    ram_addr = addr - (unsigned long)phys_ram_base;
-#endif
 #ifdef VBOX
     if (RT_UNLIKELY((ram_addr >> TARGET_PAGE_BITS) >= phys_ram_dirty_size))
@@ -2824 +2824 @@
     }
 #if defined(VBOX) && !defined(REM_PHYS_ADDR_IN_TLB)
-    remR3PhysWriteU16(addr, val);
-#else
-    stw_p((uint8_t *)(long)addr, val);
+    remR3PhysWriteU16(ram_addr, val);
+#else
+    stw_p(phys_ram_base + ram_addr, val);
 #endif
 
@@ -2842 +2842 @@
        flushed */
     if (dirty_flags == 0xff)
-        tlb_set_dirty(cpu_single_env, addr, cpu_single_env->mem_io_vaddr);
-}
-
-static void notdirty_mem_writel(void *opaque, target_phys_addr_t addr, uint32_t val)
-{
-    unsigned long ram_addr;
+        tlb_set_dirty(cpu_single_env, cpu_single_env->mem_io_vaddr);
+}
+
+static void notdirty_mem_writel(void *opaque, target_phys_addr_t ram_addr,
+                                uint32_t val)
+{
     int dirty_flags;
-#if defined(VBOX)
-    ram_addr = addr;
-#else
-    ram_addr = addr - (unsigned long)phys_ram_base;
-#endif
 #ifdef VBOX
     if (RT_UNLIKELY((ram_addr >> TARGET_PAGE_BITS) >= phys_ram_dirty_size))
@@ -2872 +2867 @@
     }
 #if defined(VBOX) && !defined(REM_PHYS_ADDR_IN_TLB)
-    remR3PhysWriteU32(addr, val);
-#else
-    stl_p((uint8_t *)(long)addr, val);
+    remR3PhysWriteU32(ram_addr, val);
+#else
+    stl_p(phys_ram_base + ram_addr, val);
 #endif
 #ifdef USE_KQEMU
@@ -2889 +2884 @@
        flushed */
     if (dirty_flags == 0xff)
-        tlb_set_dirty(cpu_single_env, addr, cpu_single_env->mem_io_vaddr);
+        tlb_set_dirty(cpu_single_env, cpu_single_env->mem_io_vaddr);
 }
 
@@ -2903 +2898 @@
     notdirty_mem_writel,
 };
-
 
 /* Generate a debug exception if a watchpoint has been hit.  */
@@ -3184 +3178 @@
     return io_mem_read[io_index >> IO_MEM_SHIFT];
 }
+
 #endif /* !defined(CONFIG_USER_ONLY) */
 
@@ -3210 +3205 @@
                 /* FIXME - should this return an error rather than just fail? */
                 return;
-            memcpy(p, buf, len);
-            unlock_user(p, addr, len);
+            memcpy(p, buf, l);
+            unlock_user(p, addr, l);
         } else {
             if (!(flags & PAGE_READ))
                 return;
+            /* XXX: this code should not depend on lock_user */
             if (!(p = lock_user(VERIFY_READ, addr, l, 1)))
                 /* FIXME - should this return an error rather than just fail? */
                 return;
-            memcpy(buf, p, len);
+            memcpy(buf, p, l);
             unlock_user(p, addr, 0);
         }
@@ -3508 +3504 @@
     } else {
 #ifndef VBOX
-        ptr = phys_ram_base + (pd & TARGET_PAGE_MASK) +
-            (addr & ~TARGET_PAGE_MASK);
+        unsigned long addr1 = (pd & TARGET_PAGE_MASK) + (addr & ~TARGET_PAGE_MASK);
+        ptr = phys_ram_base + addr1;
         stl_p(ptr, val);
 #else
@@ -3521 +3517 @@
                 /* set dirty bit */
                 phys_ram_dirty[addr1 >> TARGET_PAGE_BITS] |=
-                        (0xff & ~CODE_DIRTY_FLAG);
+                    (0xff & ~CODE_DIRTY_FLAG);
             }
         }
-#endif
+#endif /* !VBOX */
     }
 }
@@ -3561 +3557 @@
     }
 }
-
 
 /* warning: addr must be aligned */
@@ -3632 +3627 @@
 {
     int l;
-    target_ulong page, phys_addr;
+    target_phys_addr_t phys_addr;
+    target_ulong page;
 
     while (len > 0) {