Changeset 26499 in vbox

Timestamp:

Feb 14, 2010 8:22:40 AM (15 years ago)

Author:

vboxsync

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

57669

Message:

recompier: whitespace cleanup. (Clean up whitespace on the foreign code before trying to merge in new changes again.)

Location:

trunk/src/recompiler

Files:

• cutils.c (modified) (2 diffs)
• dyngen-exec.h (modified) (3 diffs)
• elf.h (modified) (1 diff)
• fpu/softfloat.h (modified) (1 diff)
• host-utils.h (modified) (1 diff)
• softmmu_header.h (modified) (1 diff)
• softmmu_template.h (modified) (4 diffs)
• target-i386/exec.h (modified) (3 diffs)
• target-i386/opreg_template.h (modified) (1 diff)
• target-i386/ops_sse.h (modified) (1 diff)
• target-i386/ops_template.h (modified) (3 diffs)
• target-i386/ops_template_mem.h (modified) (5 diffs)
• tcg/i386/tcg-target.h (modified) (1 diff)
• tcg/tcg-op.h (modified) (24 diffs)
• tcg/tcg.c (modified) (56 diffs)
• tcg/tcg.h (modified) (10 diffs)
• tcg/x86_64/tcg-target.c (modified) (34 diffs)
• tcg/x86_64/tcg-target.h (modified) (1 diff)
• vl.h (modified) (21 diffs)

trunk/src/recompiler/cutils.c

@@ -33 +33 @@
 }
 
-/* Quick sort from OpenSolaris: 
+/* Quick sort from OpenSolaris:
      http://src.opensolaris.org/source/raw/onnv/onnv-gate/usr/src/common/util/qsort.c */
 /*
@@ -583 +583 @@
         y--;
     }
-    t = 86400 * (d + (153 * m - 457) / 5 + 365 * y + y / 4 - y / 100 + 
+    t = 86400 * (d + (153 * m - 457) / 5 + 365 * y + y / 4 - y / 100 +
                  y / 400 - 719469);
     t += 3600 * tm->tm_hour + 60 * tm->tm_min + tm->tm_sec;

trunk/src/recompiler/dyngen-exec.h

@@ -125 +125 @@
 #endif
 #ifdef __x86_64__
-#if defined(VBOX) 
+#if defined(VBOX)
 /* Must be in sync with TCG register notion, see tcg-target.h */
 #endif
@@ -243 +243 @@
 #define __hidden __attribute__((visibility("hidden")))
 #else
-#define __hidden 
+#define __hidden
 #endif
 
@@ -278 +278 @@
 
 #ifdef VBOX
-#define GETPC() ASMReturnAddress() 
+#define GETPC() ASMReturnAddress()
 #elif defined(__s390__)
 /* The return address may point to the start of the next instruction.

trunk/src/recompiler/elf.h

@@ -1041 +1041 @@
 #define SHN_HIRESERVE   0xffff
 #define SHN_MIPS_ACCOMON        0xff00
- 
+
 typedef struct elf32_shdr {
   Elf32_Word    sh_name;

trunk/src/recompiler/fpu/softfloat.h

@@ -102 +102 @@
 #if defined(VBOX) && (!defined(FLOATX80) || defined(CONFIG_SOFTFLOAT))
 # error misconfigured
-#endif 
+#endif
 
 #define STATUS_PARAM , float_status *status

trunk/src/recompiler/host-utils.h

@@ -175 +175 @@
 #endif
  }
- 
+
 #ifndef VBOX
 static always_inline int cto32 (uint32_t val)

trunk/src/recompiler/softmmu_header.h

@@ -1 +1 @@
 /*
  *  Software MMU support
- * 
+ *
  *  Copyright (c) 2003 Fabrice Bellard
  *

trunk/src/recompiler/softmmu_template.h

@@ -1 +1 @@
 /*
  *  Software MMU support
- * 
+ *
  *  Copyright (c) 2003 Fabrice Bellard
  *
@@ -71 +71 @@
                                                         void *retaddr);
 #ifndef VBOX
-static inline DATA_TYPE glue(io_read, SUFFIX)(target_phys_addr_t physaddr, 
+static inline DATA_TYPE glue(io_read, SUFFIX)(target_phys_addr_t physaddr,
                                               target_ulong addr,
                                               void *retaddr)
 #else
-DECLINLINE(DATA_TYPE) glue(io_read, SUFFIX)(target_phys_addr_t physaddr, 
+DECLINLINE(DATA_TYPE) glue(io_read, SUFFIX)(target_phys_addr_t physaddr,
                                             target_ulong addr,
                                             void *retaddr)
@@ -115 +115 @@
    that valid value takes the whole register, why gcc after 4.3 may
    use only lower part of register for smaller types. So force promoution. */
-DATA_TYPE_PROMOTED REGPARM 
+DATA_TYPE_PROMOTED REGPARM
 glue(glue(__ld, SUFFIX), MMUSUFFIX)(target_ulong addr,
                                     int mmu_idx)
@@ -224 +224 @@
 #ifndef SOFTMMU_CODE_ACCESS
 
