sse: convert from X86_ECX to gp_tmpreg

diff --git a/orc/orcprogram-sse.c b/orc/orcprogram-sse.c
index dd1964b..589c5ca 100644 (file)
--- a/orc/orcprogram-sse.c
+++ b/orc/orcprogram-sse.c
@@ -201,8 +201,8 @@ sse_save_accumulators (OrcCompiler *compiler)
         }
 
         if (compiler->vars[i].size == 2) {
-          orc_x86_emit_mov_sse_reg (compiler, src, X86_ECX);
-          orc_x86_emit_mov_reg_memoffset (compiler, 2, X86_ECX,
+          orc_x86_emit_mov_sse_reg (compiler, src, compiler->gp_tmpreg);
+          orc_x86_emit_mov_reg_memoffset (compiler, 2, compiler->gp_tmpreg,
               (int)ORC_STRUCT_OFFSET(OrcExecutor, accumulators[i-ORC_VAR_A1]),
               compiler->exec_reg);
         } else {
@@ -285,19 +285,19 @@ orc_sse_emit_load_src (OrcCompiler *compiler, OrcVariable *var)
     i = var - compiler->vars;
     orc_x86_emit_mov_memoffset_reg (compiler, compiler->is_64bit ? 8 : 4,
         (int)ORC_STRUCT_OFFSET(OrcExecutor, arrays[i]),
-        compiler->exec_reg, X86_ECX);
-    ptr_reg = X86_ECX;
+        compiler->exec_reg, compiler->gp_tmpreg);
+    ptr_reg = compiler->gp_tmpreg;
   } else {
     ptr_reg = var->ptr_register;
   }
   switch (var->size << compiler->loop_shift) {
     case 1:
-      orc_x86_emit_mov_memoffset_reg (compiler, 1, 0, ptr_reg, X86_ECX);
-      orc_x86_emit_mov_reg_sse (compiler, X86_ECX, var->alloc);
+      orc_x86_emit_mov_memoffset_reg (compiler, 1, 0, ptr_reg, compiler->gp_tmpreg);
+      orc_x86_emit_mov_reg_sse (compiler, compiler->gp_tmpreg, var->alloc);
       break;
     case 2:
-      orc_x86_emit_mov_memoffset_reg (compiler, 2, 0, ptr_reg, X86_ECX);
-      orc_x86_emit_mov_reg_sse (compiler, X86_ECX, var->alloc);
+      orc_x86_emit_mov_memoffset_reg (compiler, 2, 0, ptr_reg, compiler->gp_tmpreg);
+      orc_x86_emit_mov_reg_sse (compiler, compiler->gp_tmpreg, var->alloc);
       break;
     case 4:
       orc_x86_emit_mov_memoffset_sse (compiler, 4, 0, ptr_reg, var->alloc,
@@ -324,27 +324,27 @@ orc_sse_emit_store_dest (OrcCompiler *compiler, OrcVariable *var)
   int ptr_reg;
   if (var->ptr_register == 0) {
     orc_x86_emit_mov_memoffset_reg (compiler, compiler->is_64bit ? 8 : 4,
-        var->ptr_offset, compiler->exec_reg, X86_ECX);
-    ptr_reg = X86_ECX;
+        var->ptr_offset, compiler->exec_reg, compiler->gp_tmpreg);
+    ptr_reg = compiler->gp_tmpreg;
   } else {
     ptr_reg = var->ptr_register;
   }
   switch (var->size << compiler->loop_shift) {
     case 1:
       /* FIXME we might be using ecx twice here */
-      if (ptr_reg == X86_ECX) {
+      if (ptr_reg == compiler->gp_tmpreg) {
         ORC_COMPILER_ERROR(compiler,"unimplemented");
       }
-      orc_x86_emit_mov_sse_reg (compiler, var->alloc, X86_ECX);
-      orc_x86_emit_mov_reg_memoffset (compiler, 1, X86_ECX, 0, ptr_reg);
+      orc_x86_emit_mov_sse_reg (compiler, var->alloc, compiler->gp_tmpreg);
+      orc_x86_emit_mov_reg_memoffset (compiler, 1, compiler->gp_tmpreg, 0, ptr_reg);
       break;
     case 2:
       /* FIXME we might be using ecx twice here */
-      if (ptr_reg == X86_ECX) {
+      if (ptr_reg == compiler->gp_tmpreg) {
         ORC_COMPILER_ERROR(compiler,"unimplemented");
       }
-      orc_x86_emit_mov_sse_reg (compiler, var->alloc, X86_ECX);
-      orc_x86_emit_mov_reg_memoffset (compiler, 2, X86_ECX, 0, ptr_reg);
+      orc_x86_emit_mov_sse_reg (compiler, var->alloc, compiler->gp_tmpreg);
+      orc_x86_emit_mov_reg_memoffset (compiler, 2, compiler->gp_tmpreg, 0, ptr_reg);
       break;
     case 4:
       orc_x86_emit_mov_sse_memoffset (compiler, 4, var->alloc, 0, ptr_reg,
@@ -423,13 +423,14 @@ orc_compiler_sse_assemble (OrcCompiler *compiler)
         (int)ORC_STRUCT_OFFSET(OrcExecutor,counter1), compiler->exec_reg);
     
     orc_x86_emit_mov_memoffset_reg (compiler, 4,
-        (int)ORC_STRUCT_OFFSET(OrcExecutor,n), compiler->exec_reg, X86_ECX);
-    orc_x86_emit_sub_reg_reg (compiler, 4, X86_EAX, X86_ECX);
+        (int)ORC_STRUCT_OFFSET(OrcExecutor,n), compiler->exec_reg,
+        compiler->gp_tmpreg);
+    orc_x86_emit_sub_reg_reg (compiler, 4, X86_EAX, compiler->gp_tmpreg);
 
-    orc_x86_emit_mov_reg_reg (compiler, 4, X86_ECX, X86_EAX);
+    orc_x86_emit_mov_reg_reg (compiler, 4, compiler->gp_tmpreg, X86_EAX);
 
-    orc_x86_emit_sar_imm_reg (compiler, 4, compiler->loop_shift, X86_ECX);
-    orc_x86_emit_mov_reg_memoffset (compiler, 4, X86_ECX,
+    orc_x86_emit_sar_imm_reg (compiler, 4, compiler->loop_shift, compiler->gp_tmpreg);
+    orc_x86_emit_mov_reg_memoffset (compiler, 4, compiler->gp_tmpreg,
         (int)ORC_STRUCT_OFFSET(OrcExecutor,counter2), compiler->exec_reg);
 
     orc_x86_emit_and_imm_reg (compiler, 4, (1<<compiler->loop_shift)-1, X86_EAX);
@@ -452,8 +453,8 @@ orc_compiler_sse_assemble (OrcCompiler *compiler)
     orc_x86_emit_label (compiler, 7);
   } else {
     orc_x86_emit_mov_memoffset_reg (compiler, 4,
-        (int)ORC_STRUCT_OFFSET(OrcExecutor,n), compiler->exec_reg, X86_ECX);
-    orc_x86_emit_mov_reg_memoffset (compiler, 4, X86_ECX,
+        (int)ORC_STRUCT_OFFSET(OrcExecutor,n), compiler->exec_reg, compiler->gp_tmpreg);
+    orc_x86_emit_mov_reg_memoffset (compiler, 4, compiler->gp_tmpreg,
         (int)ORC_STRUCT_OFFSET(OrcExecutor,counter2), compiler->exec_reg);
   }
 

diff --git a/orc/orcrules-sse.c b/orc/orcrules-sse.c
index 6ced86a..c76ca5e 100644 (file)
--- a/orc/orcrules-sse.c
+++ b/orc/orcrules-sse.c
@@ -22,8 +22,8 @@ orc_sse_emit_loadil (OrcCompiler *p, int reg, int value)
   if (value == 0) {
     orc_sse_emit_660f (p, "pxor", 0xef, reg, reg);
   } else {
-    orc_x86_emit_mov_imm_reg (p, 4, value, X86_ECX);
-    orc_x86_emit_mov_reg_sse (p, X86_ECX, reg);
+    orc_x86_emit_mov_imm_reg (p, 4, value, p->gp_tmpreg);
+    orc_x86_emit_mov_reg_sse (p, p->gp_tmpreg, reg);
     orc_sse_emit_pshufd (p, 0, reg, reg);
   }
 }
@@ -230,9 +230,9 @@ sse_rule_signX (OrcCompiler *p, void *user, OrcInstruction *insn)
     src = p->tmpreg;
   }
 
-  orc_x86_emit_mov_imm_reg (p, 4, imm_vals[ORC_PTR_TO_INT(user)], X86_ECX);
+  orc_x86_emit_mov_imm_reg (p, 4, imm_vals[ORC_PTR_TO_INT(user)], p->gp_tmpreg);
 
-  orc_x86_emit_mov_reg_sse (p, X86_ECX, dest);
+  orc_x86_emit_mov_reg_sse (p, p->gp_tmpreg, dest);
   orc_sse_emit_pshufd (p, 0, dest, dest);
 
   orc_sse_emit_660f (p, names[ORC_PTR_TO_INT(user)], codes[ORC_PTR_TO_INT(user)], src, dest);
@@ -491,11 +491,11 @@ sse_emit_load_mask (OrcCompiler *p, unsigned int mask1, unsigned int mask2)
   int tmp = p->tmpreg;
   int tmp2 = X86_XMM7;
 
-  orc_x86_emit_mov_imm_reg (p, 4, mask1, X86_ECX);
-  orc_x86_emit_mov_reg_sse (p, X86_ECX, p->tmpreg);
+  orc_x86_emit_mov_imm_reg (p, 4, mask1, p->gp_tmpreg);
+  orc_x86_emit_mov_reg_sse (p, p->gp_tmpreg, p->tmpreg);
   orc_sse_emit_pshufd (p, 0, tmp, tmp);
-  orc_x86_emit_mov_imm_reg (p, 4, mask2, X86_ECX);
-  orc_x86_emit_mov_reg_sse (p, X86_ECX, tmp2);
+  orc_x86_emit_mov_imm_reg (p, 4, mask2, p->gp_tmpreg);
+  orc_x86_emit_mov_reg_sse (p, p->gp_tmpreg, tmp2);
   orc_sse_emit_660f (p, "punpcklbw", 0x60, tmp2, tmp2);
   orc_sse_emit_660f (p, "punpcklwd", 0x61, tmp2, tmp2);
   orc_sse_emit_660f (p, "paddb", 0xfc, tmp2, tmp);
@@ -616,8 +616,8 @@ sse_rule_maxuw_slow (OrcCompiler *p, void *user, OrcInstruction *insn)
   int dest = p->vars[insn->dest_args[0]].alloc;
   int tmp = p->tmpreg;
 
-  orc_x86_emit_mov_imm_reg (p, 4, 0x80008000, X86_ECX);
-  orc_x86_emit_mov_reg_sse (p, X86_ECX, tmp);
+  orc_x86_emit_mov_imm_reg (p, 4, 0x80008000, p->gp_tmpreg);
+  orc_x86_emit_mov_reg_sse (p, p->gp_tmpreg, tmp);
   orc_sse_emit_pshufd (p, 0, tmp, tmp);
   orc_sse_emit_660f (p, "pxor", 0xef, tmp, src);
   orc_sse_emit_660f (p, "pxor", 0xef, tmp, dest);