Win64 host port

- Change long/unsigned long to intptr_t/uintptr_t where needed - Use PRIuPTR instead of %zu for printf - Rework parsing of UUIDs - Add support for Win64 ABI to TCG

Win64 host port
- Change long/unsigned long to intptr_t/uintptr_t where needed - Use PRIuPTR instead of %zu for printf - Rework parsing of UUIDs - Add support for Win64 ABI to TCG
Filip Navara
1 parent 82642adc
Showing 52 changed files with 234 additions and 200 deletions
arm-semi.c
audio/audio.c
audio/audio_template.h
audio/mixeng.c
block/qcow2.c
cache-utils.h
cpu-all.h
cpu-defs.h
cpu-exec.c
disas.c
dyngen-exec.h
exec-all.h
exec.c
gen-icount.h
hw/usb-ohci.c
migration-tcp.c
monitor.c
qemu-common.h
slirp/cksum.c
softmmu_header.h
@@ -37,6 +37,7 @@
 #include "gdbstub.h"
 #endif
  
+#undef SYS_OPEN
 #define SYS_OPEN        0x01
 #define SYS_CLOSE       0x02
 #define SYS_WRITEC      0x03
@@ -192,7 +192,8 @@ void *audio_calloc (const char *funcname, int nmemb, size_t size)
     if (audio_bug ("audio_calloc", cond)) {
         AUD_log (NULL, "%s passed invalid arguments to audio_calloc\n",
                  funcname);
-        AUD_log (NULL, "nmemb=%d size=%zu (len=%zu)\n", nmemb, size, len);
+        AUD_log (NULL, "nmemb=%d size=%" PRIuPTR " (len=%" PRIuPTR ")\n",
+                 nmemb, size, len);
         return NULL;
     }
  
@@ -804,8 +805,8 @@ static int audio_attach_capture (HWVoiceOut *hw)
  
         sc = audio_calloc (AUDIO_FUNC, 1, sizeof (*sc));
         if (!sc) {
-            dolog ("Could not allocate soft capture voice (%zu bytes)\n",
-                   sizeof (*sc));
+            dolog ("Could not allocate soft capture voice (%" PRIuPTR
+                   " bytes)\n", sizeof (*sc));
             return -1;
         }
  
