Changeset 42601 in vbox for trunk/src/recompiler

Timestamp:

Aug 5, 2012 4:26:25 PM (13 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

79786

Message:

REM: Initial changes to make it work (seemingly) with MinGW-w64.

Location:

trunk/src/recompiler

Files:

• Makefile.kmk (modified) (2 diffs)
• VBoxRecompiler.c (modified) (4 diffs)
• cache-utils.h (modified) (1 diff)
• cpu-all.h (modified) (7 diffs)
• cpu-common.h (modified) (1 diff)
• cpu-defs.h (modified) (2 diffs)
• cpu-exec.c (modified) (27 diffs)
• dyngen-exec.h (modified) (1 diff)
• exec-all.h (modified) (10 diffs)
• exec.c (modified) (64 diffs)
• gen-icount.h (modified) (1 diff)
• qemu-lock.h (modified) (1 diff)
• softmmu_header.h (modified) (3 diffs)
• softmmu_template.h (modified) (10 diffs)
• target-i386/op_helper.c (modified) (3 diffs)
• target-i386/translate.c (modified) (2 diffs)
• tcg/i386/tcg-target.c (modified) (10 diffs)
• tcg/i386/tcg-target.h (modified) (2 diffs)
• tcg/tcg-dyngen.c (modified) (9 diffs)
• tcg/tcg.c (modified) (6 diffs)
• tcg/tcg.h (modified) (4 diffs)
• translate-all.c (modified) (3 diffs)

trunk/src/recompiler/Makefile.kmk

@@ -64 +64 @@
 #VBoxRemPrimary_DEFS           += REM_PHYS_ADDR_IN_TLB
 #VBoxRemPrimary_DEFS           += DEBUG_ALL_LOGGING DEBUG_DISAS DEBUG_PCALL CONFIG_DEBUG_EXEC DEBUG_FLUSH DEBUG_IOPORT DEBUG_SIGNAL DEBUG_TLB_CHECK DEBUG_TB_INVALIDATE DEBUG_TLB  # Enables huge amounts of debug logging.
+#VBoxRemPrimary_DEFS           += DEBUG_DISAS DEBUG_PCALL CONFIG_DEBUG_EXEC DEBUG_FLUSH DEBUG_IOPORT DEBUG_SIGNAL DEBUG_TLB_CHECK DEBUG_TB_INVALIDATE DEBUG_TLB  # Enables huge amounts of debug logging.
 ifdef IEM_VERIFICATION_MODE
  VBoxRemPrimary_DEFS          += IEM_VERIFICATION_MODE
@@ -110 +111 @@
 VBoxRemPrimary_SOURCES.win.x86 = $(VBoxREMImp_0_OUTDIR)/VBoxREMWin.def
 ifdef VBOX_USE_MINGWW64
-VBoxRemPrimary_SOURCES.win.amd64 = $(VBoxREMImp_0_OUTDIR)/VBoxREMWin.def
+ if 0 # exporting all helps when windbg pops up on crashes
+  VBoxRemPrimary_SOURCES.win.amd64 = $(VBoxREMImp_0_OUTDIR)/VBoxREMWin.def
+ else
+  VBoxRemPrimary_LDFLAGS.win.amd64 = --export-all
+ endif
 endif
 

trunk/src/recompiler/VBoxRecompiler.c

@@ -56 +56 @@
 
 /* Don't wanna include everything. */
-extern void cpu_exec_init_all(unsigned long tb_size);
+extern void cpu_exec_init_all(uintptr_t tb_size);
 extern void cpu_x86_update_cr3(CPUX86State *env, target_ulong new_cr3);
 extern void cpu_x86_update_cr0(CPUX86State *env, uint32_t new_cr0);
@@ -66 +66 @@
 
 #ifdef VBOX_STRICT
-unsigned long get_phys_page_offset(target_ulong addr);
+ram_addr_t get_phys_page_offset(target_ulong addr);
 #endif
 
@@ -266 +266 @@
     AssertReleaseMsg(sizeof(pVM->rem.s.Env) <= REM_ENV_SIZE, ("%#x == %#x\n", sizeof(pVM->rem.s.Env), REM_ENV_SIZE));
     AssertReleaseMsg(!(RT_OFFSETOF(VM, rem) & 31), ("off=%#x\n", RT_OFFSETOF(VM, rem)));
+#if 0 /* just an annoyance at the moment. */
 #if defined(DEBUG) && !defined(RT_OS_SOLARIS) && !defined(RT_OS_FREEBSD) /// @todo fix the solaris and freebsd math stuff.
     Assert(!testmath());
+#endif
 #endif
 
@@ -3446 +3448 @@
 {
 #ifdef VBOX_STRICT
-    unsigned long off;
+    ram_addr_t off;
     REMR3ReplayHandlerNotifications(pVM);
 

trunk/src/recompiler/cache-utils.h

@@ -13 +13 @@
 
 /* mildly adjusted code from tcg-dyngen.c */
-static inline void flush_icache_range(unsigned long start, unsigned long stop)
+static inline void flush_icache_range(uintptr_t start, uintptr_t stop)
 {
     unsigned long p, start1, stop1;

trunk/src/recompiler/cpu-all.h

@@ -774 +774 @@
  */
 #if defined(CONFIG_USE_GUEST_BASE)
-extern unsigned long guest_base;
+extern uintptr_t guest_base;
 extern int have_guest_base;
-extern unsigned long reserved_va;
+extern uintptr_t reserved_va;
 #define GUEST_BASE guest_base
 #define RESERVED_VA reserved_va
@@ -785 +785 @@
 
 /* All direct uses of g2h and h2g need to go away for usermode softmmu.  */
-#define g2h(x) ((void *)((unsigned long)(x) + GUEST_BASE))
+#define g2h(x) ((void *)((uintptr_t)(x) + GUEST_BASE))
 
 #if HOST_LONG_BITS <= TARGET_VIRT_ADDR_SPACE_BITS
@@ -791 +791 @@
 #else
 #define h2g_valid(x) ({ \
-    unsigned long __guest = (unsigned long)(x) - GUEST_BASE; \
+    uintptr_t __guest = (uintptr_t)(x) - GUEST_BASE; \
     __guest < (1ul << TARGET_VIRT_ADDR_SPACE_BITS); \
 })
@@ -797 +797 @@
 
 #define h2g(x) ({ \
-    unsigned long __ret = (unsigned long)(x) - GUEST_BASE; \
+    uintptr_t __ret = (uintptr_t)(x) - GUEST_BASE; \
     /* Check if given address fits target address space */ \
     assert(h2g_valid(x)); \
@@ -809 +809 @@
 /* NOTE: we use double casts if pointers and target_ulong have
    different sizes */
-#define saddr(x) (uint8_t *)(long)(x)
-#define laddr(x) (uint8_t *)(long)(x)
+#define saddr(x) (uint8_t *)(intptr_t)(x)
+#define laddr(x) (uint8_t *)(intptr_t)(x)
 #endif
 
@@ -877 +877 @@
 #define TARGET_PAGE_ALIGN(addr) (((addr) + TARGET_PAGE_SIZE - 1) & TARGET_PAGE_MASK)
 
-/* ??? These should be the larger of unsigned long and target_ulong.  */
-extern unsigned long qemu_real_host_page_size;
-extern unsigned long qemu_host_page_bits;
-extern unsigned long qemu_host_page_size;
-extern unsigned long qemu_host_page_mask;
+/* ??? These should be the larger of uintptr_t and target_ulong.  */
+extern size_t qemu_real_host_page_size;
+extern size_t qemu_host_page_bits;
+extern size_t qemu_host_page_size;
+extern uintptr_t qemu_host_page_mask;
 
 #define HOST_PAGE_ALIGN(addr) (((addr) + qemu_host_page_size - 1) & qemu_host_page_mask)
@@ -903 +903 @@
 
 typedef int (*walk_memory_regions_fn)(void *, abi_ulong,
-                                      abi_ulong, unsigned long);
+                                      abi_ulong, uintptr_t);
 int walk_memory_regions(void *, walk_memory_regions_fn);
 

trunk/src/recompiler/cpu-common.h