-static void glue(glue(slow_st, SUFFIX), MMUSUFFIX)(target_ulong addr, 
-                                                   DATA_TYPE val, 
+static void glue(glue(slow_st, SUFFIX), MMUSUFFIX)(target_ulong addr,
+                                                   DATA_TYPE val,
                                                    int mmu_idx,
                                                    void *retaddr);
 
 #ifndef VBOX
-static inline void glue(io_write, SUFFIX)(target_phys_addr_t physaddr, 
+static inline void glue(io_write, SUFFIX)(target_phys_addr_t physaddr,
                                           DATA_TYPE val,
                                           target_ulong addr,
                                           void *retaddr)
 #else
-DECLINLINE(void) glue(io_write, SUFFIX)(target_phys_addr_t physaddr, 
+DECLINLINE(void) glue(io_write, SUFFIX)(target_phys_addr_t physaddr,
                                         DATA_TYPE val,
                                         target_ulong addr,

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

@@ -163 +163 @@
 }
 
-#ifndef VBOX 
+#ifndef VBOX
 static inline void stfq(target_ulong ptr, double v)
 #else
@@ -444 +444 @@
 {
     CPU86_LDoubleU temp;
-    
+
     temp.d = f;
     stq(ptr, temp.l.lower);
@@ -494 +494 @@
     CC_SRC = eflags & (CC_O | CC_S | CC_Z | CC_A | CC_P | CC_C);
     DF = 1 - (2 * ((eflags >> 10) & 1));
-    env->eflags = (env->eflags & ~update_mask) | 
+    env->eflags = (env->eflags & ~update_mask) |
         (eflags & update_mask);
 }

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

@@ -2 +2 @@
  *  i386 micro operations (templates for various register related
  *  operations)
- * 
+ *
  *  Copyright (c) 2003 Fabrice Bellard
  *

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

@@ -1989 +1989 @@
 
     if (res)
-#ifndef VBOX    
+#ifndef VBOX
         env->regs[R_ECX] = ((ctrl & (1 << 6)) ? rffs1 : ffs1)(res) - 1;
 #else
         env->regs[R_ECX] = ((ctrl & (1 << 6)) ? rffs1(res) : ffs1(res)) - 1;
-#endif        
+#endif
     else
         env->regs[R_ECX] = 16 >> (ctrl & (1 << 0));

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

@@ -2 +2 @@
  *  i386 micro operations (included several times to generate
  *  different operand sizes)
- * 
+ *
  *  Copyright (c) 2003 Fabrice Bellard
  *
@@ -249 +249 @@
     sf = lshift(CC_DST, 8 - DATA_BITS) & 0x80;
     /* of is defined if shift count == 1 */
-    of = lshift(CC_SRC ^ CC_DST, 12 - DATA_BITS) & CC_O; 
+    of = lshift(CC_SRC ^ CC_DST, 12 - DATA_BITS) & CC_O;
     return cf | pf | af | zf | sf | of;
 }
@@ -512 +512 @@
     int count;
     target_long res;
-    
+
     res = T0 & DATA_MASK;
     if (res != 0) {

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

@@ -2 +2 @@
  *  i386 micro operations (included several times to generate
  *  different operand sizes)
- * 
+ *
  *  Copyright (c) 2003 Fabrice Bellard
  *
@@ -94 +94 @@
         asm volatile("" : : "r" (T0));
 #endif
-        CC_SRC = (cc_table[CC_OP].compute_all() & ~(CC_O | CC_C)) | 
-            (lshift(src ^ T0, 11 - (DATA_BITS - 1)) & CC_O) | 
+        CC_SRC = (cc_table[CC_OP].compute_all() & ~(CC_O | CC_C)) |
+            (lshift(src ^ T0, 11 - (DATA_BITS - 1)) & CC_O) |
             (T0 & CC_C);
         CC_OP = CC_OP_EFLAGS;
@@ -119 +119 @@
 #endif
         CC_SRC = (cc_table[CC_OP].compute_all() & ~(CC_O | CC_C)) |
-            (lshift(src ^ T0, 11 - (DATA_BITS - 1)) & CC_O) | 
+            (lshift(src ^ T0, 11 - (DATA_BITS - 1)) & CC_O) |
             ((T0 >> (DATA_BITS - 1)) & CC_C);
         CC_OP = CC_OP_EFLAGS;
@@ -178 +178 @@
 #endif
         CC_SRC = (eflags & ~(CC_C | CC_O)) |
-            (lshift(src ^ T0, 11 - (DATA_BITS - 1)) & CC_O) | 
+            (lshift(src ^ T0, 11 - (DATA_BITS - 1)) & CC_O) |
             ((src >> (DATA_BITS - count)) & CC_C);
         CC_OP = CC_OP_EFLAGS;
@@ -209 +209 @@
 #endif
         CC_SRC = (eflags & ~(CC_C | CC_O)) |
-            (lshift(src ^ T0, 11 - (DATA_BITS - 1)) & CC_O) | 
+            (lshift(src ^ T0, 11 - (DATA_BITS - 1)) & CC_O) |
             ((src >> (count - 1)) & CC_C);
         CC_OP = CC_OP_EFLAGS;

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

@@ -49 +49 @@
 
 /* used for function call generation */
-#define TCG_REG_CALL_STACK TCG_REG_ESP 
+#define TCG_REG_CALL_STACK TCG_REG_ESP
 #define TCG_TARGET_STACK_ALIGN 16
 #define TCG_TARGET_CALL_STACK_OFFSET 0

trunk/src/recompiler/tcg/tcg-op.h

@@ -117 +117 @@
 
 #ifndef VBOX
-static inline void tcg_gen_op4(int opc, TCGv arg1, TCGv arg2, TCGv arg3, 
-#else /* VBOX */
-DECLINLINE(void) tcg_gen_op4(int opc, TCGv arg1, TCGv arg2, TCGv arg3, 
+static inline void tcg_gen_op4(int opc, TCGv arg1, TCGv arg2, TCGv arg3,
+#else /* VBOX */
+DECLINLINE(void) tcg_gen_op4(int opc, TCGv arg1, TCGv arg2, TCGv arg3,
 #endif /* VBOX */
                                TCGv arg4)
@@ -131 +131 @@
 
 #ifndef VBOX
-static inline void tcg_gen_op4i(int opc, TCGv arg1, TCGv arg2, TCGv arg3, 
-#else /* VBOX */
-DECLINLINE(void) tcg_gen_op4i(int opc, TCGv arg1, TCGv arg2, TCGv arg3, 
+static inline void tcg_gen_op4i(int opc, TCGv arg1, TCGv arg2, TCGv arg3,
+#else /* VBOX */
+DECLINLINE(void) tcg_gen_op4i(int opc, TCGv arg1, TCGv arg2, TCGv arg3,
 #endif /* VBOX */
                                 TCGArg arg4)
@@ -145 +145 @@
 
 #ifndef VBOX
-static inline void tcg_gen_op4ii(int opc, TCGv arg1, TCGv arg2, TCGArg arg3, 
-#else /* VBOX */
-DECLINLINE(void) tcg_gen_op4ii(int opc, TCGv arg1, TCGv arg2, TCGArg arg3, 
+static inline void tcg_gen_op4ii(int opc, TCGv arg1, TCGv arg2, TCGArg arg3,
+#else /* VBOX */
+DECLINLINE(void) tcg_gen_op4ii(int opc, TCGv arg1, TCGv arg2, TCGArg arg3,
 #endif /* VBOX */
                                  TCGArg arg4)
@@ -159 +159 @@
 
 #ifndef VBOX
-static inline void tcg_gen_op5(int opc, TCGv arg1, TCGv arg2, 
-#else /* VBOX */
-DECLINLINE(void) tcg_gen_op5(int opc, TCGv arg1, TCGv arg2, 
+static inline void tcg_gen_op5(int opc, TCGv arg1, TCGv arg2,
+#else /* VBOX */
+DECLINLINE(void) tcg_gen_op5(int opc, TCGv arg1, TCGv arg2,
 #endif /* VBOX */
                                TCGv arg3, TCGv arg4,
@@ -175 +175 @@
 
 #ifndef VBOX
-static inline void tcg_gen_op5i(int opc, TCGv arg1, TCGv arg2, 
-#else /* VBOX */
-DECLINLINE(void) tcg_gen_op5i(int opc, TCGv arg1, TCGv arg2, 
+static inline void tcg_gen_op5i(int opc, TCGv arg1, TCGv arg2,
+#else /* VBOX */
+DECLINLINE(void) tcg_gen_op5i(int opc, TCGv arg1, TCGv arg2,
 #endif /* VBOX */
                                 TCGv arg3, TCGv arg4,
@@ -191 +191 @@
 
 #ifndef VBOX
-static inline void tcg_gen_op6(int opc, TCGv arg1, TCGv arg2, 
-#else /* VBOX */
-DECLINLINE(void) tcg_gen_op6(int opc, TCGv arg1, TCGv arg2, 
+static inline void tcg_gen_op6(int opc, TCGv arg1, TCGv arg2,
+#else /* VBOX */
+DECLINLINE(void) tcg_gen_op6(int opc, TCGv arg1, TCGv arg2,
 #endif /* VBOX */
                                TCGv arg3, TCGv arg4,
@@ -208 +208 @@
 
 #ifndef VBOX
-static inline void tcg_gen_op6ii(int opc, TCGv arg1, TCGv arg2, 
-#else /* VBOX */
-DECLINLINE(void) tcg_gen_op6ii(int opc, TCGv arg1, TCGv arg2, 
+static inline void tcg_gen_op6ii(int opc, TCGv arg1, TCGv arg2,
+#else /* VBOX */
+DECLINLINE(void) tcg_gen_op6ii(int opc, TCGv arg1, TCGv arg2,
 #endif /* VBOX */
                                  TCGv arg3, TCGv arg4,
@@ -272 +272 @@
     TCGv t0;
     t0 = tcg_const_ptr((tcg_target_long)func);
-    tcg_gen_call(&tcg_ctx, 
+    tcg_gen_call(&tcg_ctx,
                  t0, TCG_HELPER_CALL_FLAGS,
                  0, NULL, 0, NULL);
@@ -303 +303 @@
     args[1] = arg2;
     t0 = tcg_const_ptr((tcg_target_long)func);
-    tcg_gen_call(&tcg_ctx, 
+    tcg_gen_call(&tcg_ctx,
                  t0, TCG_HELPER_CALL_FLAGS,
                  0, NULL, 2, args);
@@ -377 +377 @@
 
 #ifndef VBOX
-static inline void tcg_gen_helper_1_2(void *func, TCGv ret, 
-#else /* VBOX */
-DECLINLINE(void) tcg_gen_helper_1_2(void *func, TCGv ret, 
+static inline void tcg_gen_helper_1_2(void *func, TCGv ret,
+#else /* VBOX */
+DECLINLINE(void) tcg_gen_helper_1_2(void *func, TCGv ret,
 #endif /* VBOX */
                                       TCGv arg1, TCGv arg2)
@@ -388 +388 @@
     args[1] = arg2;
     t0 = tcg_const_ptr((tcg_target_long)func);
-    tcg_gen_call(&tcg_ctx, 
+    tcg_gen_call(&tcg_ctx,
                  t0, TCG_HELPER_CALL_FLAGS,
                  1, &ret, 2, args);
@@ -710 +710 @@
 
 #ifndef VBOX
-static inline void tcg_gen_brcond_i32(int cond, TCGv arg1, TCGv arg2, 
-#else /* VBOX */
-DECLINLINE(void) tcg_gen_brcond_i32(int cond, TCGv arg1, TCGv arg2, 
+static inline void tcg_gen_brcond_i32(int cond, TCGv arg1, TCGv arg2,
+#else /* VBOX */
+DECLINLINE(void) tcg_gen_brcond_i32(int cond, TCGv arg1, TCGv arg2,
 #endif /* VBOX */
                                       int label_index)
@@ -720 +720 @@
 
 #ifndef VBOX
-static inline void tcg_gen_brcondi_i32(int cond, TCGv arg1, int32_t arg2, 
-#else /* VBOX */
-DECLINLINE(void) tcg_gen_brcondi_i32(int cond, TCGv arg1, int32_t arg2, 
+static inline void tcg_gen_brcondi_i32(int cond, TCGv arg1, int32_t arg2,
+#else /* VBOX */
+DECLINLINE(void) tcg_gen_brcondi_i32(int cond, TCGv arg1, int32_t arg2,
 #endif /* VBOX */
                                        int label_index)
@@ -990 +990 @@
 #endif /* VBOX */
 {
-    tcg_gen_op6(INDEX_op_add2_i32, ret, TCGV_HIGH(ret), 
+    tcg_gen_op6(INDEX_op_add2_i32, ret, TCGV_HIGH(ret),
                 arg1, TCGV_HIGH(arg1), arg2, TCGV_HIGH(arg2));
 }
@@ -1011 +1011 @@
 #endif /* VBOX */
 {
-    tcg_gen_op6(INDEX_op_sub2_i32, ret, TCGV_HIGH(ret), 
+    tcg_gen_op6(INDEX_op_sub2_i32, ret, TCGV_HIGH(ret),
                 arg1, TCGV_HIGH(arg1), arg2, TCGV_HIGH(arg2));
 }
@@ -1143 +1143 @@
 
 #ifndef VBOX
-static inline void tcg_gen_brcond_i64(int cond, TCGv arg1, TCGv arg2, 
-#else /* VBOX */
-DECLINLINE(void) tcg_gen_brcond_i64(int cond, TCGv arg1, TCGv arg2, 
+static inline void tcg_gen_brcond_i64(int cond, TCGv arg1, TCGv arg2,
+#else /* VBOX */
+DECLINLINE(void) tcg_gen_brcond_i64(int cond, TCGv arg1, TCGv arg2,
 #endif /* VBOX */
                                       int label_index)
 {
-    tcg_gen_op6ii(INDEX_op_brcond2_i32, 
+    tcg_gen_op6ii(INDEX_op_brcond2_i32,
                   arg1, TCGV_HIGH(arg1), arg2, TCGV_HIGH(arg2),
                   cond, label_index);
@@ -1161 +1161 @@
 {
     TCGv t0, t1;
-    
+
     t0 = tcg_temp_new(TCG_TYPE_I64);
     t1 = tcg_temp_new(TCG_TYPE_I32);
 
     tcg_gen_op4(INDEX_op_mulu2_i32, t0, TCGV_HIGH(t0), arg1, arg2);
-    
+
     tcg_gen_mul_i32(t1, arg1, TCGV_HIGH(arg2));
     tcg_gen_add_i32(TCGV_HIGH(t0), TCGV_HIGH(t0), t1);
     tcg_gen_mul_i32(t1, TCGV_HIGH(arg1), arg2);
     tcg_gen_add_i32(TCGV_HIGH(t0), TCGV_HIGH(t0), t1);
-    
+
     tcg_gen_mov_i64(ret, t0);
     tcg_temp_free(t0);
@@ -1526 +1526 @@
 
 #ifndef VBOX
-static inline void tcg_gen_brcond_i64(int cond, TCGv arg1, TCGv arg2, 
-#else /* VBOX */
-DECLINLINE(void) tcg_gen_brcond_i64(int cond, TCGv arg1, TCGv arg2, 
+static inline void tcg_gen_brcond_i64(int cond, TCGv arg1, TCGv arg2,
+#else /* VBOX */
+DECLINLINE(void) tcg_gen_brcond_i64(int cond, TCGv arg1, TCGv arg2,
 #endif /* VBOX */
                                       int label_index)
@@ -1648 +1648 @@
 
 #ifndef VBOX
-static inline void tcg_gen_brcondi_i64(int cond, TCGv arg1, int64_t arg2, 
-#else /* VBOX */
-DECLINLINE(void) tcg_gen_brcondi_i64(int cond, TCGv arg1, int64_t arg2, 
+static inline void tcg_gen_brcondi_i64(int cond, TCGv arg1, int64_t arg2,
+#else /* VBOX */
+DECLINLINE(void) tcg_gen_brcondi_i64(int cond, TCGv arg1, int64_t arg2,
 #endif /* VBOX */
                                        int label_index)
@@ -1723 +1723 @@
     t0 = tcg_temp_new(TCG_TYPE_I32);
     t1 = tcg_temp_new(TCG_TYPE_I32);
-    
+
     tcg_gen_shri_i32(t0, arg, 8);
     tcg_gen_andi_i32(t1, arg, 0x000000ff);
@@ -1745 +1745 @@
     t0 = tcg_temp_new(TCG_TYPE_I32);
     t1 = tcg_temp_new(TCG_TYPE_I32);
-    
+
     tcg_gen_shli_i32(t0, arg, 24);
-    
+
     tcg_gen_andi_i32(t1, arg, 0x0000ff00);
     tcg_gen_shli_i32(t1, t1, 8);
     tcg_gen_or_i32(t0, t0, t1);
-    
+
     tcg_gen_shri_i32(t1, arg, 8);
     tcg_gen_andi_i32(t1, t1, 0x0000ff00);
     tcg_gen_or_i32(t0, t0, t1);
-    
+
     tcg_gen_shri_i32(t1, arg, 24);
     tcg_gen_or_i32(ret, t0, t1);
@@ -1986 +1986 @@
     t0 = tcg_temp_new(TCG_TYPE_I32);
     t1 = tcg_temp_new(TCG_TYPE_I32);
-    
+
     tcg_gen_shli_i64(t0, arg, 56);
-    
+
     tcg_gen_andi_i64(t1, arg, 0x0000ff00);
     tcg_gen_shli_i64(t1, t1, 40);
     tcg_gen_or_i64(t0, t0, t1);
-    
+
     tcg_gen_andi_i64(t1, arg, 0x00ff0000);
     tcg_gen_shli_i64(t1, t1, 24);
@@ -2004 +2004 @@
     tcg_gen_andi_i64(t1, t1, 0xff000000);
     tcg_gen_or_i64(t0, t0, t1);
-    
+
     tcg_gen_shri_i64(t1, arg, 24);
     tcg_gen_andi_i64(t1, t1, 0x00ff0000);
@@ -2154 +2154 @@
     /* XXX: must really use a 32 bit size for TCGArg in all cases */
 #if TARGET_LONG_BITS > TCG_TARGET_REG_BITS
-    tcg_gen_op2ii(INDEX_op_debug_insn_start, 
+    tcg_gen_op2ii(INDEX_op_debug_insn_start,
                   (uint32_t)(pc), (uint32_t)(pc >> 32));
 #else

trunk/src/recompiler/tcg/tcg.c

@@ -67 +67 @@
 
 #ifdef VBOX
-/* 
+/*
  * Liveness analysis doesn't work well with 32-bit hosts and 64-bit targets,
- * second element of the register pair to store 64-bit value is consedered 
- * dead, it seems. 
+ * second element of the register pair to store 64-bit value is consedered
+ * dead, it seems.
  * @todo: fix it in compiler
  */
@@ -78 +78 @@
 #endif
 
-static void patch_reloc(uint8_t *code_ptr, int type, 
+static void patch_reloc(uint8_t *code_ptr, int type,
                         tcg_target_long value, tcg_target_long addend);
 
@@ -131 +131 @@
 /* label relocation processing */
 
-void tcg_out_reloc(TCGContext *s, uint8_t *code_ptr, int type, 
+void tcg_out_reloc(TCGContext *s, uint8_t *code_ptr, int type,
                    int label_index, long addend)
 {
@@ -140 +140 @@
     if (l->has_value) {
         /* FIXME: This may break relocations on RISC targets that
-           modify instruction fields in place.  The caller may not have 
+           modify instruction fields in place.  The caller may not have
            written the initial value.  */
         patch_reloc(code_ptr, type, l->u.value, addend);
@@ -154 +154 @@
 }
 
-static void tcg_out_label(TCGContext *s, int label_index, 
+static void tcg_out_label(TCGContext *s, int label_index,
                           tcg_target_long value)
 {
@@ -194 +194 @@
     TCGPool *p;
     int pool_size;
-    
+
     if (size > TCG_POOL_CHUNK_SIZE) {
         /* big malloc: insert a new pool (XXX: could optimize) */
@@ -217 +217 @@
                 p->size = pool_size;
                 p->next = NULL;
-                if (s->pool_current) 
+                if (s->pool_current)
                     s->pool_current->next = p;
                 else
@@ -248 +248 @@
     s->temps = s->static_temps;
     s->nb_globals = 0;
-    
+
     /* Count total number of arguments and allocate the corresponding
        space */
@@ -269 +269 @@
         args_ct += n;
     }
-    
+
     tcg_target_init(s);
 
@@ -276 +276 @@
     s->code_ptr = s->code_buf;
     tcg_target_qemu_prologue(s);
-    flush_icache_range((unsigned long)s->code_buf, 
+    flush_icache_range((unsigned long)s->code_buf,
                        (unsigned long)s->code_ptr);
 }
@@ -340 +340 @@
 #if TCG_TARGET_REG_BITS == 32
 /* temporary hack to avoid register shortage for tcg_qemu_st64() */
-TCGv tcg_global_reg2_new_hack(TCGType type, int reg1, int reg2, 
+TCGv tcg_global_reg2_new_hack(TCGType type, int reg1, int reg2,
                               const char *name)
 {
@@ -554 +554 @@
 }
 
-static void tcg_gen_call_internal(TCGContext *s, TCGv func, 
+static void tcg_gen_call_internal(TCGContext *s, TCGv func,
                                   unsigned int flags,
                                   unsigned int nb_rets, const TCGv *rets,
                                   unsigned int nb_params, const TCGv *params)
 {
-#ifndef VBOX 
+#ifndef VBOX
    int i;
 #else
@@ -639 +639 @@
         }
     }
-    tcg_gen_call_internal(s, func, flags, 
+    tcg_gen_call_internal(s, func, flags,
                           nb_rets, rets, j, args2);
 }
@@ -647 +647 @@
                   unsigned int nb_params, const TCGv *args1)
 {
-    tcg_gen_call_internal(s, func, flags, 
+    tcg_gen_call_internal(s, func, flags,
                           nb_rets, rets, nb_params, args1);
 }
@@ -653 +653 @@
 
 #if TCG_TARGET_REG_BITS == 32
-void tcg_gen_shifti_i64(TCGv ret, TCGv arg1, 
+void tcg_gen_shifti_i64(TCGv ret, TCGv arg1,
                         int c, int right, int arith)
 {
@@ -682 +682 @@
             if (arith)
                 tcg_gen_sari_i32(t1, TCGV_HIGH(arg1), c);
-            else 
+            else
                 tcg_gen_shri_i32(t1, TCGV_HIGH(arg1), c);
-            tcg_gen_shri_i32(ret, arg1, c); 
+            tcg_gen_shri_i32(ret, arg1, c);
             tcg_gen_or_i32(ret, ret, t0);
             tcg_gen_mov_i32(TCGV_HIGH(ret), t1);
@@ -690 +690 @@
             tcg_gen_shri_i32(t0, arg1, 32 - c);
             /* Note: ret can be the same as arg1, so we use t1 */
-            tcg_gen_shli_i32(t1, arg1, c); 
+            tcg_gen_shli_i32(t1, arg1, c);
             tcg_gen_shli_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), c);
             tcg_gen_or_i32(TCGV_HIGH(ret), TCGV_HIGH(ret), t0);
@@ -733 +733 @@
         pstrcpy(buf, buf_size, ts->name);
     } else {
-        if (ts->temp_local) 
+        if (ts->temp_local)
             snprintf(buf, buf_size, "loc%d", idx - s->nb_globals);
         else
@@ -767 +767 @@
     if (unlikely(!s->helpers_sorted)) {
 #ifdef VBOX
-        qemu_qsort(s->helpers, s->nb_helpers, sizeof(TCGHelperInfo), 
+        qemu_qsort(s->helpers, s->nb_helpers, sizeof(TCGHelperInfo),
               helper_cmp);
 #else
-        qsort(s->helpers, s->nb_helpers, sizeof(TCGHelperInfo), 
+        qsort(s->helpers, s->nb_helpers, sizeof(TCGHelperInfo),
               helper_cmp);
 #endif
@@ -846 +846 @@
             pc = args[0];
 #endif
-            if (!first_insn) 
+            if (!first_insn)
                 fprintf(outfile, "\n");
             fprintf(outfile, " ---- 0x%" PRIx64, pc);
@@ -886 +886 @@
                 }
             }
-        } else if (c == INDEX_op_movi_i32 
+        } else if (c == INDEX_op_movi_i32
 #if TCG_TARGET_REG_BITS == 64
                    || c == INDEX_op_movi_i64
@@ -897 +897 @@
             nb_iargs = def->nb_iargs;
             nb_cargs = def->nb_cargs;
-            fprintf(outfile, " %s %s,$", def->name, 
+            fprintf(outfile, " %s %s,$", def->name,
                     tcg_get_arg_str_idx(s, buf, sizeof(buf), args[0]));
             val = args[1];
@@ -921 +921 @@
                 nb_cargs = def->nb_cargs;
             }
-            
+
             k = 0;
             for(i = 0; i < nb_oargs; i++) {
@@ -1083 +1083 @@
 /* set a nop for an operation using 'nb_args' */
 #ifndef VBOX
-static inline void tcg_set_nop(TCGContext *s, uint16_t *opc_ptr, 
+static inline void tcg_set_nop(TCGContext *s, uint16_t *opc_ptr,
 #else /* VBOX */
-DECLINLINE(void) tcg_set_nop(TCGContext *s, uint16_t *opc_ptr, 
+DECLINLINE(void) tcg_set_nop(TCGContext *s, uint16_t *opc_ptr,
 #endif /* VBOX */
                                TCGArg *args, int nb_args)
@@ -1144 +1144 @@
     uint8_t *dead_temps;
     unsigned int dead_iargs;
-    
+
     gen_opc_ptr++; /* skip end */
 
@@ -1151 +1151 @@
     /* XXX: make it really dynamic */
     s->op_dead_iargs = tcg_malloc(OPC_BUF_SIZE * sizeof(uint16_t));
-    
+
     dead_temps = tcg_malloc(s->nb_temps);
     memset(dead_temps, 1, s->nb_temps);
@@ -1180 +1180 @@
                             goto do_not_remove_call;
                     }
-                    tcg_set_nop(s, gen_opc_buf + op_index, 
+                    tcg_set_nop(s, gen_opc_buf + op_index,
                                 args - 1, nb_args);
                 } else {
@@ -1190 +1190 @@
                         dead_temps[arg] = 1;
                     }
-                    
+
                     /* globals are live (they may be used by the call) */
                     memset(dead_temps, 0, s->nb_globals);
-                    
+
                     /* input args are live */
                     dead_iargs = 0;
@@ -1257 +1257 @@
                         dead_temps[arg] = 1;
                     }
-                    
+
                     /* if end of basic block, update */
                     if (def->flags & TCG_OPF_BB_END) {
@@ -1265 +1265 @@
                         memset(dead_temps, 0, s->nb_globals);
                     }
-                    
+
                     /* input args are live */
                     dead_iargs = 0;
@@ -1335 +1335 @@
     for(i = 0; i < TCG_TARGET_NB_REGS; i++) {
         if (s->reg_to_temp[i] >= 0) {
-            printf("%s: %s\n", 
-                   tcg_target_reg_names[i], 
+            printf("%s: %s\n",
+                   tcg_target_reg_names[i],
                    tcg_get_arg_str_idx(s, buf, sizeof(buf), s->reg_to_temp[i]));
         }
@@ -1354 +1354 @@
             if (ts->val_type != TEMP_VAL_REG ||
                 ts->reg != reg) {
-                printf("Inconsistency for register %s:\n", 
+                printf("Inconsistency for register %s:\n",
                        tcg_target_reg_names[reg]);
                 goto fail;
@@ -1365 +1365 @@
             !ts->fixed_reg &&
             s->reg_to_temp[ts->reg] != k) {
-                printf("Inconsistency for temp %s:\n", 
+                printf("Inconsistency for temp %s:\n",
                        tcg_get_arg_str_idx(s, buf, sizeof(buf), k));
         fail:
@@ -1404 +1404 @@
         assert(ts->val_type == TEMP_VAL_REG);
         if (!ts->mem_coherent) {
-            if (!ts->mem_allocated) 
+            if (!ts->mem_allocated)
                 temp_allocate_frame(s, temp);
             tcg_out_st(s, ts->type, reg, ts->mem_reg, ts->mem_offset);
@@ -1457 +1457 @@
             break;
         case TEMP_VAL_CONST:
-            reg = tcg_reg_alloc(s, tcg_target_available_regs[ts->type], 
+            reg = tcg_reg_alloc(s, tcg_target_available_regs[ts->type],
                                 allocated_regs);
-            if (!ts->mem_allocated) 
+            if (!ts->mem_allocated)
                 temp_allocate_frame(s, temp);
             tcg_out_movi(s, ts->type, reg, ts->val);
@@ -1589 +1589 @@
 }
 
-static void tcg_reg_alloc_op(TCGContext *s, 
+static void tcg_reg_alloc_op(TCGContext *s,
                              const TCGOpDef *def, int opc,
                              const TCGArg *args,
@@ -1606 +1606 @@
 
     /* copy constants */
-    memcpy(new_args + nb_oargs + nb_iargs, 
-           args + nb_oargs + nb_iargs, 
+    memcpy(new_args + nb_oargs + nb_iargs,
+           args + nb_oargs + nb_iargs,
            sizeof(TCGArg) * def->nb_cargs);
 
-    /* satisfy input constraints */ 
+    /* satisfy input constraints */
     tcg_regset_set(allocated_regs, s->reserved_regs);
     for(k = 0; k < nb_iargs; k++) {
@@ -1651 +1651 @@
                    not dead after the instruction, we must allocate
                    a new register and move it */
-                if (!IS_DEAD_IARG(i - nb_oargs)) 
+                if (!IS_DEAD_IARG(i - nb_oargs))
                     goto allocate_in_reg;
             }
@@ -1660 +1660 @@
         } else {
         allocate_in_reg:
-            /* allocate a new register matching the constraint 
+            /* allocate a new register matching the constraint
                and move the temporary register into it */
             reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs);
@@ -1670 +1670 @@
     iarg_end: ;
     }
-    
+
     if (def->flags & TCG_OPF_BB_END) {
         tcg_reg_alloc_bb_end(s, allocated_regs);
@@ -1686 +1686 @@
             }
         }
-        
+
         if (def->flags & TCG_OPF_CALL_CLOBBER) {
-            /* XXX: permit generic clobber register list ? */ 
+            /* XXX: permit generic clobber register list ? */
             for(reg = 0; reg < TCG_TARGET_NB_REGS; reg++) {
                 if (tcg_regset_test_reg(tcg_target_call_clobber_regs, reg)) {
@@ -1696 +1696 @@
             /* XXX: for load/store we could do that only for the slow path
                (i.e. when a memory callback is called) */
-            
+
             /* store globals and free associated registers (we assume the insn
                can modify any global. */
             save_globals(s, allocated_regs);
         }
-        
+
         /* satisfy the output constraints */
         tcg_regset_set(allocated_regs, s->reserved_regs);
@@ -1729 +1729 @@
                 /* temp value is modified, so the value kept in memory is
                    potentially not the same */
-                ts->mem_coherent = 0; 
+                ts->mem_coherent = 0;
                 s->reg_to_temp[reg] = arg;
             }
@@ -1739 +1739 @@
     /* emit instruction */
     tcg_out_op(s, opc, new_args, const_args);
-    
+
     /* move the outputs in the correct register if needed */
     for(i = 0; i < nb_oargs; i++) {
@@ -1783 +1783 @@
     /* XXX: preallocate call stack */
     call_stack_size = (nb_params - nb_regs) * sizeof(tcg_target_long);
-    call_stack_size = (call_stack_size + TCG_TARGET_STACK_ALIGN - 1) & 
+    call_stack_size = (call_stack_size + TCG_TARGET_STACK_ALIGN - 1) &
         ~(TCG_TARGET_STACK_ALIGN - 1);
     allocate_args = (call_stack_size > TCG_STATIC_CALL_ARGS_SIZE);
@@ -1801 +1801 @@
                 tcg_out_st(s, ts->type, ts->reg, TCG_REG_CALL_STACK, stack_offset);
             } else if (ts->val_type == TEMP_VAL_MEM) {
-                reg = tcg_reg_alloc(s, tcg_target_available_regs[ts->type], 
+                reg = tcg_reg_alloc(s, tcg_target_available_regs[ts->type],
                                     s->reserved_regs);
                 /* XXX: not correct if reading values from the stack */
@@ -1807 +1807 @@
                 tcg_out_st(s, ts->type, reg, TCG_REG_CALL_STACK, stack_offset);
             } else if (ts->val_type == TEMP_VAL_CONST) {
-                reg = tcg_reg_alloc(s, tcg_target_available_regs[ts->type], 
+                reg = tcg_reg_alloc(s, tcg_target_available_regs[ts->type],
                                     s->reserved_regs);
                 /* XXX: sign extend may be needed on some targets */
@@ -1820 +1820 @@
 #endif
     }
-    
+
     /* assign input registers */
     tcg_regset_set(allocated_regs, s->reserved_regs);
@@ -1844 +1844 @@
         }
     }
-    
+
     /* assign function address */
     func_arg = args[nb_oargs + nb_iargs - 1];
@@ -1877 +1877 @@
         tcg_abort();
     }
-        
-    
+
+
     /* mark dead temporaries and free the associated registers */
     for(i = 0; i < nb_iargs; i++) {
@@ -1891 +1891 @@
         }
     }
-    
+
     /* clobber call registers */
     for(reg = 0; reg < TCG_TARGET_NB_REGS; reg++) {
@@ -1898 +1898 @@
         }
     }
-    
+
     /* store globals and free associated registers (we assume the call
        can modify any global. */
@@ -1904 +1904 @@
 
     tcg_out_op(s, opc, &func_arg, &const_func_arg);
-    
+
     if (allocate_args) {
         tcg_out_addi(s, TCG_REG_CALL_STACK, STACK_DIR(call_stack_size));
@@ -1924 +1924 @@
             ts->val_type = TEMP_VAL_REG;
             ts->reg = reg;
-            ts->mem_coherent = 0; 
+            ts->mem_coherent = 0;
             s->reg_to_temp[reg] = arg;
         }
     }
-    
+
     return nb_iargs + nb_oargs + def->nb_cargs + 1;
 }
@@ -2114 +2114 @@
 
     /* flush instruction cache */
-    flush_icache_range((unsigned long)gen_code_buf, 
+    flush_icache_range((unsigned long)gen_code_buf,
                        (unsigned long)s->code_ptr);
     return s->code_ptr -  gen_code_buf;
@@ -2138 +2138 @@
     cpu_fprintf(f, "JIT cycles          %" PRId64 " (%0.3f s at 2.4 GHz)\n",
                 tot, tot / 2.4e9);
-    cpu_fprintf(f, "translated TBs      %" PRId64 " (aborted=%" PRId64 " %0.1f%%)\n", 
-                s->tb_count, 
+    cpu_fprintf(f, "translated TBs      %" PRId64 " (aborted=%" PRId64 " %0.1f%%)\n",
+                s->tb_count,
                 s->tb_count1 - s->tb_count,
                 s->tb_count1 ? (double)(s->tb_count1 - s->tb_count) / s->tb_count1 * 100.0 : 0);
-    cpu_fprintf(f, "avg ops/TB          %0.1f max=%d\n", 
+    cpu_fprintf(f, "avg ops/TB          %0.1f max=%d\n",
                 s->tb_count ? (double)s->op_count / s->tb_count : 0, s->op_count_max);
-    cpu_fprintf(f, "old ops/total ops   %0.1f%%\n", 
+    cpu_fprintf(f, "old ops/total ops   %0.1f%%\n",
                 s->op_count ? (double)s->old_op_count / s->op_count * 100.0 : 0);
     cpu_fprintf(f, "deleted ops/TB      %0.2f\n",
-                s->tb_count ? 
+                s->tb_count ?
                 (double)s->del_op_count / s->tb_count : 0);
     cpu_fprintf(f, "avg temps/TB        %0.2f max=%d\n",
-                s->tb_count ? 
+                s->tb_count ?
                 (double)s->temp_count / s->tb_count : 0,
                 s->temp_count_max);
-    
-    cpu_fprintf(f, "cycles/op           %0.1f\n", 
+
+    cpu_fprintf(f, "cycles/op           %0.1f\n",
                 s->op_count ? (double)tot / s->op_count : 0);
-    cpu_fprintf(f, "cycles/in byte      %0.1f\n", 
+    cpu_fprintf(f, "cycles/in byte      %0.1f\n",
                 s->code_in_len ? (double)tot / s->code_in_len : 0);
-    cpu_fprintf(f, "cycles/out byte     %0.1f\n", 
+    cpu_fprintf(f, "cycles/out byte     %0.1f\n",
                 s->code_out_len ? (double)tot / s->code_out_len : 0);
     if (tot == 0)
         tot = 1;
-    cpu_fprintf(f, "  gen_interm time   %0.1f%%\n", 
+    cpu_fprintf(f, "  gen_interm time   %0.1f%%\n",
                 (double)s->interm_time / tot * 100.0);
-    cpu_fprintf(f, "  gen_code time     %0.1f%%\n", 
+    cpu_fprintf(f, "  gen_code time     %0.1f%%\n",
                 (double)s->code_time / tot * 100.0);
-    cpu_fprintf(f, "liveness/code time  %0.1f%%\n", 
+    cpu_fprintf(f, "liveness/code time  %0.1f%%\n",
                 (double)s->la_time / (s->code_time ? s->code_time : 1) * 100.0);
     cpu_fprintf(f, "cpu_restore count   %" PRId64 "\n",

trunk/src/recompiler/tcg/tcg.h

@@ -77 +77 @@
     uint8_t *ptr;
     tcg_target_long addend;
-} TCGRelocation; 
+} TCGRelocation;
 
 typedef struct TCGLabel {
@@ -168 +168 @@
    cannot raise exceptions. Hence a call to a pure function can be
    safely suppressed if the return value is not used. */
-#define TCG_CALL_PURE           0x0010 
+#define TCG_CALL_PURE           0x0010
 
 /* used to align parameters */
@@ -230 +230 @@
     int nb_temps;
     /* index of free temps, -1 if none */
-    int first_free_temp[TCG_TYPE_COUNT * 2]; 
+    int first_free_temp[TCG_TYPE_COUNT * 2];
 
     /* goto_tb support */
@@ -241 +241 @@
     uint16_t *op_dead_iargs; /* for each operation, each bit tells if the
                                 corresponding input argument is dead */
-    
+
     /* tells in which temporary a given register is. It does not take
        into account fixed registers */
@@ -319 +319 @@
                    tcg_target_long start, tcg_target_long size);
 TCGv tcg_global_reg_new(TCGType type, int reg, const char *name);
-TCGv tcg_global_reg2_new_hack(TCGType type, int reg1, int reg2, 
+TCGv tcg_global_reg2_new_hack(TCGType type, int reg1, int reg2,
                               const char *name);
 TCGv tcg_global_mem_new(TCGType type, int reg, tcg_target_long offset,
@@ -362 +362 @@
 #define TCG_OPF_BB_END     0x01 /* instruction defines the end of a basic
                                    block */
-#define TCG_OPF_CALL_CLOBBER 0x02 /* instruction clobbers call registers 
+#define TCG_OPF_CALL_CLOBBER 0x02 /* instruction clobbers call registers
                                    and potentially update globals. */
 #define TCG_OPF_SIDE_EFFECTS 0x04 /* instruction has side effects : it
@@ -376 +376 @@
     int *sorted_args;
 } TCGOpDef;
-        
+
 typedef struct TCGTargetOpDef {
     int op;
@@ -413 +413 @@
                   unsigned int nb_rets, const TCGv *rets,
                   unsigned int nb_params, const TCGv *args1);
-void tcg_gen_shifti_i64(TCGv ret, TCGv arg1, 
+void tcg_gen_shifti_i64(TCGv ret, TCGv arg1,
                         int c, int right, int arith);
 
@@ -436 +436 @@
 #endif
 
-void tcg_out_reloc(TCGContext *s, uint8_t *code_ptr, int type, 
+void tcg_out_reloc(TCGContext *s, uint8_t *code_ptr, int type,
                    int label_index, long addend);
 const TCGArg *tcg_gen_code_op(TCGContext *s, int opc, const TCGArg *args1,
@@ -465 +465 @@
 #if defined(VBOX) && defined(GCC_WITH_BUGGY_REGPARM)
 #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") 
+    __asm__ __volatile__("call *%%ecx" : "=a"(ret) : "a"(tb_ptr), "c" (&code_gen_prologue[0]) : "memory", "%edx", "cc")
 #else
 #define tcg_qemu_tb_exec(tb_ptr) ((long REGPARM (*)(void *))code_gen_prologue)(tb_ptr)

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

@@ -80 +80 @@
 
 static const int tcg_target_call_oarg_regs[2] = {
-    TCG_REG_RAX, 
-    TCG_REG_RDX 
+    TCG_REG_RAX,
+    TCG_REG_RDX
 };
 
 static uint8_t *tb_ret_addr;
 
-static void patch_reloc(uint8_t *code_ptr, int type, 
+static void patch_reloc(uint8_t *code_ptr, int type,
                         tcg_target_long value, tcg_target_long addend)
 {
@@ -227 +227 @@
 #define P_REXW  0x200 /* set rex.w = 1 */
 #define P_REXB  0x400 /* force rex use for byte registers */
-                                  
+
 static const uint8_t tcg_cond_to_jcc[10] = {
     [TCG_COND_EQ] = JCC_JE,
@@ -244 +244 @@
 {
     int rex;
-    rex = ((opc >> 6) & 0x8) | ((r >> 1) & 0x4) | 
+    rex = ((opc >> 6) & 0x8) | ((r >> 1) & 0x4) |
         ((x >> 2) & 2) | ((rm >> 3) & 1);
     if (rex || (opc & P_REXB)) {
@@ -272 +272 @@
 
 /* rm < 0 means no register index plus (-rm - 1 immediate bytes) */
-static inline void tcg_out_modrm_offset(TCGContext *s, int opc, int r, int rm, 
+static inline void tcg_out_modrm_offset(TCGContext *s, int opc, int r, int rm,
                                         tcg_target_long offset)
 {
@@ -321 +321 @@
 #if defined(CONFIG_SOFTMMU)
 /* XXX: incomplete. index must be different from ESP */
-static void tcg_out_modrm_offset2(TCGContext *s, int opc, int r, int rm, 
+static void tcg_out_modrm_offset2(TCGContext *s, int opc, int r, int rm,
                                   int index, int shift,
                                   tcg_target_long offset)
@@ -363 +363 @@
 }
 
-static inline void tcg_out_movi(TCGContext *s, TCGType type, 
+static inline void tcg_out_movi(TCGContext *s, TCGType type,
                                 int ret, tcg_target_long arg)
 {
@@ -451 +451 @@
     int32_t val, val1;
     TCGLabel *l = &s->labels[label_index];
-    
+
     if (l->has_value) {
         val = l->u.value - (tcg_target_long)s->code_ptr;
@@ -483 +483 @@
 }
 
-static void tcg_out_brcond(TCGContext *s, int cond, 
+static void tcg_out_brcond(TCGContext *s, int cond,
                            TCGArg arg1, TCGArg arg2, int const_arg2,
                            int label_index, int rexw)
@@ -510 +510 @@
      if ((val >> 32) != 0)
      {
-         tcg_out8(s, 0xc7); /* mov imm32, 4(%rsp) */ 
-         tcg_out8(s, 0x44); 
+         tcg_out8(s, 0xc7); /* mov imm32, 4(%rsp) */
+         tcg_out8(s, 0x44);
          tcg_out8(s, 0x24);
          tcg_out8(s, 0x04);
@@ -518 +518 @@
 }
 
-DECLINLINE(void) tcg_out_long_call(TCGContext *s, tcg_target_long dst) 
+DECLINLINE(void) tcg_out_long_call(TCGContext *s, tcg_target_long dst)
 {
     intptr_t disp = dst - (tcg_target_long)s->code_ptr - 5;
@@ -561 +561 @@
         return;
     }
-    
+
     disp = dst - (tcg_target_long)s->code_ptr - 5;
     if (disp < 2LL * _1G && disp > -2LL * _1G)
@@ -577 +577 @@
     tcg_out8(s, 0xe0);
 #endif
-} 
+}
 #endif
 
@@ -619 +619 @@
 
 static void tcg_out_vbox_phys_read(TCGContext *s, int index, int addr_reg, int data_reg) {
-    if (addr_reg != TCG_REG_RDI) 
+    if (addr_reg != TCG_REG_RDI)
         /* mov addr_reg, %rdi */
         tcg_out_modrm(s, 0x8b |  P_REXW, TCG_REG_RDI, addr_reg);
-    
+
     tcg_out_long_call(s, (tcg_target_long)vbox_ld_helpers[index]);
     /* mov %rax, data_reg*/
@@ -629 +629 @@
 
 static void tcg_out_vbox_phys_write(TCGContext *s, int index, int addr_reg, int val_reg) {
-    if (addr_reg != TCG_REG_RDI) 
+    if (addr_reg != TCG_REG_RDI)
         /* mov addr_reg, %rdi */
         tcg_out_modrm(s, 0x8b |  P_REXW, TCG_REG_RDI, addr_reg);
-    if (val_reg != TCG_REG_RSI) 
+    if (val_reg != TCG_REG_RSI)
         /* mov addr_reg, %rsi */
         tcg_out_modrm(s, 0x8b | P_REXW, TCG_REG_RSI, val_reg);
@@ -667 +667 @@
     /* mov */
     tcg_out_modrm(s, 0x8b | rexw, r0, addr_reg);
- 
+
     tcg_out_modrm(s, 0xc1 | rexw, 5, r1); /* shr $x, r1 */
-    tcg_out8(s, TARGET_PAGE_BITS - CPU_TLB_ENTRY_BITS); 
-    
+    tcg_out8(s, TARGET_PAGE_BITS - CPU_TLB_ENTRY_BITS);
+
     tcg_out_modrm(s, 0x81 | rexw, 4, r0); /* andl $x, r0 */
     tcg_out32(s, TARGET_PAGE_MASK | ((1 << s_bits) - 1));
-    
+
     tcg_out_modrm(s, 0x81, 4, r1); /* andl $x, r1 */
     tcg_out32(s, (CPU_TLB_SIZE - 1) << CPU_TLB_ENTRY_BITS);
@@ -683 +683 @@
     /* cmp 0(r1), r0 */
     tcg_out_modrm_offset(s, 0x3b | rexw, r0, r1, 0);
-    
+
     /* mov */
     tcg_out_modrm(s, 0x8b | rexw, r0, addr_reg);
-    
+
     /* je label1 */
     tcg_out8(s, 0x70 + JCC_JE);
@@ -696 +696 @@
 #ifndef VBOX
     tcg_out8(s, 0xe8);
-    tcg_out32(s, (tcg_target_long)qemu_ld_helpers[s_bits] - 
+    tcg_out32(s, (tcg_target_long)qemu_ld_helpers[s_bits] -
               (tcg_target_long)s->code_ptr - 4);
 #else
@@ -731 +731 @@
     label2_ptr = s->code_ptr;
     s->code_ptr++;
-    
+
     /* label1: */
     *label1_ptr = s->code_ptr - label1_ptr - 1;
 
     /* add x(r1), r0 */
-    tcg_out_modrm_offset(s, 0x03 | P_REXW, r0, r1, offsetof(CPUTLBEntry, addend) - 
+    tcg_out_modrm_offset(s, 0x03 | P_REXW, r0, r1, offsetof(CPUTLBEntry, addend) -
                          offsetof(CPUTLBEntry, addr_read));
 #else
     r0 = addr_reg;
-#endif    
+#endif
 
 #if !defined(VBOX) || !defined(REM_PHYS_ADDR_IN_TLB)
@@ -764 +764 @@
         if (bswap) {
             /* rolw $8, data_reg */
-            tcg_out8(s, 0x66); 
+            tcg_out8(s, 0x66);
             tcg_out_modrm(s, 0xc1, 0, data_reg);
             tcg_out8(s, 8);
@@ -774 +774 @@
             tcg_out_modrm_offset(s, 0xb7 | P_EXT, data_reg, r0, 0);
             /* rolw $8, data_reg */
-            tcg_out8(s, 0x66); 
+            tcg_out8(s, 0x66);
             tcg_out_modrm(s, 0xc1, 0, data_reg);
             tcg_out8(s, 8);
@@ -855 +855 @@
     /* mov */
     tcg_out_modrm(s, 0x8b | rexw, r0, addr_reg);
- 
+
     tcg_out_modrm(s, 0xc1 | rexw, 5, r1); /* shr $x, r1 */
-    tcg_out8(s, TARGET_PAGE_BITS - CPU_TLB_ENTRY_BITS); 
-    
+    tcg_out8(s, TARGET_PAGE_BITS - CPU_TLB_ENTRY_BITS);
+
     tcg_out_modrm(s, 0x81 | rexw, 4, r0); /* andl $x, r0 */
     tcg_out32(s, TARGET_PAGE_MASK | ((1 << s_bits) - 1));
-    
+
     tcg_out_modrm(s, 0x81, 4, r1); /* andl $x, r1 */
     tcg_out32(s, (CPU_TLB_SIZE - 1) << CPU_TLB_ENTRY_BITS);
@@ -871 +871 @@
     /* cmp 0(r1), r0 */
     tcg_out_modrm_offset(s, 0x3b | rexw, r0, r1, 0);
-    
+
     /* mov */
     tcg_out_modrm(s, 0x8b | rexw, r0, addr_reg);
-    
+
     /* je label1 */
     tcg_out8(s, 0x70 + JCC_JE);
@@ -902 +902 @@
 #ifndef VBOX
     tcg_out8(s, 0xe8);
-    tcg_out32(s, (tcg_target_long)qemu_st_helpers[s_bits] - 
+    tcg_out32(s, (tcg_target_long)qemu_st_helpers[s_bits] -
               (tcg_target_long)s->code_ptr - 4);
 #else
@@ -912 +912 @@
     label2_ptr = s->code_ptr;
     s->code_ptr++;
-    
+
     /* label1: */
     *label1_ptr = s->code_ptr - label1_ptr - 1;
 
     /* add x(r1), r0 */
-    tcg_out_modrm_offset(s, 0x03 | P_REXW, r0, r1, offsetof(CPUTLBEntry, addend) - 
+    tcg_out_modrm_offset(s, 0x03 | P_REXW, r0, r1, offsetof(CPUTLBEntry, addend) -
                          offsetof(CPUTLBEntry, addr_write));
 #else
@@ -983 +983 @@
 {
     int c;
-    
+
     switch(opc) {
     case INDEX_op_exit_tb:
@@ -1004 +1004 @@
             /* jmp Ev */
 #ifndef VBOX
-            tcg_out_modrm_offset(s, 0xff, 4, -1, 
-                                 (tcg_target_long)(s->tb_next + 
+            tcg_out_modrm_offset(s, 0xff, 4, -1,
+                                 (tcg_target_long)(s->tb_next +
                                                    args[0]));
 #else
             /* @todo: can we clobber RAX here? */
-            tcg_out_movi(s, TCG_TYPE_I64, TCG_REG_RAX, 
+            tcg_out_movi(s, TCG_TYPE_I64, TCG_REG_RAX,
                          (tcg_target_long)&(s->tb_next[args[0]]));
             tcg_out8(s, 0xff); tcg_out8(s, 0x20 | TCG_REG_RAX); /* jmp *(%rax) */
@@ -1084 +1084 @@
         tcg_out_modrm_offset(s, 0x8b | P_REXW, args[0], args[1], args[2]);
         break;
-        
+
     case INDEX_op_st8_i32:
     case INDEX_op_st8_i64:
@@ -1213 +1213 @@
         c = SHIFT_SAR;
         goto gen_shift32;
-        
+
     case INDEX_op_shl_i64:
         c = SHIFT_SHL;
@@ -1234 +1234 @@
         c = SHIFT_SAR;
         goto gen_shift64;
-        
+
     case INDEX_op_brcond_i32:
-        tcg_out_brcond(s, args[2], args[0], args[1], const_args[1], 
+        tcg_out_brcond(s, args[2], args[0], args[1], const_args[1],
                        args[3], 0);
         break;
     case INDEX_op_brcond_i64:
-        tcg_out_brcond(s, args[2], args[0], args[1], const_args[1], 
+        tcg_out_brcond(s, args[2], args[0], args[1], const_args[1],
                        args[3], P_REXW);
         break;
@@ -1295 +1295 @@
         tcg_out_qemu_ld(s, args, 3);
         break;
-        
+
     case INDEX_op_qemu_st8:
         tcg_out_qemu_st(s, args, 0);
@@ -1338 +1338 @@
     push_size = 8 + ARRAY_SIZE(tcg_target_callee_save_regs) * 8;
     frame_size = push_size + TCG_STATIC_CALL_ARGS_SIZE;
-    frame_size = (frame_size + TCG_TARGET_STACK_ALIGN - 1) & 
+    frame_size = (frame_size + TCG_TARGET_STACK_ALIGN - 1) &
         ~(TCG_TARGET_STACK_ALIGN - 1);
     stack_addend = frame_size - push_size;
@@ -1344 +1344 @@
 
     tcg_out_modrm(s, 0xff, 4, TCG_REG_RDI); /* jmp *%rdi */
-    
+
     /* TB epilogue */
     tb_ret_addr = s->code_ptr;
@@ -1453 +1453 @@
     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) | 
+                     (1 << TCG_REG_RDI) |
+                     (1 << TCG_REG_RSI) |
                      (1 << TCG_REG_RDX) |
                      (1 << TCG_REG_RCX) |
@@ -1462 +1462 @@
                      (1 << TCG_REG_R10) |
                      (1 << TCG_REG_R11));
-    
+
     tcg_regset_clear(s->reserved_regs);
     tcg_regset_set_reg(s->reserved_regs, TCG_REG_RSP);

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

@@ -60 +60 @@
 
 /* used for function call generation */
-#define TCG_REG_CALL_STACK TCG_REG_RSP 
+#define TCG_REG_CALL_STACK TCG_REG_RSP
 #define TCG_TARGET_STACK_ALIGN 16
 #define TCG_TARGET_CALL_STACK_OFFSET 0

trunk/src/recompiler/vl.h

@@ -1 +1 @@
 /*
  * QEMU System Emulator header
- * 
+ *
  * Copyright (c) 2003 Fabrice Bellard
- * 
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -54 +54 @@
 
 #ifdef _WIN32
-#ifndef VBOX 
+#ifndef VBOX
 #include <windows.h>
 #define fsync _commit
@@ -250 +250 @@
 typedef void IOHandler(void *opaque);
 
-int qemu_set_fd_handler2(int fd, 
-                         IOCanRWHandler *fd_read_poll, 
-                         IOHandler *fd_read, 
-                         IOHandler *fd_write, 
+int qemu_set_fd_handler2(int fd,
+                         IOCanRWHandler *fd_read_poll,
+                         IOHandler *fd_read,
+                         IOHandler *fd_write,
                          void *opaque);
 int qemu_set_fd_handler(int fd,
-                        IOHandler *fd_read, 
+                        IOHandler *fd_read,
                         IOHandler *fd_write,
                         void *opaque);
@@ -321 +321 @@
 int qemu_chr_write(CharDriverState *s, const uint8_t *buf, int len);
 void qemu_chr_send_event(CharDriverState *s, int event);
-void qemu_chr_add_handlers(CharDriverState *s, 
-                           IOCanRWHandler *fd_can_read, 
+void qemu_chr_add_handlers(CharDriverState *s,
+                           IOCanRWHandler *fd_can_read,
                            IOReadHandler *fd_read,
                            IOEventHandler *fd_event,
@@ -520 +520 @@
 typedef int LoadStateHandler(QEMUFile *f, void *opaque, int version_id);
 
-int register_savevm(const char *idstr, 
-                    int instance_id, 
+int register_savevm(const char *idstr,
+                    int instance_id,
                     int version_id,
                     SaveStateHandler *save_state,
@@ -564 +564 @@
 typedef struct BlockDriverInfo {
     /* in bytes, 0 if irrelevant */
-    int cluster_size; 
+    int cluster_size;
     /* offset at which the VM state can be saved (0 if not possible) */
-    int64_t vm_state_offset; 
+    int64_t vm_state_offset;
 } BlockDriverInfo;
 
@@ -592 +592 @@
 void bdrv_init(void);
 BlockDriver *bdrv_find_format(const char *format_name);
-int bdrv_create(BlockDriver *drv, 
+int bdrv_create(BlockDriver *drv,
                 const char *filename, int64_t size_in_sectors,
                 const char *backing_file, int flags);
@@ -602 +602 @@
                BlockDriver *drv);
 void bdrv_close(BlockDriverState *bs);
-int bdrv_read(BlockDriverState *bs, int64_t sector_num, 
+int bdrv_read(BlockDriverState *bs, int64_t sector_num,
               uint8_t *buf, int nb_sectors);
-int bdrv_write(BlockDriverState *bs, int64_t sector_num, 
+int bdrv_write(BlockDriverState *bs, int64_t sector_num,
                const uint8_t *buf, int nb_sectors);
-int bdrv_pread(BlockDriverState *bs, int64_t offset, 
+int bdrv_pread(BlockDriverState *bs, int64_t offset,
                void *buf, int count);
-int bdrv_pwrite(BlockDriverState *bs, int64_t offset, 
+int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
                 const void *buf, int count);
 int bdrv_truncate(BlockDriverState *bs, int64_t offset);
@@ -646 +646 @@
 #define BIOS_ATA_TRANSLATION_RECHS  4
 
-void bdrv_set_geometry_hint(BlockDriverState *bs, 
+void bdrv_set_geometry_hint(BlockDriverState *bs,
                             int cyls, int heads, int secs);
 void bdrv_set_type_hint(BlockDriverState *bs, int type);
 void bdrv_set_translation_hint(BlockDriverState *bs, int translation);
-void bdrv_get_geometry_hint(BlockDriverState *bs, 
+void bdrv_get_geometry_hint(BlockDriverState *bs,
                             int *pcyls, int *pheads, int *psecs);
 int bdrv_get_type_hint(BlockDriverState *bs);
@@ -661 +661 @@
 void bdrv_set_locked(BlockDriverState *bs, int locked);
 void bdrv_eject(BlockDriverState *bs, int eject_flag);
-void bdrv_set_change_cb(BlockDriverState *bs, 
+void bdrv_set_change_cb(BlockDriverState *bs,
                         void (*change_cb)(void *opaque), void *opaque);
 void bdrv_get_format(BlockDriverState *bs, char *buf, int buf_size);
@@ -669 +669 @@
 int bdrv_is_encrypted(BlockDriverState *bs);
 int bdrv_set_key(BlockDriverState *bs, const char *key);
-void bdrv_iterate_format(void (*it)(void *opaque, const char *name), 
+void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
                          void *opaque);
 const char *bdrv_get_device_name(BlockDriverState *bs);
-int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num, 
+int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
                           const uint8_t *buf, int nb_sectors);
 int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi);
 
-void bdrv_get_backing_filename(BlockDriverState *bs, 
+void bdrv_get_backing_filename(BlockDriverState *bs,
                                char *filename, int filename_size);
-int bdrv_snapshot_create(BlockDriverState *bs, 
+int bdrv_snapshot_create(BlockDriverState *bs,
                          QEMUSnapshotInfo *sn_info);
-int bdrv_snapshot_goto(BlockDriverState *bs, 
+int bdrv_snapshot_goto(BlockDriverState *bs,
                        const char *snapshot_id);
 int bdrv_snapshot_delete(BlockDriverState *bs, const char *snapshot_id);
-int bdrv_snapshot_list(BlockDriverState *bs, 
+int bdrv_snapshot_list(BlockDriverState *bs,
                        QEMUSnapshotInfo **psn_info);
 char *bdrv_snapshot_dump(char *buf, int buf_size, QEMUSnapshotInfo *sn);
@@ -695 +695 @@
 #ifndef QEMU_TOOL
 
-typedef void QEMUMachineInitFunc(int ram_size, int vga_ram_size, 
+typedef void QEMUMachineInitFunc(int ram_size, int vga_ram_size,
                                  int boot_device,
              DisplayState *ds, const char **fd_filename, int snapshot,
@@ -720 +720 @@
 typedef uint32_t (IOPortReadFunc)(void *opaque, uint32_t address);
 
-int register_ioport_read(int start, int length, int size, 
+int register_ioport_read(int start, int length, int size,
                          IOPortReadFunc *func, void *opaque);
-int register_ioport_write(int start, int length, int size, 
+int register_ioport_write(int start, int length, int size,
                           IOPortWriteFunc *func, void *opaque);
 void isa_unassign_ioport(int start, int length);
@@ -735 +735 @@
 typedef struct PCIDevice PCIDevice;
 
-typedef void PCIConfigWriteFunc(PCIDevice *pci_dev, 
+typedef void PCIConfigWriteFunc(PCIDevice *pci_dev,
                                 uint32_t address, uint32_t data, int len);
-typedef uint32_t PCIConfigReadFunc(PCIDevice *pci_dev, 
+typedef uint32_t PCIConfigReadFunc(PCIDevice *pci_dev,
                                    uint32_t address, int len);
-typedef void PCIMapIORegionFunc(PCIDevice *pci_dev, int region_num, 
+typedef void PCIMapIORegionFunc(PCIDevice *pci_dev, int region_num,
                                 uint32_t addr, uint32_t size, int type);
 
@@ -778 +778 @@
     char name[64];
     PCIIORegion io_regions[PCI_NUM_REGIONS];
-    
+
     /* do not access the following fields */
     PCIConfigReadFunc *config_read;
@@ -791 +791 @@
 PCIDevice *pci_register_device(PCIBus *bus, const char *name,
                                int instance_size, int devfn,
-                               PCIConfigReadFunc *config_read, 
+                               PCIConfigReadFunc *config_read,
                                PCIConfigWriteFunc *config_write);
 
-void pci_register_io_region(PCIDevice *pci_dev, int region_num, 
-                            uint32_t size, int type, 
+void pci_register_io_region(PCIDevice *pci_dev, int region_num,
+                            uint32_t size, int type,
                             PCIMapIORegionFunc *map_func);
 
 void pci_set_irq(PCIDevice *pci_dev, int irq_num, int level);
 
-uint32_t pci_default_read_config(PCIDevice *d, 
+uint32_t pci_default_read_config(PCIDevice *d,
                                  uint32_t address, int len);
-void pci_default_write_config(PCIDevice *d, 
+void pci_default_write_config(PCIDevice *d,
                               uint32_t address, uint32_t val, int len);
 void pci_device_save(PCIDevice *s, QEMUFile *f);
@@ -903 +903 @@
 }
 
-int isa_vga_init(DisplayState *ds, uint8_t *vga_ram_base, 
+int isa_vga_init(DisplayState *ds, uint8_t *vga_ram_base,
                  unsigned long vga_ram_offset, int vga_ram_size);
-int pci_vga_init(PCIBus *bus, DisplayState *ds, uint8_t *vga_ram_base, 
+int pci_vga_init(PCIBus *bus, DisplayState *ds, uint8_t *vga_ram_base,
                  unsigned long vga_ram_offset, int vga_ram_size,
                  unsigned long vga_bios_offset, int vga_bios_size);
 
 /* cirrus_vga.c */
-void pci_cirrus_vga_init(PCIBus *bus, DisplayState *ds, uint8_t *vga_ram_base, 
+void pci_cirrus_vga_init(PCIBus *bus, DisplayState *ds, uint8_t *vga_ram_base,
                          unsigned long vga_ram_offset, int vga_ram_size);
-void isa_cirrus_vga_init(DisplayState *ds, uint8_t *vga_ram_base, 
+void isa_cirrus_vga_init(DisplayState *ds, uint8_t *vga_ram_base,
                          unsigned long vga_ram_offset, int vga_ram_size);
 
@@ -975 +975 @@
 typedef struct fdctrl_t fdctrl_t;
 
-fdctrl_t *fdctrl_init (int irq_lvl, int dma_chann, int mem_mapped, 
+fdctrl_t *fdctrl_init (int irq_lvl, int dma_chann, int mem_mapped,
                        uint32_t io_base,
                        BlockDriverState **fds);
@@ -1171 +1171 @@
                        void *intctl);
 void ledma_set_irq(void *opaque, int isr);
-void ledma_memory_read(void *opaque, target_phys_addr_t addr, 
+void ledma_memory_read(void *opaque, target_phys_addr_t addr,
                        uint8_t *buf, int len, int do_bswap);
-void ledma_memory_write(void *opaque, target_phys_addr_t addr, 
+void ledma_memory_write(void *opaque, target_phys_addr_t addr,
                         uint8_t *buf, int len, int do_bswap);
 void espdma_raise_irq(void *opaque);
@@ -1243 +1243 @@
 int adb_poll(ADBBusState *s, uint8_t *buf_out);
 
-ADBDevice *adb_register_device(ADBBusState *s, int devaddr, 
-                               ADBDeviceRequest *devreq, 
-                               ADBDeviceReset *devreset, 
+ADBDevice *adb_register_device(ADBBusState *s, int devaddr,
+                               ADBDeviceRequest *devreq,
+                               ADBDeviceReset *devreset,
                                void *opaque);
 void adb_kbd_init(ADBBusState *bus);
@@ -1379 +1379 @@
                            BlockDriverState *bs,
                            target_ulong sector_len, int nb_blocs, int width,
-                           uint16_t id0, uint16_t id1, 
+                           uint16_t id0, uint16_t id1,
                            uint16_t id2, uint16_t id3);