@@ -1830,8 +1831,8 @@ CaptureVoiceOut *AUD_add_capture (
  
     cb = audio_calloc (AUDIO_FUNC, 1, sizeof (*cb));
     if (!cb) {
-        dolog ("Could not allocate capture callback information, size %zu\n",
-               sizeof (*cb));
+        dolog ("Could not allocate capture callback information, size %"
+               PRIuPTR "\n", sizeof (*cb));
         goto err0;
     }
     cb->ops = *ops;
@@ -1848,7 +1849,7 @@ CaptureVoiceOut *AUD_add_capture (
  
         cap = audio_calloc (AUDIO_FUNC, 1, sizeof (*cap));
         if (!cap) {
-            dolog ("Could not allocate capture voice, size %zu\n",
+            dolog ("Could not allocate capture voice, size %" PRIuPTR "\n",
                    sizeof (*cap));
             goto err1;
         }
@@ -350,7 +350,7 @@ static SW *glue (audio_pcm_create_voice_pair_, TYPE) (
  
     sw = audio_calloc (AUDIO_FUNC, 1, sizeof (*sw));
     if (!sw) {
-        dolog ("Could not allocate soft voice `%s' (%zu bytes)\n",
+        dolog ("Could not allocate soft voice `%s' (%" PRIuPTR " bytes)\n",
                sw_name ? sw_name : "unknown", sizeof (*sw));
         goto err1;
     }
@@ -301,7 +301,8 @@ void *st_rate_start (int inrate, int outrate)
     struct rate *rate = audio_calloc (AUDIO_FUNC, 1, sizeof (*rate));
  
     if (!rate) {
-        dolog ("Could not allocate resampler (%zu bytes)\n", sizeof (*rate));
+        dolog ("Could not allocate resampler (%" PRIuPTR " bytes)\n",
+               sizeof (*rate));
         return NULL;
     }
  
@@ -96,8 +96,8 @@ static int qcow_read_extensions(BlockDriverState *bs, uint64_t start_offset,
 #endif
  
         if (bdrv_pread(s->hd, offset, &ext, sizeof(ext)) != sizeof(ext)) {
-            fprintf(stderr, "qcow_handle_extension: ERROR: pread fail from offset %llu\n",
-                    (unsigned long long)offset);
+            fprintf(stderr, "qcow_handle_extension: ERROR: pread fail from"
+                    " offset %" PRIu64 "\n", offset);
             return 1;
         }
         be32_to_cpus(&ext.magic);
@@ -113,7 +113,7 @@ static int qcow_read_extensions(BlockDriverState *bs, uint64_t start_offset,
         case QCOW_EXT_MAGIC_BACKING_FORMAT:
             if (ext.len >= sizeof(bs->backing_format)) {
                 fprintf(stderr, "ERROR: ext_backing_format: len=%u too large"
-                        " (>=%zu)\n",
+                        " (>=%" PRIuPTR ")\n",
                         ext.len, sizeof(bs->backing_format));
                 return 2;
             }
@@ -12,11 +12,11 @@ extern struct qemu_cache_conf qemu_cache_conf;
 extern void qemu_cache_utils_init(char **envp);
  
 /* 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;
-    unsigned long dsize = qemu_cache_conf.dcache_bsize;
-    unsigned long isize = qemu_cache_conf.icache_bsize;
+    uintptr_t p, start1, stop1;
+    uintptr_t dsize = qemu_cache_conf.dcache_bsize;
+    uintptr_t isize = qemu_cache_conf.icache_bsize;
  
     start1 = start & ~(dsize - 1);
     stop1 = (stop + dsize - 1) & ~(dsize - 1);
@@ -651,8 +651,8 @@ extern int have_guest_base;
 #else /* !CONFIG_USER_ONLY */
 /* 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
  
 #define ldub_raw(p) ldub_p(laddr((p)))
@@ -141,8 +141,8 @@ typedef struct CPUWatchpoint {
     /* in order to avoid passing too many arguments to the MMIO         \
        helpers, we store some rarely used information in the CPU        \
        context) */                                                      \
-    unsigned long mem_io_pc; /* host pc at which the memory was         \
-                                accessed */                             \
+    uintptr_t mem_io_pc; /* host pc at which the memory was             \
+                            accessed */                                 \
     target_ulong mem_io_vaddr; /* target virtual addr at which the      \
                                      memory was accessed */             \
     uint32_t halted; /* Nonzero if the CPU is in suspend state */       \
@@ -94,7 +94,7 @@ void cpu_resume_from_signal(CPUState *env1, void *puc)
    could be used if available. */
 static void cpu_exec_nocache(int max_cycles, TranslationBlock *orig_tb)
 {
-    unsigned long next_tb;
+    uintptr_t next_tb;
     TranslationBlock *tb;
  
     /* Should never happen.
@@ -213,7 +213,7 @@ int cpu_exec(CPUState *env1)
     int ret, interrupt_request;
     TranslationBlock *tb;
     uint8_t *tc_ptr;
-    unsigned long next_tb;
+    uintptr_t next_tb;
  
     if (cpu_halted(env1) == EXCP_HALTED)
         return EXCP_HALTED;
@@ -608,8 +608,8 @@ int cpu_exec(CPUState *env1)
                     tb_invalidated_flag = 0;
                 }
 #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 0x%08Ix [" TARGET_FMT_lx "] %s\n",
+                             (intptr_t)tb->tc_ptr, tb->pc,
                              lookup_symbol(tb->pc));
 #endif
                 /* see if we can patch the calling TB. When the TB
@@ -647,7 +647,7 @@ int cpu_exec(CPUState *env1)
                     if ((next_tb & 3) == 2) {
                         /* Instruction counter expired.  */
                         int insns_left;
-                        tb = (TranslationBlock *)(long)(next_tb & ~3);
+                        tb = (TranslationBlock *)(intptr_t)(next_tb & ~3);
                         /* Restore PC.  */
                         cpu_pc_from_tb(env, tb);
                         insns_left = env->icount_decr.u32;
@@ -235,7 +235,7 @@ void target_disas(FILE *out, target_ulong code, target_ulong size, int flags)
 /* Disassemble this for me please... (debugging). */
 void disas(FILE *out, void *code, unsigned long size)
 {
-    unsigned long pc;
+    uintptr_t pc;
     int count;
     struct disassemble_info disasm_info;
     int (*print_insn)(bfd_vma pc, disassemble_info *info);
@@ -243,7 +243,7 @@ void disas(FILE *out, void *code, unsigned long size)
     INIT_DISASSEMBLE_INFO(disasm_info, out, fprintf);
  
     disasm_info.buffer = code;
-    disasm_info.buffer_vma = (unsigned long)code;
+    disasm_info.buffer_vma = (uintptr_t)code;
     disasm_info.buffer_length = size;
  
 #ifdef HOST_WORDS_BIGENDIAN
@@ -283,8 +283,8 @@ void disas(FILE *out, void *code, unsigned long size)
 	    (long) code);
     return;
 #endif
-    for (pc = (unsigned long)code; size > 0; pc += count, size -= count) {
-	fprintf(out, "0x%08lx:  ", pc);
+    for (pc = (uintptr_t)code; size > 0; pc += count, size -= count) {
+	fprintf(out, "0x%08Ix:  ", pc);
 #ifdef __arm__
         /* since data is included in the code, it is better to
            display code data too */
@@ -94,13 +94,13 @@ extern int printf(const char *, ...);
 /* The return address may point to the start of the next instruction.
    Subtracting one gets us the call instruction itself.  */
 #if defined(__s390__)
-# 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
  
 #endif /* !defined(__DYNGEN_EXEC_H__) */
@@ -61,17 +61,17 @@ extern uint32_t gen_opc_hflags[OPC_BUF_SIZE];
 void gen_intermediate_code(CPUState *env, struct TranslationBlock *tb);
 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);
  
-unsigned long code_gen_max_block_size(void);
+uintptr_t code_gen_max_block_size(void);
 void cpu_gen_init(void);
 int cpu_gen_code(CPUState *env, struct TranslationBlock *tb,
                  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);
 int cpu_restore_state_copy(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);
 void cpu_io_recompile(CPUState *env, void *retaddr);
@@ -80,7 +80,7 @@ TranslationBlock *tb_gen_code(CPUState *env,
                               int cflags);
 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(target_phys_addr_t start, target_phys_addr_t end,
                                    int is_cpu_write_access);
 void tb_invalidate_page_range(target_ulong start, target_ulong end);
@@ -142,7 +142,7 @@ struct TranslationBlock {
 #ifdef USE_DIRECT_JUMP
     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
        the two least significant bits of the pointers to tell what is
@@ -168,7 +168,7 @@ static inline unsigned int tb_jmp_cache_hash_func(target_ulong pc)
 	    | (tmp & TB_JMP_ADDR_MASK));
 }
  
-static inline unsigned int tb_phys_hash_func(unsigned long pc)
+static inline unsigned int tb_phys_hash_func(uintptr_t pc)
 {
     return pc & (CODE_GEN_PHYS_HASH_SIZE - 1);
 }
@@ -187,17 +187,17 @@ extern int code_gen_max_blocks;
 #if defined(USE_DIRECT_JUMP)
  
 #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 */
     *(uint32_t *)jmp_addr = addr - (jmp_addr + 4);
     /* no need to flush icache explicitly */
 }
 #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)
     void __clear_cache(char *beg, char *end);
@@ -223,19 +223,19 @@ static inline void tb_set_jmp_target1(unsigned long jmp_addr, unsigned long addr
 #endif
  
 static inline void tb_set_jmp_target(TranslationBlock *tb,
-                                     int n, unsigned long addr)
+                                     int n, uintptr_t addr)
 {
-    unsigned long offset;
+    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);
 }
  
 #else
  
 /* 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;
 }
@@ -248,15 +248,15 @@ static inline void tb_add_jump(TranslationBlock *tb, int n,
     /* NOTE: this test is only needed for thread safety */
     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 *)((uintptr_t)(tb) | (n));
     }
 }
  
-TranslationBlock *tb_find_pc(unsigned long pc_ptr);
+TranslationBlock *tb_find_pc(uintptr_t pc_ptr);
  
 extern CPUWriteMemoryFunc *io_mem_write[IO_MEM_NB_ENTRIES][4];
 extern CPUReadMemoryFunc *io_mem_read[IO_MEM_NB_ENTRIES][4];
@@ -325,7 +325,7 @@ static inline target_ulong get_phys_addr_code(CPUState *env1, target_ulong addr)
         cpu_abort(env1, "Trying to execute code outside RAM or ROM at 0x" TARGET_FMT_lx "\n", addr);
 #endif
     }
-    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);
 }
@@ -706,8 +706,8 @@ static inline void tb_page_remove(TranslationBlock **ptb, TranslationBlock *tb)
  
     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];
             break;
@@ -727,8 +727,8 @@ static inline void tb_jmp_remove(TranslationBlock *tb, int n)
         /* find tb(n) in circular list */
         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;
             if (n1 == 2) {
@@ -748,7 +748,7 @@ static inline void tb_jmp_remove(TranslationBlock *tb, int n)
    another TB */
 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]));
 }
  
 void tb_phys_invalidate(TranslationBlock *tb, target_ulong page_addr)
@@ -793,16 +793,16 @@ void tb_phys_invalidate(TranslationBlock *tb, target_ulong page_addr)
     /* suppress any remaining jumps to this TB */
     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);
         tb1->jmp_next[n1] = NULL;
         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++;
 }