@@ -22 +22 @@
 
 /* address in the RAM (different from a physical address) */
-typedef unsigned long ram_addr_t;
+typedef uintptr_t ram_addr_t;
 
 /* memory API */

trunk/src/recompiler/cpu-defs.h

@@ -115 +115 @@
     /* Addend to virtual address to get host address.  IO accesses
        use the corresponding iotlb value.  */
-    unsigned long addend;
+    uintptr_t addend;
     /* padding to get a power of two size */
     uint8_t dummy[(1 << CPU_TLB_ENTRY_BITS) -
                   (sizeof(target_ulong) * 3 +
-                   ((-sizeof(target_ulong) * 3) & (sizeof(unsigned long) - 1)) +
-                   sizeof(unsigned long))];
+                   ((-sizeof(target_ulong) * 3) & (sizeof(uintptr_t) - 1)) +
+                   sizeof(uintptr_t))];
 } CPUTLBEntry;
 
@@ -175 +175 @@
        helpers, we store some rarely used information in the CPU        \
        context) */                                                      \
-    unsigned long mem_io_pc; /* host pc at which the memory was         \
+    uintptr_t mem_io_pc; /* host pc at which the memory was             \
                                 accessed */                             \
     target_ulong mem_io_vaddr; /* target virtual addr at which the      \

trunk/src/recompiler/cpu-exec.c

@@ -111 +111 @@
 static void cpu_exec_nocache(int max_cycles, TranslationBlock *orig_tb)
 {
-    unsigned long next_tb;
+    uintptr_t next_tb;
     TranslationBlock *tb;
 
@@ -237 +237 @@
     TranslationBlock *tb;
     uint8_t *tc_ptr;
-#ifndef VBOX
     uintptr_t next_tb;
-#else  /* VBOX */
-    unsigned long next_tb;
-#endif /* VBOX */
 
 # ifndef VBOX
@@ -739 +735 @@
                 }
 #ifdef CONFIG_DEBUG_EXEC