@@ -843,8 +843,8 @@ static void build_page_bitmap(PageDesc *p)
  
     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) {
             /* NOTE: tb_end may be after the end of the page, but
@@ -887,7 +887,7 @@ TranslationBlock *tb_gen_code(CPUState *env,
     tb->flags = flags;
     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 */
     virt_page2 = (pc + tb->size - 1) & TARGET_PAGE_MASK;
@@ -935,8 +935,8 @@ void tb_invalidate_phys_page_range(target_phys_addr_t start, target_phys_addr_t 
     /* XXX: see if in some cases it could be faster to invalidate all the code */
     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 */
         if (n == 0) {
@@ -1039,7 +1039,7 @@ static inline void tb_invalidate_phys_page_fast(target_phys_addr_t start, int le
  
 #if !defined(CONFIG_SOFTMMU)
 static void tb_invalidate_phys_page(target_phys_addr_t addr,
-                                    unsigned long pc, void *puc)
+                                    uintptr_t pc, void *puc)
 {
     TranslationBlock *tb;
     PageDesc *p;
@@ -1064,8 +1064,8 @@ static void tb_invalidate_phys_page(target_phys_addr_t addr,
     }
 #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 &&
             (current_tb->cflags & CF_COUNT_MASK) != 1) {
@@ -1109,7 +1109,7 @@ static inline void tb_alloc_page(TranslationBlock *tb,
     p = page_find_alloc(page_addr >> TARGET_PAGE_BITS);
     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);
  
 #if defined(TARGET_HAS_SMC) || 1
@@ -1203,7 +1203,7 @@ void tb_link_phys(TranslationBlock *tb,
     else
         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;
  
@@ -1221,16 +1221,16 @@ void tb_link_phys(TranslationBlock *tb,
  
 /* 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) */
     m_min = 0;
@@ -1238,7 +1238,7 @@ TranslationBlock *tb_find_pc(unsigned long tc_ptr)
     while (m_min <= m_max) {
         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;
         else if (tc_ptr < v) {
@@ -1261,8 +1261,8 @@ static inline void tb_reset_jump_recursive2(TranslationBlock *tb, int n)
     if (tb1 != NULL) {
         /* 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;
             tb1 = tb1->jmp_next[n1];
@@ -1274,8 +1274,8 @@ static inline void tb_reset_jump_recursive2(TranslationBlock *tb, int n)
         ptb = &tb_next->jmp_first;
         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;
             ptb = &tb1->jmp_next[n1];
@@ -1843,7 +1843,7 @@ void cpu_physical_memory_reset_dirty(ram_addr_t start, ram_addr_t end,
                                      int dirty_flags)
 {
     CPUState *env;
-    unsigned long length, start1;
+    uintptr_t length, start1;
     int i, mask, len;
     uint8_t *p;
  
@@ -1873,10 +1873,10 @@ void cpu_physical_memory_reset_dirty(ram_addr_t start, ram_addr_t end,
  
     /* we modify the TLB cache so that the dirty bit will be set again
        when accessing the range */
-    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();
     }
@@ -1921,7 +1921,7 @@ static inline void tlb_update_dirty(CPUTLBEntry *tlb_entry)
     void *p;
  
     if ((tlb_entry->addr_write & ~TARGET_PAGE_MASK) == IO_MEM_RAM) {
-        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);
         if (!cpu_physical_memory_is_dirty(ram_addr)) {
@@ -1996,7 +1996,7 @@ int tlb_set_page_exec(CPUState *env, target_ulong vaddr,
         /* IO memory case (romd handled later) */
         address |= TLB_MMIO;
     }
-    addend = (unsigned long)qemu_get_ram_ptr(pd & TARGET_PAGE_MASK);
+    addend = (uintptr_t)qemu_get_ram_ptr(pd & TARGET_PAGE_MASK);
     if ((pd & ~TARGET_PAGE_MASK) <= IO_MEM_ROM) {
         /* Normal RAM.  */
         iotlb = pd & TARGET_PAGE_MASK;
@@ -3634,13 +3634,13 @@ void cpu_io_recompile(CPUState *env, void *retaddr)
     target_ulong pc, cs_base;
     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", 
                   retaddr);
     }
     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.  */
     n = n - env->icount_decr.u16.low;
@@ -27,7 +27,7 @@ static void gen_icount_end(TranslationBlock *tb, int num_insns)
     if (use_icount) {
         *icount_arg = num_insns;
         gen_set_label(icount_label);
-        tcg_gen_exit_tb((long)tb + 2);
+        tcg_gen_exit_tb((intptr_t)tb + 2);
     }
 }
  
@@ -765,8 +765,9 @@ static int ohci_service_iso_td(OHCIState *ohci, struct ohci_ed *ed,
     }
  
 #ifdef DEBUG_ISOCH
-    printf("so 0x%.8x eo 0x%.8x\nsa 0x%.8x ea 0x%.8x\ndir %s len %zu ret %d\n",
-           start_offset, end_offset, start_addr, end_addr, str, len, ret);
+    printf("so 0x%.8x eo 0x%.8x\nsa 0x%.8x ea 0x%.8x\ndir %s len %" PRIuPTR
+           " ret %d\n", start_offset, end_offset, start_addr, end_addr, str,
+           len, ret);
 #endif
  
     /* Writeback */
@@ -783,7 +784,7 @@ static int ohci_service_iso_td(OHCIState *ohci, struct ohci_ed *ed,
         OHCI_SET_BM(iso_td.offset[relative_frame_number], TD_PSW_SIZE, 0);
     } else {
         if (ret > (ssize_t) len) {
-            printf("usb-ohci: DataOverrun %d > %zu\n", ret, len);
+            printf("usb-ohci: DataOverrun %d > %" PRIuPTR "\n", ret, len);
             OHCI_SET_BM(iso_td.offset[relative_frame_number], TD_PSW_CC,
                         OHCI_CC_DATAOVERRUN);
             OHCI_SET_BM(iso_td.offset[relative_frame_number], TD_PSW_SIZE,
@@ -134,7 +134,7 @@ static void tcp_accept_incoming_migration(void *opaque)
 {
     struct sockaddr_in addr;
     socklen_t addrlen = sizeof(addr);
-    int s = (unsigned long)opaque;
+    int s = (intptr_t)opaque;
     QEMUFile *f;
     int c, ret;
  
@@ -200,7 +200,7 @@ int tcp_start_incoming_migration(const char *host_port)
         goto err;
  
     qemu_set_fd_handler2(s, NULL, tcp_accept_incoming_migration, NULL,
-                         (void *)(unsigned long)s);
+                         (void *)(intptr_t)s);
  
     return 0;
  
@@ -2740,9 +2740,9 @@ static void monitor_handle_command(Monitor *mon, const char *cmdline)
                 }
                 if (nb_args + 3 > MAX_ARGS)
                     goto error_args;
-                args[nb_args++] = (void*)(long)count;
-                args[nb_args++] = (void*)(long)format;
-                args[nb_args++] = (void*)(long)size;
+                args[nb_args++] = (void*)(intptr_t)count;
+                args[nb_args++] = (void*)(intptr_t)format;
+                args[nb_args++] = (void*)(intptr_t)size;
             }
             break;
         case 'i':
@@ -2771,7 +2771,7 @@ static void monitor_handle_command(Monitor *mon, const char *cmdline)
                     typestr++;
                     if (nb_args >= MAX_ARGS)
                         goto error_args;
-                    args[nb_args++] = (void *)(long)has_arg;
+                    args[nb_args++] = (void *)(intptr_t)has_arg;
                     if (!has_arg) {
                         if (nb_args >= MAX_ARGS)
                             goto error_args;
@@ -2785,16 +2785,16 @@ static void monitor_handle_command(Monitor *mon, const char *cmdline)
                 if (c == 'i') {
                     if (nb_args >= MAX_ARGS)
                         goto error_args;
-                    args[nb_args++] = (void *)(long)val;
+                    args[nb_args++] = (void *)(intptr_t)val;
                 } else {
                     if ((nb_args + 1) >= MAX_ARGS)
                         goto error_args;
 #if TARGET_PHYS_ADDR_BITS > 32
-                    args[nb_args++] = (void *)(long)((val >> 32) & 0xffffffff);
+                    args[nb_args++] = (void *)(intptr_t)((val >> 32) & 0xffffffff);
 #else
                     args[nb_args++] = (void *)0;
 #endif
-                    args[nb_args++] = (void *)(long)(val & 0xffffffff);
+                    args[nb_args++] = (void *)(intptr_t)(val & 0xffffffff);
                 }
             }
             break;
@@ -2821,7 +2821,7 @@ static void monitor_handle_command(Monitor *mon, const char *cmdline)
                 }
                 if (nb_args >= MAX_ARGS)
                     goto error_args;
-                args[nb_args++] = (void *)(long)has_option;
+                args[nb_args++] = (void *)(intptr_t)has_option;
             }
             break;
         default:
@@ -64,10 +64,6 @@ static inline char *realpath(const char *path, char *resolved_path)
     return resolved_path;
 }
  
-#define PRId64 "I64d"
-#define PRIx64 "I64x"
-#define PRIu64 "I64u"
-#define PRIo64 "I64o"
 #endif
  
 /* FIXME: Remove NEED_CPU_H.  */
@@ -72,7 +72,7 @@ int cksum(struct mbuf *m, int len)
 	/*
 	 * Force to even boundary.
 	 */
-	if ((1 & (long) w) && (mlen > 0)) {
+	if ((1 & (intptr_t) w) && (mlen > 0)) {
 		REDUCE;
 		sum <<= 8;
 		s_util.c[0] = *(u_int8_t *)w;
@@ -76,7 +76,7 @@ static inline RES_TYPE glue(glue(ld, USUFFIX), MEMSUFFIX)(target_ulong ptr)
     int page_index;
     RES_TYPE res;
     target_ulong addr;
-    unsigned long physaddr;
+    uintptr_t physaddr;
     int mmu_idx;
  
     addr = ptr;
@@ -87,7 +87,7 @@ static inline RES_TYPE glue(glue(ld, USUFFIX), MEMSUFFIX)(target_ulong ptr)
         res = glue(glue(__ld, SUFFIX), MMUSUFFIX)(addr, mmu_idx);
     } else {
         physaddr = addr + env->tlb_table[mmu_idx][page_index].addend;
-        res = glue(glue(ld, USUFFIX), _raw)((uint8_t *)physaddr);
+        res = glue(glue(ld, USUFFIX), _raw)(physaddr);
     }
     return res;
 }
@@ -97,7 +97,7 @@ static inline int glue(glue(lds, SUFFIX), MEMSUFFIX)(target_ulong ptr)
 {
     int res, page_index;
     target_ulong addr;
-    unsigned long physaddr;
+    uintptr_t physaddr;
     int mmu_idx;
  
     addr = ptr;
@@ -108,7 +108,7 @@ static inline int glue(glue(lds, SUFFIX), MEMSUFFIX)(target_ulong ptr)
         res = (DATA_STYPE)glue(glue(__ld, SUFFIX), MMUSUFFIX)(addr, mmu_idx);
     } else {
         physaddr = addr + env->tlb_table[mmu_idx][page_index].addend;
-        res = glue(glue(lds, SUFFIX), _raw)((uint8_t *)physaddr);
+        res = glue(glue(lds, SUFFIX), _raw)(physaddr);
     }
     return res;
 }
@@ -122,7 +122,7 @@ static inline void glue(glue(st, SUFFIX), MEMSUFFIX)(target_ulong ptr, RES_TYPE 
 {
     int page_index;
     target_ulong addr;
-    unsigned long physaddr;
+    uintptr_t physaddr;
     int mmu_idx;
  
     addr = ptr;
@@ -133,7 +133,7 @@ static inline void glue(glue(st, SUFFIX), MEMSUFFIX)(target_ulong ptr, RES_TYPE 
         glue(glue(__st, SUFFIX), MMUSUFFIX)(addr, v, mmu_idx);
     } else {
         physaddr = addr + env->tlb_table[mmu_idx][page_index].addend;
-        glue(glue(st, SUFFIX), _raw)((uint8_t *)physaddr, v);
+        glue(glue(st, SUFFIX), _raw)(physaddr, v);
     }
 }
  
@@ -57,7 +57,7 @@ static inline DATA_TYPE glue(io_read, SUFFIX)(target_phys_addr_t physaddr,
     int index;
     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)) {
         cpu_io_recompile(env, retaddr);
@@ -122,7 +122,7 @@ DATA_TYPE REGPARM glue(glue(__ld, SUFFIX), MMUSUFFIX)(target_ulong addr,
             }
 #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 *)(intptr_t)(addr+addend));
         }
     } else {
         /* the page is not in the TLB : fill it */
@@ -177,7 +177,7 @@ static DATA_TYPE glue(glue(slow_ld, SUFFIX), MMUSUFFIX)(target_ulong addr,
         } else {
             /* 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 *)(intptr_t)(addr+addend));
         }
     } else {
         /* the page is not in the TLB : fill it */
@@ -208,7 +208,7 @@ static inline void glue(io_write, SUFFIX)(target_phys_addr_t physaddr,
     }
  
     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);
 #else
@@ -262,7 +262,7 @@ void REGPARM glue(glue(__st, SUFFIX), MMUSUFFIX)(target_ulong addr,
             }
 #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 *)(intptr_t)(addr+addend), val);
         }
     } else {
         /* the page is not in the TLB : fill it */
@@ -313,7 +313,7 @@ static void glue(glue(slow_st, SUFFIX), MMUSUFFIX)(target_ulong addr,
         } else {
             /* 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 *)(intptr_t)(addr+addend), val);
         }
     } else {
         /* the page is not in the TLB : fill it */
@@ -21,7 +21,7 @@ extern int vm_running;
 extern const char *qemu_name;
 extern uint8_t qemu_uuid[];
 int qemu_uuid_parse(const char *str, uint8_t *uuid);
-#define UUID_FMT "%02hhx%02hhx%02hhx%02hhx-%02hhx%02hhx-%02hhx%02hhx-%02hhx%02hhx-%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx"
+#define UUID_FMT "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x"
  
 typedef struct vm_change_state_entry VMChangeStateEntry;
 typedef void VMChangeStateHandler(void *opaque, int running, int reason);
@@ -1170,7 +1170,7 @@ void tlb_fill (target_ulong addr, int is_write, int mmu_idx, void *retaddr)
 {
     TranslationBlock *tb;
     CPUState *saved_env;
-    unsigned long pc;
+    uintptr_t pc;
     int ret;
  
     /* XXX: hack to restore env in all cases, even if not called from
@@ -1181,7 +1181,7 @@ void tlb_fill (target_ulong addr, int is_write, int mmu_idx, void *retaddr)
     if (!likely(ret == 0)) {
         if (likely(retaddr)) {
             /* now we have a real cpu fault */
-            pc = (unsigned long)retaddr;
+            pc = (uintptr_t)retaddr;
             tb = tb_find_pc(pc);
             if (likely(tb)) {
                 /* the PC is inside the translated code. It means that we have
@@ -2509,7 +2509,7 @@ CPUAlphaState * cpu_alpha_init (const char *cpu_model)
 }
  
 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)
 {
     env->pc = gen_opc_pc[pc_pos];
 }
@@ -88,7 +88,7 @@ void tlb_fill (target_ulong addr, int is_write, int mmu_idx, void *retaddr)
 {
     TranslationBlock *tb;
     CPUState *saved_env;
-    unsigned long pc;
+    uintptr_t pc;
     int ret;
  
     /* XXX: hack to restore env in all cases, even if not called from
@@ -99,7 +99,7 @@ void tlb_fill (target_ulong addr, int is_write, int mmu_idx, void *retaddr)
     if (unlikely(ret)) {
         if (retaddr) {
             /* now we have a real cpu fault */
-            pc = (unsigned long)retaddr;
+            pc = (uintptr_t)retaddr;
             tb = tb_find_pc(pc);
             if (tb) {
                 /* the PC is inside the translated code. It means that we have
@@ -3198,7 +3198,7 @@ static inline void gen_goto_tb(DisasContext *s, int n, uint32_t dest)
     if ((tb->pc & TARGET_PAGE_MASK) == (dest & TARGET_PAGE_MASK)) {
         tcg_gen_goto_tb(n);
         gen_set_pc_im(dest);
-        tcg_gen_exit_tb((long)tb + n);
+        tcg_gen_exit_tb((intptr_t)tb + n);
     } else {
         gen_set_pc_im(dest);
         tcg_gen_exit_tb(0);
@@ -9027,7 +9027,7 @@ void cpu_dump_state(CPUState *env, FILE *f,
 }
  
 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)
 {
     env->regs[15] = gen_opc_pc[pc_pos];
 }
@@ -58,7 +58,7 @@ void tlb_fill (target_ulong addr, int is_write, int mmu_idx, void *retaddr)
 {
     TranslationBlock *tb;
     CPUState *saved_env;
-    unsigned long pc;
+    uintptr_t pc;
     int ret;
  
     /* XXX: hack to restore env in all cases, even if not called from
@@ -72,7 +72,7 @@ void tlb_fill (target_ulong addr, int is_write, int mmu_idx, void *retaddr)
     if (unlikely(ret)) {
         if (retaddr) {
             /* now we have a real cpu fault */
-            pc = (unsigned long)retaddr;
+            pc = (uintptr_t)retaddr;
             tb = tb_find_pc(pc);
             if (tb) {
                 /* the PC is inside the translated code. It means that we have
@@ -523,7 +523,7 @@ static void gen_goto_tb(DisasContext *dc, int n, target_ulong dest)
 	if ((tb->pc & TARGET_PAGE_MASK) == (dest & TARGET_PAGE_MASK)) {
 		tcg_gen_goto_tb(n);
 		tcg_gen_movi_tl(env_pc, dest);
-		tcg_gen_exit_tb((long)tb + n);
+		tcg_gen_exit_tb((intptr_t)tb + n);
 	} else {
 		tcg_gen_movi_tl(env_pc, dest);
 		tcg_gen_exit_tb(0);
@@ -3478,7 +3478,7 @@ void cpu_reset (CPUCRISState *env)
 }
  
 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)
 {
 	env->pc = gen_opc_pc[pc_pos];
 }
@@ -4830,7 +4830,7 @@ void tlb_fill(target_ulong addr, int is_write, int mmu_idx, void *retaddr)
 {
     TranslationBlock *tb;
     int ret;
-    unsigned long pc;
+    uintptr_t pc;
     CPUX86State *saved_env;
  
     /* XXX: hack to restore env in all cases, even if not called from
@@ -4842,7 +4842,7 @@ void tlb_fill(target_ulong addr, int is_write, int mmu_idx, void *retaddr)
     if (ret) {
         if (retaddr) {
             /* now we have a real cpu fault */
-            pc = (unsigned long)retaddr;
+            pc = (uintptr_t)retaddr;
             tb = tb_find_pc(pc);
             if (tb) {
                 /* the PC is inside the translated code. It means that we have
@@ -2293,7 +2293,7 @@ static inline void gen_goto_tb(DisasContext *s, int tb_num, target_ulong eip)
         /* jump to same page: we can use a direct jump */
         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 */
         gen_jmp_im(eip);
@@ -7787,7 +7787,7 @@ void gen_intermediate_code_pc(CPUState *env, TranslationBlock *tb)
 }
  
 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;
 #ifdef DEBUG_DISAS
@@ -7799,7 +7799,7 @@ void gen_pc_load(CPUState *env, TranslationBlock *tb,
                 qemu_log("0x%04x: " TARGET_FMT_lx "\n", i, gen_opc_pc[i]);
             }
         }
-        qemu_log("spc=0x%08lx pc_pos=0x%x eip=" TARGET_FMT_lx " cs_base=%x\n",
+        qemu_log("spc=0x%08Ix pc_pos=0x%x eip=" TARGET_FMT_lx " cs_base=%x\n",
                 searched_pc, pc_pos, gen_opc_pc[pc_pos] - tb->cs_base,
                 (uint32_t)tb->cs_base);
     }
@@ -52,7 +52,7 @@ void tlb_fill (target_ulong addr, int is_write, int mmu_idx, void *retaddr)
 {
     TranslationBlock *tb;
     CPUState *saved_env;
-    unsigned long pc;
+    uintptr_t pc;
     int ret;
  
     /* XXX: hack to restore env in all cases, even if not called from
@@ -63,7 +63,7 @@ void tlb_fill (target_ulong addr, int is_write, int mmu_idx, void *retaddr)
     if (unlikely(ret)) {
         if (retaddr) {
             /* now we have a real cpu fault */
-            pc = (unsigned long)retaddr;
+            pc = (uintptr_t)retaddr;
             tb = tb_find_pc(pc);
             if (tb) {
                 /* the PC is inside the translated code. It means that we have
@@ -862,7 +862,7 @@ static void gen_jmp_tb(DisasContext *s, int n, uint32_t dest)
                (s->pc & TARGET_PAGE_MASK) == (dest & TARGET_PAGE_MASK)) {
         tcg_gen_goto_tb(n);
         tcg_gen_movi_i32(QREG_PC, dest);
-        tcg_gen_exit_tb((long)tb + n);
+        tcg_gen_exit_tb((intptr_t)tb + n);
     } else {
         gen_jmp_im(s, dest);
         tcg_gen_exit_tb(0);
@@ -3118,7 +3118,7 @@ void cpu_dump_state(CPUState *env, FILE *f,
 }
  
 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)
 {
     env->pc = gen_opc_pc[pc_pos];
 }
@@ -43,7 +43,7 @@ void tlb_fill (target_ulong addr, int is_write, int mmu_idx, void *retaddr)
 {
     TranslationBlock *tb;
     CPUState *saved_env;
-    unsigned long pc;
+    uintptr_t pc;
     int ret;
  
     /* XXX: hack to restore env in all cases, even if not called from
@@ -55,7 +55,7 @@ void tlb_fill (target_ulong addr, int is_write, int mmu_idx, void *retaddr)
     if (unlikely(ret)) {
         if (retaddr) {
             /* now we have a real cpu fault */
-            pc = (unsigned long)retaddr;
+            pc = (uintptr_t)retaddr;
             tb = tb_find_pc(pc);
             if (tb) {
                 /* the PC is inside the translated code. It means that we have
@@ -146,7 +146,7 @@ static void gen_goto_tb(DisasContext *dc, int n, target_ulong dest)
     if ((tb->pc & TARGET_PAGE_MASK) == (dest & TARGET_PAGE_MASK)) {
         tcg_gen_goto_tb(n);
         tcg_gen_movi_tl(cpu_SR[SR_PC], dest);
-        tcg_gen_exit_tb((long)tb + n);
+        tcg_gen_exit_tb((intptr_t)tb + n);
     } else {
         tcg_gen_movi_tl(cpu_SR[SR_PC], dest);
         tcg_gen_exit_tb(0);
@@ -1388,7 +1388,7 @@ void cpu_reset (CPUState *env)
 }
  
 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)
 {
     env->sregs[SR_PC] = gen_opc_pc[pc_pos];
 }
@@ -1822,7 +1822,7 @@ void tlb_fill (target_ulong addr, int is_write, int mmu_idx, void *retaddr)
 {
     TranslationBlock *tb;
     CPUState *saved_env;
-    unsigned long pc;
+    uintptr_t pc;
     int ret;
  
     /* XXX: hack to restore env in all cases, even if not called from
@@ -1833,7 +1833,7 @@ void tlb_fill (target_ulong addr, int is_write, int mmu_idx, void *retaddr)
     if (ret) {
         if (retaddr) {
             /* now we have a real cpu fault */
-            pc = (unsigned long)retaddr;
+            pc = (uintptr_t)retaddr;
             tb = tb_find_pc(pc);
             if (tb) {
                 /* the PC is inside the translated code. It means that we have
@@ -2462,7 +2462,7 @@ static inline void gen_goto_tb(DisasContext *ctx, int n, target_ulong dest)
     if ((tb->pc & TARGET_PAGE_MASK) == (dest & TARGET_PAGE_MASK)) {
         tcg_gen_goto_tb(n);
         gen_save_pc(dest);
-        tcg_gen_exit_tb((long)tb + n);
+        tcg_gen_exit_tb((intptr_t)tb + n);
     } else {
         gen_save_pc(dest);
         tcg_gen_exit_tb(0);
@@ -8640,7 +8640,7 @@ void cpu_reset (CPUMIPSState *env)
 }
  
 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)
 {
     env->active_tc.PC = gen_opc_pc[pc_pos];
     env->hflags &= ~MIPS_HFLAG_BMASK;
@@ -3714,7 +3714,7 @@ void tlb_fill (target_ulong addr, int is_write, int mmu_idx, void *retaddr)
 {
     TranslationBlock *tb;
     CPUState *saved_env;
-    unsigned long pc;
+    uintptr_t pc;
     int ret;
  
     /* XXX: hack to restore env in all cases, even if not called from
@@ -3725,7 +3725,7 @@ void tlb_fill (target_ulong addr, int is_write, int mmu_idx, void *retaddr)
     if (unlikely(ret != 0)) {
         if (likely(retaddr)) {
             /* now we have a real cpu fault */
-            pc = (unsigned long)retaddr;
+            pc = (uintptr_t)retaddr;
             tb = tb_find_pc(pc);
             if (likely(tb)) {
                 /* the PC is inside the translated code. It means that we have
@@ -3298,7 +3298,7 @@ static always_inline void gen_goto_tb (DisasContext *ctx, int n,
         likely(!ctx->singlestep_enabled)) {
         tcg_gen_goto_tb(n);
         tcg_gen_movi_tl(cpu_nip, dest & ~3);
-        tcg_gen_exit_tb((long)tb + n);
+        tcg_gen_exit_tb((intptr_t)tb + n);
     } else {
         tcg_gen_movi_tl(cpu_nip, dest & ~3);
         if (unlikely(ctx->singlestep_enabled)) {
@@ -9098,7 +9098,7 @@ void gen_intermediate_code_pc (CPUState *env, struct TranslationBlock *tb)
 }
  
 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)
 {
     env->nip = gen_opc_pc[pc_pos];
 }
@@ -41,7 +41,7 @@ void tlb_fill(target_ulong addr, int is_write, int mmu_idx, void *retaddr)
 {
     TranslationBlock *tb;
     CPUState *saved_env;
-    unsigned long pc;
+    uintptr_t pc;
     int ret;
  
     /* XXX: hack to restore env in all cases, even if not called from
@@ -52,7 +52,7 @@ void tlb_fill(target_ulong addr, int is_write, int mmu_idx, void *retaddr)
     if (ret) {
 	if (retaddr) {
 	    /* now we have a real cpu fault */
-	    pc = (unsigned long) retaddr;
+	    pc = (uintptr_t) retaddr;
 	    tb = tb_find_pc(pc);
 	    if (tb) {
 		/* the PC is inside the translated code. It means that we have
@@ -302,7 +302,7 @@ static void gen_goto_tb(DisasContext * ctx, int n, target_ulong dest)
 	/* Use a direct jump if in same page and singlestep not enabled */
         tcg_gen_goto_tb(n);
         tcg_gen_movi_i32(cpu_pc, dest);
-        tcg_gen_exit_tb((long) tb + n);
+        tcg_gen_exit_tb((intptr_t) tb + n);
     } else {
         tcg_gen_movi_i32(cpu_pc, dest);
         if (ctx->singlestep_enabled)
@@ -2030,7 +2030,7 @@ void gen_intermediate_code_pc(CPUState * env, struct TranslationBlock *tb)
 }
  
 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)
 {
     env->pc = gen_opc_pc[pc_pos];
     env->flags = gen_opc_hflags[pc_pos];
@@ -236,7 +236,7 @@ static inline void gen_goto_tb(DisasContext *s, int tb_num,
         tcg_gen_goto_tb(tb_num);
         tcg_gen_movi_tl(cpu_pc, pc);
         tcg_gen_movi_tl(cpu_npc, npc);
-        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 */
         tcg_gen_movi_tl(cpu_pc, pc);
@@ -4891,7 +4891,7 @@ void gen_intermediate_code_init(CPUSPARCState *env)
 }
  
 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)
 {
     target_ulong npc;
     env->pc = gen_opc_pc[pc_pos];
@@ -69,7 +69,7 @@ enum {
     TCG_AREG0 = TCG_REG_R7,
 };
  
-static inline void flush_icache_range(unsigned long start, unsigned long stop)
+static inline void flush_icache_range(uintptr_t start, uintptr_t stop)
 {
 #if QEMU_GNUC_PREREQ(4, 1)
     __builtin___clear_cache((char *) start, (char *) stop);
@@ -83,7 +83,7 @@ enum {
 /* Note: must be synced with dyngen-exec.h */
 #define TCG_AREG0 TCG_REG_R17
  
-static inline void flush_icache_range(unsigned long start, unsigned long stop)
+static inline void flush_icache_range(uintptr_t start, uintptr_t stop)
 {
     start &= ~31;
     while (start <= stop)
@@ -58,6 +58,6 @@ enum {
 /* Note: must be synced with dyngen-exec.h */
 #define TCG_AREG0 TCG_REG_EBP
  
-static inline void flush_icache_range(unsigned long start, unsigned long stop)
+static inline void flush_icache_range(uintptr_t start, uintptr_t stop)
 {
 }
@@ -1120,11 +1120,11 @@ static void tcg_out_brcond2 (TCGContext *s, const TCGArg *args,
     tcg_out_bc (s, (BC | BI (7, CR_EQ) | BO_COND_TRUE), label_index);
 }
  
-void ppc_tb_set_jmp_target (unsigned long jmp_addr, unsigned long addr)
+void ppc_tb_set_jmp_target (uintptr_t jmp_addr, uintptr_t addr)
 {
     uint32_t *ptr;
-    long disp = addr - jmp_addr;
-    unsigned long patch_size;
+    intptr_t disp = addr - jmp_addr;
+    uintptr_t patch_size;
  
     ptr = (uint32_t *)jmp_addr;
  
@@ -103,7 +103,7 @@ enum {
 #define TCG_AREG0 TCG_REG_G6
 #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)
 {
     unsigned long p;
  
@@ -244,8 +244,8 @@ void tcg_context_init(TCGContext *s)
     s->code_buf = code_gen_prologue;
     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);
 }
  
 void tcg_set_frame(TCGContext *s, int reg,
@@ -2153,7 +2153,7 @@ static inline int tcg_gen_code_common(TCGContext *s, uint8_t *gen_code_buf,
             break;
         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:
             dead_iargs = s->op_dead_iargs[op_index];
@@ -2202,8 +2202,8 @@ int tcg_gen_code(TCGContext *s, uint8_t *gen_code_buf)
     tcg_gen_code_common(s, gen_code_buf, -1);
  
     /* 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;
 }
  
@@ -468,7 +468,7 @@ uint64_t tcg_helper_remu_i64(uint64_t arg1, uint64_t arg2);
 extern uint8_t code_gen_prologue[];
 #if defined(_ARCH_PPC) && !defined(_ARCH_PPC64)
 #define tcg_qemu_tb_exec(tb_ptr) \
-    ((long REGPARM __attribute__ ((longcall)) (*)(void *))code_gen_prologue)(tb_ptr)
+    ((intptr_t REGPARM __attribute__ ((longcall)) (*)(void *))code_gen_prologue)(tb_ptr)
 #else
-#define tcg_qemu_tb_exec(tb_ptr) ((long REGPARM (*)(void *))code_gen_prologue)(tb_ptr)
+#define tcg_qemu_tb_exec(tb_ptr) ((intptr_t REGPARM (*)(void *))code_gen_prologue)(tb_ptr)
 #endif
@@ -62,12 +62,19 @@ static const int tcg_target_reg_alloc_order[] = {
 };
  
 static const int tcg_target_call_iarg_regs[6] = {
+#ifdef _WIN64
+    TCG_REG_RCX,
+    TCG_REG_RDX,
+    TCG_REG_R8,
+    TCG_REG_R9,
+#else
     TCG_REG_RDI,
     TCG_REG_RSI,
     TCG_REG_RDX,
     TCG_REG_RCX,
     TCG_REG_R8,
     TCG_REG_R9,
+#endif
 };
  
 static const int tcg_target_call_oarg_regs[2] = {
@@ -93,7 +100,7 @@ static void patch_reloc(uint8_t *code_ptr, int type,
         *(uint32_t *)code_ptr = value;
         break;
     case R_386_PC32:
-        value -= (long)code_ptr;
+        value -= (intptr_t)code_ptr;
         if (value != (int32_t)value)
             tcg_abort();
         *(uint32_t *)code_ptr = value;
@@ -151,8 +158,8 @@ static int target_parse_constraint(TCGArgConstraint *ct, const char **pct_str)
     case 'L': /* qemu_ld/st constraint */
         ct->ct |= TCG_CT_REG;
         tcg_regset_set32(ct->u.regs, 0, 0xffff);
-        tcg_regset_reset_reg(ct->u.regs, TCG_REG_RSI);
-        tcg_regset_reset_reg(ct->u.regs, TCG_REG_RDI);
+        tcg_regset_reset_reg(ct->u.regs, tcg_target_call_iarg_regs[0]);
+        tcg_regset_reset_reg(ct->u.regs, tcg_target_call_iarg_regs[1]);
         break;
     case 'e':
         ct->ct |= TCG_CT_CONST_S32;
@@ -518,8 +525,8 @@ static void tcg_out_qemu_ld(TCGContext *s, const TCGArg *args,
     mem_index = *args;
     s_bits = opc & 3;
  
-    r0 = TCG_REG_RDI;
-    r1 = TCG_REG_RSI;
+    r0 = tcg_target_call_iarg_regs[0];
+    r1 = tcg_target_call_iarg_regs[1];
  
 #if TARGET_LONG_BITS == 32
     rexw = 0;
@@ -558,7 +565,7 @@ static void tcg_out_qemu_ld(TCGContext *s, const TCGArg *args,
     s->code_ptr++;
  
     /* XXX: move that code at the end of the TB */
-    tcg_out_movi(s, TCG_TYPE_I32, TCG_REG_RSI, mem_index);
+    tcg_out_movi(s, TCG_TYPE_I32, tcg_target_call_iarg_regs[1], mem_index);
     tcg_out8(s, 0xe8);
     tcg_out32(s, (tcg_target_long)qemu_ld_helpers[s_bits] - 
               (tcg_target_long)s->code_ptr - 4);
@@ -715,8 +722,8 @@ static void tcg_out_qemu_st(TCGContext *s, const TCGArg *args,
  
     s_bits = opc;
  
-    r0 = TCG_REG_RDI;
-    r1 = TCG_REG_RSI;
+    r0 = tcg_target_call_iarg_regs[0];
+    r1 = tcg_target_call_iarg_regs[1];
  
 #if TARGET_LONG_BITS == 32
     rexw = 0;
@@ -758,22 +765,22 @@ static void tcg_out_qemu_st(TCGContext *s, const TCGArg *args,
     switch(opc) {
     case 0:
         /* movzbl */
-        tcg_out_modrm(s, 0xb6 | P_EXT | P_REXB, TCG_REG_RSI, data_reg);
+        tcg_out_modrm(s, 0xb6 | P_EXT | P_REXB, r1, data_reg);
         break;
     case 1:
         /* movzwl */
-        tcg_out_modrm(s, 0xb7 | P_EXT, TCG_REG_RSI, data_reg);
+        tcg_out_modrm(s, 0xb7 | P_EXT, r1, data_reg);
         break;
     case 2:
         /* movl */
-        tcg_out_modrm(s, 0x8b, TCG_REG_RSI, data_reg);
+        tcg_out_modrm(s, 0x8b, r1, data_reg);
         break;
     default:
     case 3:
-        tcg_out_mov(s, TCG_REG_RSI, data_reg);
+        tcg_out_mov(s, TCG_REG_RDX, data_reg);
         break;
     }
-    tcg_out_movi(s, TCG_TYPE_I32, TCG_REG_RDX, mem_index);
+    tcg_out_movi(s, TCG_TYPE_I32, tcg_target_call_iarg_regs[2], mem_index);
     tcg_out8(s, 0xe8);
     tcg_out32(s, (tcg_target_long)qemu_st_helpers[s_bits] - 
               (tcg_target_long)s->code_ptr - 4);
@@ -1211,6 +1218,10 @@ static int tcg_target_callee_save_regs[] = {
     /*    TCG_REG_R14, */ /* currently used for the global env, so no
                              need to save */
     TCG_REG_R15,
+#ifdef _WIN64
+    TCG_REG_RDI,
+    TCG_REG_RSI,
+#endif
 };
  
 static inline void tcg_out_push(TCGContext *s, int reg)
@@ -1242,7 +1253,7 @@ void tcg_target_qemu_prologue(TCGContext *s)
     stack_addend = frame_size - push_size;
     tcg_out_addi(s, TCG_REG_RSP, -stack_addend);
  
-    tcg_out_modrm(s, 0xff, 4, TCG_REG_RDI); /* jmp *%rdi */
+    tcg_out_modrm(s, 0xff, 4, tcg_target_call_iarg_regs[0]); /* jmp *%rdi */
  
     /* TB epilogue */
     tb_ret_addr = s->code_ptr;
@@ -1362,8 +1373,10 @@ void tcg_target_init(TCGContext *s)
     tcg_regset_set32(tcg_target_available_regs[TCG_TYPE_I32], 0, 0xffff);
     tcg_regset_set32(tcg_target_available_regs[TCG_TYPE_I64], 0, 0xffff);
     tcg_regset_set32(tcg_target_call_clobber_regs, 0,
-                     (1 << TCG_REG_RDI) | 
-                     (1 << TCG_REG_RSI) | 
+#ifndef _WIN64
+                     (1 << TCG_REG_RDI) |
+                     (1 << TCG_REG_RSI) |
+#endif
                      (1 << TCG_REG_RDX) |
                      (1 << TCG_REG_RCX) |
                      (1 << TCG_REG_R8) |
@@ -78,6 +78,6 @@ enum {
 /* Note: must be synced with dyngen-exec.h */
 #define TCG_AREG0 TCG_REG_R14
  
-static inline void flush_icache_range(unsigned long start, unsigned long stop)
+static inline void flush_icache_range(uintptr_t start, uintptr_t stop)
 {
 }
@@ -49,9 +49,9 @@ uint32_t gen_opc_hflags[OPC_BUF_SIZE];
 #endif
  
 /* XXX: suppress that */
-unsigned long code_gen_max_block_size(void)
+uintptr_t code_gen_max_block_size(void)
 {
-    static unsigned long max;
+    static uintptr_t max;
  
     if (max == 0) {
         max = TCG_MAX_OP_SIZE;
@@ -135,12 +135,12 @@ int cpu_gen_code(CPUState *env, TranslationBlock *tb, int *gen_code_size_ptr)
 /* The cpu state corresponding to 'searched_pc' is restored.
  */
 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;
 #endif
@@ -160,7 +160,7 @@ int cpu_restore_state(TranslationBlock *tb,
     }
  
     /* 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;
  
@@ -1455,7 +1455,7 @@ static int win32_start_timer(struct qemu_alarm_timer *t)
     data->timerId = timeSetEvent(1,         // interval (ms)
                         data->period,       // resolution
                         host_alarm_handler, // function
-                        (DWORD)t,           // parameter
+                        (DWORD_PTR)t,       // parameter
                         flags);
  
     if (!data->timerId) {
@@ -1492,7 +1492,7 @@ static void win32_rearm_timer(struct qemu_alarm_timer *t)
     data->timerId = timeSetEvent(1,
                         data->period,
                         host_alarm_handler,
-                        (DWORD)t,
+                        (DWORD_PTR)t,
                         TIME_ONESHOT | TIME_PERIODIC);
  
     if (!data->timerId) {
@@ -4607,17 +4607,38 @@ static BOOL WINAPI qemu_ctrl_handler(DWORD type)
  
 int qemu_uuid_parse(const char *str, uint8_t *uuid)
 {
-    int ret;
+    int pos = 0;
+    uint8_t *uuid_ptr = uuid;
  
-    if(strlen(str) != 36)
+    if(strlen(str) != 36) {
         return -1;
+    }
  
-    ret = sscanf(str, UUID_FMT, &uuid[0], &uuid[1], &uuid[2], &uuid[3],
-            &uuid[4], &uuid[5], &uuid[6], &uuid[7], &uuid[8], &uuid[9],
-            &uuid[10], &uuid[11], &uuid[12], &uuid[13], &uuid[14], &uuid[15]);
-
-    if(ret != 16)
-        return -1;
+    while (pos < 36) {
+        if (pos == 8 || pos == 13 || pos == 18 || pos == 23) {
+            if (str[pos] != '-') {
+                return -1;
+            }
+            pos++;
+        } else {
+            if (str[pos] >= '0' && str[pos] <= '9') {
+                *uuid_ptr = (str[pos] - '0') << 4;
+            } else if (str[pos] >= 'a' && str[pos] <= 'f') {
+                *uuid_ptr = (str[pos] - 'a' + 0xa) << 4;
+            } else if (str[pos] >= 'A' && str[pos] <= 'F') {
+                *uuid_ptr = (str[pos] - 'A' + 0xa) << 4;
+            }
+            pos++;
+            if (str[pos] >= '0' && str[pos] <= '9') {
+                *uuid_ptr += str[pos] - '0';
+            } else if (str[pos] >= 'a' && str[pos] <= 'f') {
+                *uuid_ptr += str[pos] - 'a' + 0xa;
+            } else if (str[pos] >= 'A' && str[pos] <= 'F') {
+                *uuid_ptr += str[pos] - 'A' + 0xa;
+            }
+            pos++;
+        }
+    }
  
 #ifdef TARGET_I386
     smbios_add_field(1, offsetof(struct smbios_type_1, uuid), 16, uuid);
@@ -4887,7 +4908,7 @@ int main(int argc, char **argv, char **envp)
        QEMU to run on a single CPU */
     {
         HANDLE h;
-        DWORD mask, smask;
+        DWORD_PTR mask, smask;
         int i;
         h = GetCurrentProcess();
         if (GetProcessAffinityMask(h, &mask, &smask)) {