-                qemu_log_mask(CPU_LOG_EXEC, "Trace 0x%08lx [" TARGET_FMT_lx "] %s\n",
-                             (long)tb->tc_ptr, tb->pc,
+                qemu_log_mask(CPU_LOG_EXEC, "Trace %p [" TARGET_FMT_lx "] %s\n",
+                             (void *)tb->tc_ptr, tb->pc,
                              lookup_symbol(tb->pc));
 #endif
@@ -775 +771 @@
 #define env cpu_single_env
 #endif
+                    Log5(("REM: tb=%p tc_ptr=%p %04x:%08RGv\n", tb, tc_ptr, env->segs[R_CS].selector, (RTGCPTR)env->eip));
 #if defined(VBOX) && defined(GCC_WITH_BUGGY_REGPARM)
                     tcg_qemu_tb_exec(tc_ptr, next_tb);
@@ -780 +777 @@
                     next_tb = tcg_qemu_tb_exec(tc_ptr);
 #endif
+                    if (next_tb)
+                        Log5(("REM: next_tb=%p %04x:%08RGv\n", next_tb, env->segs[R_CS].selector, (RTGCPTR)env->eip));
 #ifdef VBOX
                     RAWEx_ProfileStop(env, STATS_QEMU_RUN_EMULATED_CODE);
@@ -786 +785 @@
                         /* Instruction counter expired.  */
                         int insns_left;
-                        tb = (TranslationBlock *)(long)(next_tb & ~3);
+                        tb = (TranslationBlock *)(uintptr_t)(next_tb & ~3);
                         /* Restore PC.  */
                         cpu_pc_from_tb(env, tb);
@@ -938 +937 @@
    write caused the exception and otherwise 0'. 'old_set' is the
    signal set which should be restored */
-static inline int handle_cpu_signal(unsigned long pc, unsigned long address,
+static inline int handle_cpu_signal(uintptr_t pc, uintptr_t address,
                                     int is_write, sigset_t *old_set,
                                     void *puc)
@@ -1025 +1024 @@
     struct ucontext *uc = puc;
 #endif
-    unsigned long pc;
+    uintptr_t pc;
     int trapno;
 
@@ -1036 +1035 @@
     pc = EIP_sig(uc);
     trapno = TRAP_sig(uc);
-    return handle_cpu_signal(pc, (unsigned long)info->si_addr,
+    return handle_cpu_signal(pc, (uintptr_t)info->si_addr,
                              trapno == 0xe ?
                              (ERROR_sig(uc) >> 1) & 1 : 0,
@@ -1072 +1071 @@
 {
     siginfo_t *info = pinfo;
-    unsigned long pc;
+    uintptr_t pc;
 #if defined(__NetBSD__) || defined (__FreeBSD__) || defined(__DragonFly__)
     ucontext_t *uc = puc;
@@ -1082 +1081 @@
 
     pc = PC_sig(uc);
-    return handle_cpu_signal(pc, (unsigned long)info->si_addr,
+    return handle_cpu_signal(pc, (uintptr_t)info->si_addr,
                              TRAP_sig(uc) == 0xe ?
                              (ERROR_sig(uc) >> 1) & 1 : 0,
@@ -1162 +1161 @@
     struct ucontext *uc = puc;
 #endif
-    unsigned long pc;
+    uintptr_t pc;
     int is_write;
 
@@ -1175 +1174 @@
         is_write = 1;
 #endif
-    return handle_cpu_signal(pc, (unsigned long)info->si_addr,
+    return handle_cpu_signal(pc, (uintptr_t)info->si_addr,
                              is_write, &uc->uc_sigmask, puc);
 }
@@ -1206 +1205 @@
     }
 
-    return handle_cpu_signal(pc, (unsigned long)info->si_addr,
+    return handle_cpu_signal(pc, (uintptr_t)info->si_addr,
                              is_write, &uc->uc_sigmask, puc);
 }
@@ -1221 +1220 @@
     void *sigmask = (regs + 20);
     /* XXX: is there a standard glibc define ? */
-    unsigned long pc = regs[1];
+    uintptr_t pc = regs[1];
 #else
 #ifdef __linux__
     struct sigcontext *sc = puc;
-    unsigned long pc = sc->sigc_regs.tpc;
+    uintptr_t pc = sc->sigc_regs.tpc;
     void *sigmask = (void *)sc->sigc_mask;
 #elif defined(__OpenBSD__)
     struct sigcontext *uc = puc;
-    unsigned long pc = uc->sc_pc;
-    void *sigmask = (void *)(long)uc->sc_mask;
+    uintptr_t pc = uc->sc_pc;
+    void *sigmask = (void *)(uintptr_t)uc->sc_mask;
 #endif
 #endif
@@ -1262 +1261 @@
       }
     }
-    return handle_cpu_signal(pc, (unsigned long)info->si_addr,
+    return handle_cpu_signal(pc, (uintptr_t)info->si_addr,
                              is_write, sigmask, NULL);
 }
@@ -1273 +1272 @@
     siginfo_t *info = pinfo;
     struct ucontext *uc = puc;
-    unsigned long pc;
+    uintptr_t pc;
     int is_write;
 
@@ -1283 +1282 @@
     /* XXX: compute is_write */
     is_write = 0;
-    return handle_cpu_signal(pc, (unsigned long)info->si_addr,
+    return handle_cpu_signal(pc, (uintptr_t)info->si_addr,
                              is_write,
                              &uc->uc_sigmask, puc);
@@ -1295 +1294 @@
     siginfo_t *info = pinfo;
     struct ucontext *uc = puc;
-    unsigned long pc;
+    uintptr_t pc;
     int is_write;
 
@@ -1301 +1300 @@
     /* XXX: compute is_write */
     is_write = 0;
-    return handle_cpu_signal(pc, (unsigned long)info->si_addr,
+    return handle_cpu_signal(pc, (uintptr_t)info->si_addr,
                              is_write,
                              &uc->uc_sigmask, puc);
@@ -1317 +1316 @@
     siginfo_t *info = pinfo;
     struct ucontext *uc = puc;
-    unsigned long ip;
+    uintptr_t ip;
     int is_write = 0;
 
@@ -1335 +1334 @@
           break;
     }
-    return handle_cpu_signal(ip, (unsigned long)info->si_addr,
+    return handle_cpu_signal(ip, (uintptr_t)info->si_addr,
                              is_write,
                              (sigset_t *)&uc->uc_sigmask, puc);
@@ -1347 +1346 @@
     siginfo_t *info = pinfo;
     struct ucontext *uc = puc;
-    unsigned long pc;
+    uintptr_t pc;
     uint16_t *pinsn;
     int is_write = 0;
@@ -1389 +1388 @@
         break;
     }
-    return handle_cpu_signal(pc, (unsigned long)info->si_addr,
+    return handle_cpu_signal(pc, (uintptr_t)info->si_addr,
                              is_write, &uc->uc_sigmask, puc);
 }
@@ -1405 +1404 @@
     /* XXX: compute is_write */
     is_write = 0;
-    return handle_cpu_signal(pc, (unsigned long)info->si_addr,
+    return handle_cpu_signal(pc, (uintptr_t)info->si_addr,
                              is_write, &uc->uc_sigmask, puc);
 }
@@ -1416 +1415 @@
     struct siginfo *info = pinfo;
     struct ucontext *uc = puc;
-    unsigned long pc = uc->uc_mcontext.sc_iaoq[0];
+    uintptr_t pc = uc->uc_mcontext.sc_iaoq[0];
     uint32_t insn = *(uint32_t *)pc;
     int is_write = 0;
@@ -1447 +1446 @@
     }
 
-    return handle_cpu_signal(pc, (unsigned long)info->si_addr,
+    return handle_cpu_signal(pc, (uintptr_t)info->si_addr,
                              is_write, &uc->uc_sigmask, puc);
 }

trunk/src/recompiler/dyngen-exec.h

@@ -120 +120 @@
    Subtracting one gets us the call instruction itself.  */
 #if defined(__s390__) && !defined(__s390x__)
-# define GETPC() ((void*)(((unsigned long)__builtin_return_address(0) & 0x7fffffffUL) - 1))
+# define GETPC() ((void*)(((uintptr_t)__builtin_return_address(0) & 0x7fffffffUL) - 1))
 #elif defined(__arm__)
 /* Thumb return addresses have the low bit set, so we need to subtract two.
    This is still safe in ARM mode because instructions are 4 bytes.  */
-# define GETPC() ((void *)((unsigned long)__builtin_return_address(0) - 2))
+# define GETPC() ((void *)((uintptr_t)__builtin_return_address(0) - 2))
 #else
-# define GETPC() ((void *)((unsigned long)__builtin_return_address(0) - 1))
+# define GETPC() ((void *)((uintptr_t)__builtin_return_address(0) - 1))
 #endif
 

trunk/src/recompiler/exec-all.h

@@ -101 +101 @@
 void gen_intermediate_code_pc(CPUState *env, struct TranslationBlock *tb);
 void gen_pc_load(CPUState *env, struct TranslationBlock *tb,
-                 unsigned long searched_pc, int pc_pos, void *puc);
+                 uintptr_t searched_pc, int pc_pos, void *puc);
 
 void cpu_gen_init(void);
@@ -107 +107 @@
                  int *gen_code_size_ptr);
 int cpu_restore_state(struct TranslationBlock *tb,
-                      CPUState *env, unsigned long searched_pc,
+                      CPUState *env, uintptr_t searched_pc,
                       void *puc);
 void cpu_resume_from_signal(CPUState *env1, void *puc);
@@ -116 +116 @@
 void cpu_exec_init(CPUState *env);
 void QEMU_NORETURN cpu_loop_exit(void);
-int page_unprotect(target_ulong address, unsigned long pc, void *puc);
+int page_unprotect(target_ulong address, uintptr_t pc, void *puc);
 void tb_invalidate_phys_page_range(tb_page_addr_t start, tb_page_addr_t end,
                                    int is_cpu_write_access);
@@ -179 +179 @@
     uint16_t tb_jmp_offset[2]; /* offset of jump instruction */
 #else
-    unsigned long tb_next[2]; /* address of jump generated code */
+    uintptr_t tb_next[2]; /* address of jump generated code */
 #endif
     /* list of TBs jumping to this one. This is a circular list using
@@ -222 +222 @@
 
 #if defined(_ARCH_PPC)
-extern void ppc_tb_set_jmp_target(unsigned long jmp_addr, unsigned long addr);
+extern void ppc_tb_set_jmp_target(uintptr_t jmp_addr, uintptr_t addr);
 #define tb_set_jmp_target1 ppc_tb_set_jmp_target
 #elif defined(__i386__) || defined(__x86_64__)
-static inline void tb_set_jmp_target1(unsigned long jmp_addr, unsigned long addr)
+static inline void tb_set_jmp_target1(uintptr_t jmp_addr, uintptr_t addr)
 {
     /* patch the branch destination */
@@ -232 +232 @@
 }
 #elif defined(__arm__)
-static inline void tb_set_jmp_target1(unsigned long jmp_addr, unsigned long addr)
+static inline void tb_set_jmp_target1(uintptr_t jmp_addr, uintptr_t addr)
 {
 #if QEMU_GNUC_PREREQ(4, 1)
@@ -260 +260 @@
 
 static inline void tb_set_jmp_target(TranslationBlock *tb,
-                                     int n, unsigned long addr)
-{
-    unsigned long offset;
+                                     int n, uintptr_t addr)
+{
+    uintptr_t offset;
 
     offset = tb->tb_jmp_offset[n];
-    tb_set_jmp_target1((unsigned long)(tb->tc_ptr + offset), addr);
+    tb_set_jmp_target1((uintptr_t)(tb->tc_ptr + offset), addr);
 }
 
@@ -272 +272 @@
 /* set the jump target */
 static inline void tb_set_jmp_target(TranslationBlock *tb,
-                                     int n, unsigned long addr)
+                                     int n, uintptr_t addr)
 {
     tb->tb_next[n] = addr;
@@ -285 +285 @@
     if (!tb->jmp_next[n]) {
         /* patch the native jump address */
-        tb_set_jmp_target(tb, n, (unsigned long)tb_next->tc_ptr);
+        tb_set_jmp_target(tb, n, (uintptr_t)tb_next->tc_ptr);
 
         /* add in TB jmp circular list */
         tb->jmp_next[n] = tb_next->jmp_first;
-        tb_next->jmp_first = (TranslationBlock *)((long)(tb) | (n));
+        tb_next->jmp_first = (TranslationBlock *)((intptr_t)(tb) | (n));
     }
 }
 
-TranslationBlock *tb_find_pc(unsigned long pc_ptr);
+TranslationBlock *tb_find_pc(uintptr_t pc_ptr);
 
 #include "qemu-lock.h"
@@ -378 +378 @@
     return addr + env1->phys_addends[mmu_idx][page_index];
 # else
-    p = (void *)(unsigned long)addr
+    p = (void *)(uintptr_t)addr
         + env1->tlb_table[mmu_idx][page_index].addend;
     return qemu_ram_addr_from_host(p);

trunk/src/recompiler/exec.c

@@ -130 +130 @@
 #endif /* VBOX */
 static uint8_t *code_gen_buffer;
-static unsigned long code_gen_buffer_size;
+static size_t code_gen_buffer_size;
 /* threshold to flush the translated code buffer */
-static unsigned long code_gen_buffer_max_size;
+static size_t code_gen_buffer_max_size;
 static uint8_t *code_gen_ptr;
 
@@ -209 +209 @@
 #define V_L1_SHIFT (L1_MAP_ADDR_SPACE_BITS - TARGET_PAGE_BITS - V_L1_BITS)
 
-unsigned long qemu_real_host_page_size;
-unsigned long qemu_host_page_bits;
-unsigned long qemu_host_page_size;
-unsigned long qemu_host_page_mask;
+size_t qemu_real_host_page_size;
+size_t qemu_host_page_bits;
+size_t qemu_host_page_size;
+uintptr_t qemu_host_page_mask;
 
 /* This is a multi-level map on the virtual address space.
@@ -268 +268 @@
 #ifndef VBOX
 #ifdef _WIN32
-static void map_exec(void *addr, long size)
+static void map_exec(void *addr, size_t size)
 {
     DWORD old_protect;
@@ -276 +276 @@
 }
 #else
-static void map_exec(void *addr, long size)
-{
-    unsigned long start, end, page_size;
+static void map_exec(void *addr, size_t size)
+{
+    uintptr_t start, end, page_size;
 
     page_size = getpagesize();
-    start = (unsigned long)addr;
+    start = (uintptr_t)addr;
     start &= ~(page_size - 1);
 
-    end = (unsigned long)addr + size;
+    end = (uintptr_t)addr + size;
     end += page_size - 1;
     end &= ~(page_size - 1);
@@ -293 +293 @@
 #endif
 #else /* VBOX */
-static void map_exec(void *addr, long size)
+static void map_exec(void *addr, size_t size)
 {
     RTMemProtect(addr, size,
@@ -340 +340 @@
             mmap_lock();
             for (i = 0; i < cnt; i++) {
-                unsigned long startaddr, endaddr;
+                uintptr_t startaddr, endaddr;
 
                 startaddr = freep[i].kve_start;
@@ -364 +364 @@
         FILE *f;
 
-        last_brk = (unsigned long)sbrk(0);
+        last_brk = (uintptr_t)sbrk(0);
 
         f = fopen("/compat/linux/proc/self/maps", "r");
@@ -371 +371 @@
 
             do {
-                unsigned long startaddr, endaddr;
+                uintptr_t startaddr, endaddr;
                 int n;
 
@@ -527 +527 @@
 #endif
 
-static void code_gen_alloc(unsigned long tb_size)
+static void code_gen_alloc(uintptr_t tb_size)
 {
 #ifdef USE_STATIC_CODE_GEN_BUFFER
@@ -548 +548 @@
 #else
         /* XXX: needs adjustments */
-        code_gen_buffer_size = (unsigned long)(ram_size / 4);
+        code_gen_buffer_size = (uintptr_t)(ram_size / 4);
 #endif
     }
@@ -646 +646 @@
    (in bytes) allocated to the translation buffer. Zero means default
    size. */
-void cpu_exec_init_all(unsigned long tb_size)
+void cpu_exec_init_all(uintptr_t tb_size)
 {
     cpu_gen_init();
@@ -792 +792 @@
            ((unsigned long)(code_gen_ptr - code_gen_buffer)) / nb_tbs : 0);
 #endif
-    if ((unsigned long)(code_gen_ptr - code_gen_buffer) > code_gen_buffer_size)
+    if ((uintptr_t)(code_gen_ptr - code_gen_buffer) > code_gen_buffer_size)
         cpu_abort(env1, "Internal error: code buffer overflow\n");
 
@@ -874 +874 @@
     for(;;) {
         tb1 = *ptb;
-        n1 = (long)tb1 & 3;
-        tb1 = (TranslationBlock *)((long)tb1 & ~3);
+        n1 = (intptr_t)tb1 & 3;
+        tb1 = (TranslationBlock *)((intptr_t)tb1 & ~3);
         if (tb1 == tb) {
             *ptb = tb1->page_next[n1];
@@ -895 +895 @@
         for(;;) {
             tb1 = *ptb;
-            n1 = (long)tb1 & 3;
-            tb1 = (TranslationBlock *)((long)tb1 & ~3);
+            n1 = (intptr_t)tb1 & 3;
+            tb1 = (TranslationBlock *)((intptr_t)tb1 & ~3);
             if (n1 == n && tb1 == tb)
                 break;
@@ -916 +916 @@
 static inline void tb_reset_jump(TranslationBlock *tb, int n)
 {
-    tb_set_jmp_target(tb, n, (unsigned long)(tb->tc_ptr + tb->tb_next_offset[n]));
+    tb_set_jmp_target(tb, n, (uintptr_t)(tb->tc_ptr + tb->tb_next_offset[n]));
 }
 
@@ -961 +961 @@
     tb1 = tb->jmp_first;
     for(;;) {
-        n1 = (long)tb1 & 3;
+        n1 = (intptr_t)tb1 & 3;
         if (n1 == 2)
             break;
-        tb1 = (TranslationBlock *)((long)tb1 & ~3);
+        tb1 = (TranslationBlock *)((intptr_t)tb1 & ~3);
         tb2 = tb1->jmp_next[n1];
         tb_reset_jump(tb1, n1);
@@ -970 +970 @@
         tb1 = tb2;
     }
-    tb->jmp_first = (TranslationBlock *)((long)tb | 2); /* fail safe */
+    tb->jmp_first = (TranslationBlock *)((intptr_t)tb | 2); /* fail safe */
 
     tb_phys_invalidate_count++;
@@ -991 +991 @@
     pc = cs_base + eip;
 
-    tb = tb_find(&ptb, (unsigned long)pc, (unsigned long)cs_base,
+    tb = tb_find(&ptb, (uintptr_t)pc, (uintptr_t)cs_base,
                  flags);
 
@@ -1013 +1013 @@
  * Gets the page offset.
  */
-unsigned long get_phys_page_offset(target_ulong addr)
+ram_addr_t get_phys_page_offset(target_ulong addr)
 {
     PhysPageDesc *p = phys_page_find(addr >> TARGET_PAGE_BITS);
@@ -1058 +1058 @@
     tb = p->first_tb;
     while (tb != NULL) {
-        n = (long)tb & 3;
-        tb = (TranslationBlock *)((long)tb & ~3);
+        n = (intptr_t)tb & 3;
+        tb = (TranslationBlock *)((intptr_t)tb & ~3);
         /* NOTE: this is subtle as a TB may span two physical pages */
         if (n == 0) {
@@ -1103 +1103 @@
     tb->cflags = cflags;
     cpu_gen_code(env, tb, &code_gen_size);
-    code_gen_ptr = (void *)(((unsigned long)code_gen_ptr + code_gen_size + CODE_GEN_ALIGN - 1) & ~(CODE_GEN_ALIGN - 1));
+    code_gen_ptr = (void *)(((uintptr_t)code_gen_ptr + code_gen_size + CODE_GEN_ALIGN - 1) & ~(CODE_GEN_ALIGN - 1));
 
     /* check next page if needed */
@@ -1151 +1151 @@
     tb = p->first_tb;
     while (tb != NULL) {
-        n = (long)tb & 3;
-        tb = (TranslationBlock *)((long)tb & ~3);
+        n = (intptr_t)tb & 3;
+        tb = (TranslationBlock *)((intptr_t)tb & ~3);
         tb_next = tb->page_next[n];
         /* NOTE: this is subtle as a TB may span two physical pages */
@@ -1236 +1236 @@
                   cpu_single_env->mem_io_vaddr, len,
                   cpu_single_env->eip,
-                  cpu_single_env->eip + (long)cpu_single_env->segs[R_CS].base);
+                  cpu_single_env->eip + (intptr_t)cpu_single_env->segs[R_CS].base);
     }
 #endif
@@ -1255 +1255 @@
 #if !defined(CONFIG_SOFTMMU)
 static void tb_invalidate_phys_page(tb_page_addr_t addr,
-                                    unsigned long pc, void *puc)
+                                    uintptr_t pc, void *puc)
 {
     TranslationBlock *tb;
@@ -1280 +1280 @@
 #endif
     while (tb != NULL) {
-        n = (long)tb & 3;
-        tb = (TranslationBlock *)((long)tb & ~3);
+        n = (intptr_t)tb & 3;
+        tb = (TranslationBlock *)((intptr_t)tb & ~3);
 #ifdef TARGET_HAS_PRECISE_SMC
         if (current_tb == tb &&
@@ -1325 +1325 @@
     tb->page_next[n] = p->first_tb;
     last_first_tb = p->first_tb;
-    p->first_tb = (TranslationBlock *)((long)tb | n);
+    p->first_tb = (TranslationBlock *)((intptr_t)tb | n);
     invalidate_page_bitmap(p);
 
@@ -1375 +1375 @@
 
     if (nb_tbs >= code_gen_max_blocks ||
-        (code_gen_ptr - code_gen_buffer) >= VBOX_ONLY((unsigned long))code_gen_buffer_max_size)
+        (code_gen_ptr - code_gen_buffer) >= VBOX_ONLY((uintptr_t))code_gen_buffer_max_size)
         return NULL;
     tb = &tbs[nb_tbs++];
@@ -1418 +1418 @@
         tb->page_addr[1] = -1;
 
-    tb->jmp_first = (TranslationBlock *)((long)tb | 2);
+    tb->jmp_first = (TranslationBlock *)((intptr_t)tb | 2);
     tb->jmp_next[0] = NULL;
     tb->jmp_next[1] = NULL;
@@ -1436 +1436 @@
 /* find the TB 'tb' such that tb[0].tc_ptr <= tc_ptr <
    tb[1].tc_ptr. Return NULL if not found */
-TranslationBlock *tb_find_pc(unsigned long tc_ptr)
+TranslationBlock *tb_find_pc(uintptr_t tc_ptr)
 {
     int m_min, m_max, m;
-    unsigned long v;
+    uintptr_t v;
     TranslationBlock *tb;
 
     if (nb_tbs <= 0)
         return NULL;
-    if (tc_ptr < (unsigned long)code_gen_buffer ||
-        tc_ptr >= (unsigned long)code_gen_ptr)
+    if (tc_ptr < (uintptr_t)code_gen_buffer ||
+        tc_ptr >= (uintptr_t)code_gen_ptr)
         return NULL;
     /* binary search (cf Knuth) */
@@ -1453 +1453 @@
         m = (m_min + m_max) >> 1;
         tb = &tbs[m];
-        v = (unsigned long)tb->tc_ptr;
+        v = (uintptr_t)tb->tc_ptr;
         if (v == tc_ptr)
             return tb;
@@ -1476 +1476 @@
         /* find head of list */
         for(;;) {
-            n1 = (long)tb1 & 3;
-            tb1 = (TranslationBlock *)((long)tb1 & ~3);
+            n1 = (intptr_t)tb1 & 3;
+            tb1 = (TranslationBlock *)((intptr_t)tb1 & ~3);
             if (n1 == 2)
                 break;
@@ -1489 +1489 @@
         for(;;) {
             tb1 = *ptb;
-            n1 = (long)tb1 & 3;
-            tb1 = (TranslationBlock *)((long)tb1 & ~3);
+            n1 = (intptr_t)tb1 & 3;
+            tb1 = (TranslationBlock *)((intptr_t)tb1 & ~3);
             if (n1 == n && tb1 == tb)
                 break;
@@ -2204 +2204 @@
 
 static inline void tlb_reset_dirty_range(CPUTLBEntry *tlb_entry,
-                                         unsigned long start, unsigned long length)
-{
-    unsigned long addr;
+                                         uintptr_t start, uintptr_t length)
+{
+    uintptr_t addr;
 #ifdef VBOX
 
@@ -2225 +2225 @@
 {
     CPUState *env;
-    unsigned long length, start1;
+    uintptr_t length, start1;
     int i;
 
@@ -2241 +2241 @@
     start1 = start;
 #elif !defined(VBOX)
-    start1 = (unsigned long)qemu_get_ram_ptr(start);
+    start1 = (uintptr_t)qemu_get_ram_ptr(start);
     /* Chek that we don't span multiple blocks - this breaks the
        address comparisons below.  */
-    if ((unsigned long)qemu_get_ram_ptr(end - 1) - start1
+    if ((uintptr_t)qemu_get_ram_ptr(end - 1) - start1
             != (end - 1) - start) {
         abort();
     }
 #else
-    start1 = (unsigned long)remR3TlbGCPhys2Ptr(first_cpu, start, 1 /*fWritable*/); /** @todo page replacing (sharing or read only) may cause trouble, fix interface/whatever. */
+    start1 = (uintptr_t)remR3TlbGCPhys2Ptr(first_cpu, start, 1 /*fWritable*/); /** @todo page replacing (sharing or read only) may cause trouble, fix interface/whatever. */
 #endif
 
@@ -2299 +2299 @@
 {
     ram_addr_t ram_addr;
+#ifndef VBOX
     void *p;
+#endif
 
     if ((tlb_entry->addr_write & ~TARGET_PAGE_MASK) == IO_MEM_RAM) {
@@ -2305 +2307 @@
         ram_addr = (tlb_entry->addr_write & TARGET_PAGE_MASK) + tlb_entry->addend;
 #elif !defined(VBOX)
-        p = (void *)(unsigned long)((tlb_entry->addr_write & TARGET_PAGE_MASK)
+        p = (void *)(uintptr_t)((tlb_entry->addr_write & TARGET_PAGE_MASK)
             + tlb_entry->addend);
         ram_addr = qemu_ram_addr_from_host(p);
@@ -2383 +2385 @@
 {
     PhysPageDesc *p;
-    unsigned long pd;
+    ram_addr_t pd;
     unsigned int index;
     target_ulong address;
     target_ulong code_address;
-    unsigned long addend;
+    uintptr_t addend;
     CPUTLBEntry *te;
     CPUWatchpoint *wp;
@@ -2407 +2409 @@
 #if defined(DEBUG_TLB)
     printf("tlb_set_page: vaddr=" TARGET_FMT_lx " paddr=0x%08x prot=%x idx=%d size=" TARGET_FMT_lx " pd=0x%08lx\n",
-           vaddr, (int)paddr, prot, mmu_idx, size, pd);
+           vaddr, (int)paddr, prot, mmu_idx, size, (long)pd);
 #endif
 
@@ -2418 +2420 @@
     addend = pd & TARGET_PAGE_MASK;
 #elif !defined(VBOX)
-    addend = (unsigned long)qemu_get_ram_ptr(pd & TARGET_PAGE_MASK);
+    addend = (uintptr_t)qemu_get_ram_ptr(pd & TARGET_PAGE_MASK);
 #else
     /** @todo this is racing the phys_page_find call above since it may register
      *        a new chunk of memory...  */
-    addend = (unsigned long)remR3TlbGCPhys2Ptr(env, pd & TARGET_PAGE_MASK, !!(prot & PAGE_WRITE));
+    addend = (uintptr_t)remR3TlbGCPhys2Ptr(env, pd & TARGET_PAGE_MASK, !!(prot & PAGE_WRITE));
 #endif
 
@@ -2553 +2555 @@
     walk_memory_regions_fn fn;
     void *priv;
-    unsigned long start;
+    uintptr_t start;
     int prot;
 };
@@ -2614 +2616 @@
 {
     struct walk_memory_regions_data data;
-    unsigned long i;
+    target_ulong i;
 
     data.fn = fn;
@@ -2758 +2760 @@
 /* called from signal handler: invalidate the code and unprotect the
    page. Return TRUE if the fault was successfully handled. */
-int page_unprotect(target_ulong address, unsigned long pc, void *puc)
+int page_unprotect(target_ulong address, uintptr_t pc, void *puc)
 {
     unsigned int prot;
@@ -2805 +2807 @@
 
 static inline void tlb_set_dirty(CPUState *env,
-                                 unsigned long addr, target_ulong vaddr)
+                                 uintptr_t addr, target_ulong vaddr)
 {
 }
@@ -2983 +2985 @@
 #define HUGETLBFS_MAGIC       0x958458f6
 
-static long gethugepagesize(const char *path)
+static size_t gethugepagesize(const char *path)
 {
     struct statfs fs;
@@ -3000 +3002 @@
             fprintf(stderr, "Warning: path not on HugeTLBFS: %s\n", path);
 
-    return fs.f_bsize;
+    return (size_t)fs.f_bsize;
 }
 
@@ -3013 +3015 @@
     int flags;
 #endif
-    unsigned long hpagesize;
+    size_t hpagesize;
 
     hpagesize = gethugepagesize(path);
@@ -3806 +3808 @@
     uint32_t val;
     target_phys_addr_t page;
-    unsigned long pd;
+    ram_addr_t pd;
     PhysPageDesc *p;
 
@@ -3858 +3860 @@
                 }
             } else {
-                unsigned long addr1;
+                ram_addr_t addr1;
                 addr1 = (pd & TARGET_PAGE_MASK) + (addr & ~TARGET_PAGE_MASK);
                 /* RAM case */
@@ -3937 +3939 @@
     uint8_t *ptr;
     target_phys_addr_t page;
-    unsigned long pd;
+    ram_addr_t pd;
     PhysPageDesc *p;
 
@@ -3957 +3959 @@
             /* do nothing */
         } else {
-            unsigned long addr1;
+            ram_addr_t addr1;
             addr1 = (pd & TARGET_PAGE_MASK) + (addr & ~TARGET_PAGE_MASK);
             /* ROM/RAM case */
@@ -4032 +4034 @@
     uint8_t *ptr;
     target_phys_addr_t page;
-    unsigned long pd;
+    ram_addr_t pd;
     PhysPageDesc *p;
-    unsigned long addr1;
+    ram_addr_t addr1;
 
     while (len > 0) {
@@ -4121 +4123 @@
     uint8_t *ptr;
     uint32_t val;
-    unsigned long pd;
+    ram_addr_t pd;
     PhysPageDesc *p;
 
@@ -4157 +4159 @@
     uint8_t *ptr;
     uint64_t val;
-    unsigned long pd;
+    ram_addr_t pd;
     PhysPageDesc *p;
 
@@ -4205 +4207 @@
 {
     int io_index;
+#ifndef VBOX
     uint8_t *ptr;
+#endif
     uint64_t val;
-    unsigned long pd;
+    ram_addr_t pd;
     PhysPageDesc *p;
 
@@ -4244 +4248 @@
     int io_index;
     uint8_t *ptr;
-    unsigned long pd;
+    ram_addr_t pd;
     PhysPageDesc *p;
 
@@ -4261 +4265 @@
     } else {
 #ifndef VBOX
-        unsigned long addr1 = (pd & TARGET_PAGE_MASK) + (addr & ~TARGET_PAGE_MASK);
+        ram_addr_t addr1 = (pd & TARGET_PAGE_MASK) + (addr & ~TARGET_PAGE_MASK);
         ptr = qemu_get_ram_ptr(addr1);
         stl_p(ptr, val);
@@ -4286 +4290 @@
     int io_index;
     uint8_t *ptr;
-    unsigned long pd;
+    ram_addr_t pd;
     PhysPageDesc *p;
 
@@ -4323 +4327 @@
     int io_index;
     uint8_t *ptr;
-    unsigned long pd;
+    ram_addr_t pd;
     PhysPageDesc *p;
 
@@ -4339 +4343 @@
         io_mem_write[io_index][2](io_mem_opaque[io_index], addr, val);
     } else {
-        unsigned long addr1;
+        ram_addr_t addr1;
         addr1 = (pd & TARGET_PAGE_MASK) + (addr & ~TARGET_PAGE_MASK);
         /* RAM case */
@@ -4370 +4374 @@
     int io_index;
     uint8_t *ptr;
-    unsigned long pd;
+    ram_addr_t pd;
     PhysPageDesc *p;
 
@@ -4386 +4390 @@
         io_mem_write[io_index][1](io_mem_opaque[io_index], addr, val);
     } else {
-        unsigned long addr1;
+        ram_addr_t addr1;
         addr1 = (pd & TARGET_PAGE_MASK) + (addr & ~TARGET_PAGE_MASK);
         /* RAM case */
@@ -4453 +4457 @@
     uint64_t flags;
 
-    tb = tb_find_pc((unsigned long)retaddr);
+    tb = tb_find_pc((uintptr_t)retaddr);
     if (!tb) {
         cpu_abort(env, "cpu_io_recompile: could not find TB for pc=%p",
@@ -4459 +4463 @@
     }
     n = env->icount_decr.u16.low + tb->icount;
-    cpu_restore_state(tb, env, (unsigned long)retaddr, NULL);
+    cpu_restore_state(tb, env, (uintptr_t)retaddr, NULL);
     /* Calculate how many instructions had been executed before the fault
        occurred.  */

trunk/src/recompiler/gen-icount.h

@@ -30 +30 @@
         *icount_arg = num_insns;
         gen_set_label(icount_label);
-        tcg_gen_exit_tb((long)tb + 2);
+        tcg_gen_exit_tb((uintptr_t)(tb + 2));
     }
 }

trunk/src/recompiler/qemu-lock.h

@@ -101 +101 @@
 static inline int testandset (int *p)
 {
-    long int readval = 0;
+    long int64_t readval = 0;
 
     __asm__ __volatile__ ("lock; cmpxchgl %2, %0"

trunk/src/recompiler/softmmu_header.h

@@ -87 +87 @@
     RES_TYPE res;
     target_ulong addr;
-    unsigned long physaddr;
+    uintptr_t physaddr;
     int mmu_idx;
 
@@ -108 +108 @@
     int res, page_index;
     target_ulong addr;
-    unsigned long physaddr;
+    uintptr_t physaddr;
     int mmu_idx;
 
@@ -133 +133 @@
     int page_index;
     target_ulong addr;
-    unsigned long physaddr;
+    uintptr_t physaddr;
     int mmu_idx;
 

trunk/src/recompiler/softmmu_template.h

@@ -82 +82 @@
     index = (physaddr >> IO_MEM_SHIFT) & (IO_MEM_NB_ENTRIES - 1);
     physaddr = (physaddr & TARGET_PAGE_MASK) + addr;
-    env->mem_io_pc = (unsigned long)retaddr;
+    env->mem_io_pc = (uintptr_t)retaddr;
     if (index > (IO_MEM_NOTDIRTY >> IO_MEM_SHIFT)
             && !can_do_io(env)) {
@@ -120 +120 @@
     target_ulong tlb_addr;
     target_phys_addr_t ioaddr;
-    unsigned long addend;
+    uintptr_t addend;
     void *retaddr;
 
@@ -154 +154 @@
 #endif
             addend = env->tlb_table[mmu_idx][index].addend;
-            res = glue(glue(ld, USUFFIX), _raw)((uint8_t *)(long)(addr+addend));
+            res = glue(glue(ld, USUFFIX), _raw)((uint8_t *)(uintptr_t)(addr+addend));
         }
     } else {
@@ -177 +177 @@
     int index, shift;
     target_phys_addr_t ioaddr;
-    unsigned long addend;
+    uintptr_t addend;
     target_ulong tlb_addr, addr1, addr2;
 
@@ -209 +209 @@
             /* unaligned/aligned access in the same page */
             addend = env->tlb_table[mmu_idx][index].addend;
-            res = glue(glue(ld, USUFFIX), _raw)((uint8_t *)(long)(addr+addend));
+            res = glue(glue(ld, USUFFIX), _raw)((uint8_t *)(uintptr_t)(addr+addend));
         }
     } else {
@@ -240 +240 @@
 
     env->mem_io_vaddr = addr;
-    env->mem_io_pc = (unsigned long)retaddr;
+    env->mem_io_pc = (uintptr_t)retaddr;
 #if SHIFT <= 2
     io_mem_write[index][SHIFT](io_mem_opaque[index], physaddr, val);
@@ -259 +259 @@
 {
     target_phys_addr_t ioaddr;
-    unsigned long addend;
+    uintptr_t addend;
     target_ulong tlb_addr;
     void *retaddr;
@@ -292 +292 @@
 #endif
             addend = env->tlb_table[mmu_idx][index].addend;
-            glue(glue(st, SUFFIX), _raw)((uint8_t *)(long)(addr+addend), val);
+            glue(glue(st, SUFFIX), _raw)((uint8_t *)(uintptr_t)(addr+addend), val);
         }
     } else {
@@ -313 +313 @@
 {
     target_phys_addr_t ioaddr;
-    unsigned long addend;
+    uintptr_t addend;
     target_ulong tlb_addr;
     int index, i;
@@ -344 +344 @@
             /* aligned/unaligned access in the same page */
             addend = env->tlb_table[mmu_idx][index].addend;
-            glue(glue(st, SUFFIX), _raw)((uint8_t *)(long)(addr+addend), val);
+            glue(glue(st, SUFFIX), _raw)((uint8_t *)(uintptr_t)(addr+addend), val);
         }
     } else {

trunk/src/recompiler/target-i386/op_helper.c

@@ -5643 +5643 @@
     TranslationBlock *tb;
     int ret;
-    unsigned long pc;
+    uintptr_t pc;
     CPUX86State *saved_env;
 
@@ -5655 +5655 @@
         if (retaddr) {
             /* now we have a real cpu fault */
-            pc = (unsigned long)retaddr;
+            pc = (uintptr_t)retaddr;
             tb = tb_find_pc(pc);
             if (tb) {
@@ -5845 +5845 @@
 DECLINLINE(void) tb_reset_jump(TranslationBlock *tb, int n)
 {
-    tb_set_jmp_target(tb, n, (unsigned long)(tb->tc_ptr + tb->tb_next_offset[n]));
+    tb_set_jmp_target(tb, n, (uintptr_t)(tb->tc_ptr + tb->tb_next_offset[n]));
 }
 

trunk/src/recompiler/target-i386/translate.c

@@ -2480 +2480 @@
         tcg_gen_goto_tb(tb_num);
         gen_jmp_im(eip);
-        tcg_gen_exit_tb((long)tb + tb_num);
+        tcg_gen_exit_tb((intptr_t)tb + tb_num);
     } else {
         /* jump to another page: currently not optimized */
@@ -8364 +8364 @@
 
 void gen_pc_load(CPUState *env, TranslationBlock *tb,
-                unsigned long searched_pc, int pc_pos, void *puc)
+                 uintptr_t searched_pc, int pc_pos, void *puc)
 {
     int cc_op;

trunk/src/recompiler/tcg/i386/tcg-target.c

@@ -44 +44 @@
     TCG_REG_R10,
     TCG_REG_R11,
+# if !defined(VBOX) || !defined(__MINGW64__)
     TCG_REG_R9,
     TCG_REG_R8,
     TCG_REG_RCX,
     TCG_REG_RDX,
+# endif
     TCG_REG_RSI,
     TCG_REG_RDI,
+# if defined(VBOX) && defined(__MINGW64__)
+    TCG_REG_R9,
+    TCG_REG_R8,
+    TCG_REG_RDX,
+    TCG_REG_RCX,
+# endif
     TCG_REG_RAX,
 #else
@@ -64 +72 @@
 static const int tcg_target_call_iarg_regs[] = {
 #if TCG_TARGET_REG_BITS == 64
+# if defined(VBOX) && defined(__MINGW64__)
+    TCG_REG_RCX,
+    TCG_REG_RDX,
+# else
     TCG_REG_RDI,
     TCG_REG_RSI,
     TCG_REG_RDX,
     TCG_REG_RCX,
+# endif
     TCG_REG_R8,
     TCG_REG_R9,
@@ -197 +210 @@
         if (TCG_TARGET_REG_BITS == 64) {
             tcg_regset_set32(ct->u.regs, 0, 0xffff);
+#if defined(VBOX) && defined(__MINGW64__)
+            tcg_regset_reset_reg(ct->u.regs, tcg_target_call_iarg_regs[2]);
+            tcg_regset_reset_reg(ct->u.regs, tcg_target_call_iarg_regs[1]);
+            tcg_regset_reset_reg(ct->u.regs, tcg_target_call_iarg_regs[0]);
+#else
+            /** @todo figure why RDX isn't mentioned here. */
             tcg_regset_reset_reg(ct->u.regs, TCG_REG_RSI);
             tcg_regset_reset_reg(ct->u.regs, TCG_REG_RDI);
+#endif
         } else {
             tcg_regset_set32(ct->u.regs, 0, 0xff);
@@ -759 +779 @@
 }
 
-#ifdef VBOX
+#ifdef VBOX_16_BYTE_STACK_ALIGN
 static void tcg_out_subi(TCGContext *s, int reg, tcg_target_long val)
 {
@@ -1390 +1410 @@
     *label_ptr[2] = s->code_ptr - label_ptr[2] - 1;
 #else
+# if defined(VBOX) && defined(__MINGW64__)
+#  error port me
+# endif
     {
         int32_t offset = GUEST_BASE;
@@ -1526 +1549 @@
     /* XXX: move that code at the end of the TB */
     if (TCG_TARGET_REG_BITS == 64) {
+#  if defined(VBOX) && defined(__MINGW64__)
+        tcg_out_mov(s, (opc == 3 ? TCG_TYPE_I64 : TCG_TYPE_I32),
+                    tcg_target_call_iarg_regs[1], data_reg);
+        tcg_out_movi(s, TCG_TYPE_I32, tcg_target_call_iarg_regs[2], mem_index);
+#  else
         tcg_out_mov(s, (opc == 3 ? TCG_TYPE_I64 : TCG_TYPE_I32),
                     TCG_REG_RSI, data_reg);
         tcg_out_movi(s, TCG_TYPE_I32, TCG_REG_RDX, mem_index);
+#  endif
         stack_adjust = 0;
     } else if (TARGET_LONG_BITS == 32) {
@@ -1597 +1626 @@
     *label_ptr[2] = s->code_ptr - label_ptr[2] - 1;
 #else
+# if defined(VBOX) && defined(__MINGW64__)
+#  error port me
+# endif
     {
         int32_t offset = GUEST_BASE;
@@ -2092 +2124 @@
     TCG_REG_RBP,
     TCG_REG_RBX,
+# if defined(VBOX) && defined(__MINGW64__)
+    TCG_REG_RSI,
+    TCG_REG_RDI,
+# endif
     TCG_REG_R12,
     TCG_REG_R13,
@@ -2132 +2168 @@
 
     frame_size = push_size + TCG_STATIC_CALL_ARGS_SIZE;
+#if defined(VBOX) && defined(__MINGW64__)
+    frame_size += TCG_TARGET_CALL_STACK_OFFSET;
+#endif
     frame_size = (frame_size + TCG_TARGET_STACK_ALIGN - 1) &
         ~(TCG_TARGET_STACK_ALIGN - 1);
@@ -2176 +2215 @@
     tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_ECX);
     if (TCG_TARGET_REG_BITS == 64) {
+# if !defined(VBOX) || !defined(__MINGW64__)
         tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_RDI);
         tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_RSI);
+# endif
         tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_R8);
         tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_R9);

trunk/src/recompiler/tcg/i386/tcg-target.h

@@ -73 +73 @@
 #define TCG_REG_CALL_STACK TCG_REG_ESP
 #define TCG_TARGET_STACK_ALIGN 16
+#if defined(VBOX) && defined(__MINGW64__)
+# define TCG_TARGET_CALL_STACK_OFFSET 32 /* 4 qword argument/register spill zone */
+#else
 #define TCG_TARGET_CALL_STACK_OFFSET 0
+#endif
 
 /* optional instructions */
@@ -126 +130 @@
 #endif
 
-static inline void flush_icache_range(unsigned long start, unsigned long stop)
+static inline void flush_icache_range(uintptr_t start, uintptr_t stop)
 {
 }

trunk/src/recompiler/tcg/tcg-dyngen.c

@@ -52 +52 @@
 #if 0
 #if defined(__s390__)
-static inline void flush_icache_range(unsigned long start, unsigned long stop)
+static inline void flush_icache_range(uintptr_t start, uintptr_t stop)
 {
 }
 #elif defined(__ia64__)
-static inline void flush_icache_range(unsigned long start, unsigned long stop)
+static inline void flush_icache_range(uintptr_t start, uintptr_t stop)
 {
     while (start < stop) {
@@ -68 +68 @@
 #define MIN_CACHE_LINE_SIZE 8 /* conservative value */
 
-static inline void flush_icache_range(unsigned long start, unsigned long stop)
-{
-    unsigned long p;
+static inline void flush_icache_range(uintptr_t start, uintptr_t stop)
+{
+    uintptr_t p;
 
     start &= ~(MIN_CACHE_LINE_SIZE - 1);
@@ -86 +86 @@
 }
 #elif defined(__alpha__)
-static inline void flush_icache_range(unsigned long start, unsigned long stop)
+static inline void flush_icache_range(uintptr_t start, uintptr_t stop)
 {
     asm ("imb");
 }
 #elif defined(__sparc__)
-static inline void flush_icache_range(unsigned long start, unsigned long stop)
-{
-        unsigned long p;
+static inline void flush_icache_range(uintptr_t start, uintptr_t stop)
+{
+        uintptr_t p;
 
         p = start & ~(8UL - 1UL);
@@ -102 +102 @@
 }
 #elif defined(__arm__)
-static inline void flush_icache_range(unsigned long start, unsigned long stop)
-{
-    register unsigned long _beg __asm ("a1") = start;
-    register unsigned long _end __asm ("a2") = stop;
-    register unsigned long _flg __asm ("a3") = 0;
+static inline void flush_icache_range(uintptr_t start, uintptr_t stop)
+{
+    register uintptr_t _beg __asm ("a1") = start;
+    register uintptr_t _end __asm ("a2") = stop;
+    register uintptr_t _flg __asm ("a3") = 0;
     __asm __volatile__ ("swi 0x9f0002" : : "r" (_beg), "r" (_end), "r" (_flg));
 }
@@ -112 +112 @@
 
 # include <asm/cachectl.h>
-static inline void flush_icache_range(unsigned long start, unsigned long stop)
+static inline void flush_icache_range(uintptr_t start, uintptr_t stop)
 {
     cacheflush(start,FLUSH_SCOPE_LINE,FLUSH_CACHE_BOTH,stop-start+16);
@@ -119 +119 @@
 
 #include <sys/cachectl.h>
-static inline void flush_icache_range(unsigned long start, unsigned long stop)
+static inline void flush_icache_range(uintptr_t start, uintptr_t stop)
 {
     _flush_cache ((void *)start, stop - start, BCACHE);
@@ -157 +157 @@
     uint64_t m0, m1, v0, v1, b0, b1, *b = (uint64_t *) (insn_addr & -16);
 #   define insn_mask ((1UL << 41) - 1)
-    unsigned long shift;
+    uintptr_t shift;
 
     b0 = b[0]; b1 = b[1];
@@ -302 +302 @@
                                      struct ia64_fixup *plt_fixes,
                                      int num_plts,
-                                     unsigned long *plt_target,
+                                     uintptr_t *plt_target,
                                      unsigned int *plt_offset)
 {
@@ -395 +395 @@
 
     for (; stub != NULL; stub = stub->next) {
-        unsigned long l = (unsigned long)p;
+        uintptr_t l = (uintptr_t)p;
         /* stub:
          * ldil L'target, %r1

trunk/src/recompiler/tcg/tcg.c

@@ -118 +118 @@
 
 static void tcg_out_reloc(TCGContext *s, uint8_t *code_ptr, int type,
-                          int label_index, long addend)
+                          int label_index, tcg_target_long addend)
 {
     TCGLabel *l;
@@ -265 +265 @@
     s->code_ptr = s->code_buf;
     tcg_target_qemu_prologue(s);
-    flush_icache_range((unsigned long)s->code_buf,
-                       (unsigned long)s->code_ptr);
+    flush_icache_range((uintptr_t)s->code_buf,
+                       (uintptr_t)s->code_ptr);
 }
 
@@ -2004 +2004 @@
 
 static inline int tcg_gen_code_common(TCGContext *s, uint8_t *gen_code_buf,
-                                      long search_pc)
+                                      intptr_t search_pc)
 {
     TCGOpcode opc;
@@ -2096 +2096 @@
         case INDEX_op_set_label:
             tcg_reg_alloc_bb_end(s, s->reserved_regs);
-            tcg_out_label(s, args[0], (long)s->code_ptr);
+            tcg_out_label(s, args[0], (intptr_t)s->code_ptr);
             break;
         case INDEX_op_call:
@@ -2145 +2145 @@
 
     /* flush instruction cache */
-    flush_icache_range((unsigned long)gen_code_buf,
-                       (unsigned long)s->code_ptr);
+    flush_icache_range((uintptr_t)gen_code_buf,
+                       (uintptr_t)s->code_ptr);
     return s->code_ptr -  gen_code_buf;
 }
@@ -2154 +2154 @@
    not be changed, though writing the same values is ok.
    Return -1 if not found. */
-int tcg_gen_code_search_pc(TCGContext *s, uint8_t *gen_code_buf, long offset)
+int tcg_gen_code_search_pc(TCGContext *s, uint8_t *gen_code_buf, intptr_t offset)
 {
     return tcg_gen_code_common(s, gen_code_buf, offset);

trunk/src/recompiler/tcg/tcg.h

@@ -282 +282 @@
     /* goto_tb support */
     uint8_t *code_buf;
-    unsigned long *tb_next;
+    uintptr_t *tb_next;
     uint16_t *tb_next_offset;
     uint16_t *tb_jmp_offset; /* != NULL if USE_DIRECT_JUMP */
@@ -342 +342 @@
     TCGContext *s = &tcg_ctx;
     uint8_t *ptr, *ptr_end;
-    size = (size + sizeof(long) - 1) & ~(sizeof(long) - 1);
+    size = (size + sizeof(void *) - 1) & ~(sizeof(void *) - 1);
     ptr = s->pool_cur;
     ptr_end = ptr + size;
@@ -358 +358 @@
 
 int tcg_gen_code(TCGContext *s, uint8_t *gen_code_buf);
-int tcg_gen_code_search_pc(TCGContext *s, uint8_t *gen_code_buf, long offset);
+int tcg_gen_code_search_pc(TCGContext *s, uint8_t *gen_code_buf, intptr_t offset);
 
 void tcg_set_frame(TCGContext *s, int reg,
@@ -502 +502 @@
 #if defined(_ARCH_PPC) && !defined(_ARCH_PPC64)
 #define tcg_qemu_tb_exec(tb_ptr) \
-    ((long REGPARM __attribute__ ((longcall)) (*)(void *))code_gen_prologue)(tb_ptr)
-#else
-# if defined(VBOX) && defined(GCC_WITH_BUGGY_REGPARM)
+    ((intptr_t REGPARM __attribute__ ((longcall)) (*)(void *))code_gen_prologue)(tb_ptr)
+#else
+# if defined(VBOX) && defined(GCC_WITH_BUGGY_REGPARM) && !defined(__MINGW64__)
 #  define tcg_qemu_tb_exec(tb_ptr, ret)        \
     __asm__ __volatile__("call *%%ecx" : "=a"(ret) : "a"(tb_ptr), "c" (&code_gen_prologue[0]) : "memory", "%edx", "cc")
-# else  /* !VBOX || !GCC_WITH_BUGGY_REG_PARAM */
-#define tcg_qemu_tb_exec(tb_ptr) ((long REGPARM (*)(void *))code_gen_prologue)(tb_ptr)
-# endif /* !VBOX || !GCC_WITH_BUGGY_REG_PARAM */
-#endif
+# else
+#define tcg_qemu_tb_exec(tb_ptr) ((intptr_t REGPARM (*)(void *))code_gen_prologue)(tb_ptr)
+# endif
+#endif

trunk/src/recompiler/translate-all.c

@@ -56 +56 @@
     tcg_context_init(&tcg_ctx);
     tcg_set_frame(&tcg_ctx, TCG_AREG0, offsetof(CPUState, temp_buf),
-                  CPU_TEMP_BUF_NLONGS * sizeof(long));
+                  sizeof(((CPUState *)0)->temp_buf));
 }
 
@@ -132 +132 @@
  */
 int cpu_restore_state(TranslationBlock *tb,
-                      CPUState *env, unsigned long searched_pc,
+                      CPUState *env, uintptr_t searched_pc,
                       void *puc)
 {
     TCGContext *s = &tcg_ctx;
     int j;
-    unsigned long tc_ptr;
+    uintptr_t tc_ptr;
 #ifdef CONFIG_PROFILER
     int64_t ti;
@@ -157 +157 @@
 
     /* find opc index corresponding to search_pc */
-    tc_ptr = (unsigned long)tb->tc_ptr;
+    tc_ptr = (uintptr_t)tb->tc_ptr;
     if (searched_pc < tc_ptr)
         return -1;