Fixes for x86-64

diff --git a/orc-test/orctest.c b/orc-test/orctest.c
index 88e4564..455da01 100644 (file)
--- a/orc-test/orctest.c
+++ b/orc-test/orctest.c
@@ -1,4 +1,6 @@
 
+#include "config.h"
+
 #include <orc-test/orctest.h>
 #include <orc/orc.h>
 #include <orc/orcdebug.h>
@@ -53,7 +55,14 @@ orc_test_gcc_compile (OrcProgram *p)
     return FALSE;
   }
 
-  sprintf (cmd, "objcopy -I binary -O elf32-i386 -B i386 "
+  sprintf (cmd, "objcopy -I binary "
+#ifdef HAVE_I386
+      "-O elf32-i386 -B i386 "
+#elif defined(HAVE_AMD64)
+      "-O elf64-x86-64 -B i386 "
+#else
+      /* FIXME */
+#endif
       "--rename-section .data=.text "
       "--redefine-sym _binary_dump_start=%s "
       "dump tmp.o", p->name);
@@ -126,7 +135,11 @@ print_array_val_signed (void *array, int size, int i)
     case 8:
       {
         int64_t *a = array;
+#ifdef HAVE_AMD64
+        printf(" %20ld", a[i]);
+#else
         printf(" %20lld", a[i]);
+#endif
         return a[i];
       }
       break;
@@ -163,7 +176,11 @@ print_array_val_unsigned (void *array, int size, int i)
     case 8:
       {
         uint64_t *a = array;
+#ifdef HAVE_AMD64
+        printf(" %20lu", a[i]);
+#else
         printf(" %20llu", a[i]);
+#endif
         return a[i];
       }
       break;
@@ -200,7 +217,11 @@ print_array_val_hex (void *array, int size, int i)
     case 8:
       {
         uint64_t *a = array;
+#ifdef HAVE_AMD64
+        printf(" %20lx", a[i]);
+#else
         printf(" %16llx", a[i]);
+#endif
         return a[i];
       }
       break;

diff --git a/orc/orccompiler.c b/orc/orccompiler.c
index 849292d..ed3a45a 100644 (file)
--- a/orc/orccompiler.c
+++ b/orc/orccompiler.c
@@ -22,6 +22,8 @@ int
 orc_compiler_allocate_register (OrcCompiler *compiler, int data_reg)
 {
   int i;
+  int roff;
+  int reg;
   int offset;
 
   if (data_reg) {
@@ -30,21 +32,25 @@ orc_compiler_allocate_register (OrcCompiler *compiler, int data_reg)
     offset = ORC_GP_REG_BASE;
   }
 
-  for(i=offset;i<offset+32;i++){
-    if (compiler->valid_regs[i] &&
-        !compiler->save_regs[i] &&
-        compiler->alloc_regs[i] == 0) {
-      compiler->alloc_regs[i]++;
-      compiler->used_regs[i] = 1;
-      return i;
+  roff = rand()&0xf;
+
+  for(i=0;i<32;i++){
+    reg = offset + ((roff + i)&0x1f);
+    if (compiler->valid_regs[reg] &&
+        !compiler->save_regs[reg] &&
+        compiler->alloc_regs[reg] == 0) {
+      compiler->alloc_regs[reg]++;
+      compiler->used_regs[reg] = 1;
+      return reg;
     }
   }
-  for(i=offset;i<offset+32;i++){
-    if (compiler->valid_regs[i] &&
-        compiler->alloc_regs[i] == 0) {
-      compiler->alloc_regs[i]++;
-      compiler->used_regs[i] = 1;
-      return i;
+  for(i=0;i<32;i++){
+    reg = offset + ((roff + i)&0x1f);
+    if (compiler->valid_regs[reg] &&
+        compiler->alloc_regs[reg] == 0) {
+      compiler->alloc_regs[reg]++;
+      compiler->used_regs[reg] = 1;
+      return reg;
     }
   }
 

diff --git a/orc/orcopcodes.c b/orc/orcopcodes.c
index 447d621..712784a 100644 (file)
--- a/orc/orcopcodes.c
+++ b/orc/orcopcodes.c
@@ -259,13 +259,13 @@ convsuswb (OrcOpcodeExecutor *ex, void *user)
 static void
 convusswb (OrcOpcodeExecutor *ex, void *user)
 {
-  ex->dest_values[0] = ORC_CLAMP_SB((int)(uint16_t)(ex->src_values[0]));
+  ex->dest_values[0] = MIN((int)(uint16_t)(ex->src_values[0]), ORC_SB_MAX);
 }
 
 static void
 convuuswb (OrcOpcodeExecutor *ex, void *user)
 {
-  ex->dest_values[0] = ORC_CLAMP_UB((int)(uint16_t)(ex->src_values[0]));
+  ex->dest_values[0] = MIN((int)(uint16_t)(ex->src_values[0]), ORC_UB_MAX);
 }
 
 static void

diff --git a/orc/orcprogram-sse.c b/orc/orcprogram-sse.c
index 744f500..91c020f 100644 (file)
--- a/orc/orcprogram-sse.c
+++ b/orc/orcprogram-sse.c
@@ -90,7 +90,7 @@ orc_compiler_sse_init (OrcCompiler *compiler)
     compiler->used_regs[i] = 0;
   }
 
-  compiler->tmpreg = X86_XMM0;
+  compiler->tmpreg = X86_XMM0 + 12;
   compiler->valid_regs[compiler->tmpreg] = 0;
 
   switch (orc_program_get_max_var_size (compiler->program)) {

diff --git a/orc/orcrules-sse.c b/orc/orcrules-sse.c
index 0f15980..94113cc 100644 (file)
--- a/orc/orcrules-sse.c
+++ b/orc/orcrules-sse.c
@@ -25,7 +25,7 @@ sse_emit_f20f (OrcCompiler *p, const char *insn_name, int code,
       x86_get_regname_sse(src),
       x86_get_regname_sse(dest));
   *p->codeptr++ = 0xf2;
-  x86_emit_rex (p, 0, src, 0, dest);
+  x86_emit_rex (p, 0, dest, 0, src);
   *p->codeptr++ = 0x0f;
   *p->codeptr++ = code;
   x86_emit_modrm_reg (p, src, dest);
@@ -39,7 +39,7 @@ sse_emit_660f (OrcCompiler *p, const char *insn_name, int code,
       x86_get_regname_sse(src),
       x86_get_regname_sse(dest));
   *p->codeptr++ = 0x66;
-  x86_emit_rex (p, 0, src, 0, dest);
+  x86_emit_rex (p, 0, dest, 0, src);
   *p->codeptr++ = 0x0f;
   *p->codeptr++ = code;
   x86_emit_modrm_reg (p, src, dest);
@@ -53,7 +53,7 @@ sse_emit_660f38 (OrcCompiler *p, const char *insn_name, int code,
       x86_get_regname_sse(src),
       x86_get_regname_sse(dest));
   *p->codeptr++ = 0x66;
-  x86_emit_rex (p, 0, src, 0, dest);
+  x86_emit_rex (p, 0, dest, 0, src);
   *p->codeptr++ = 0x0f;
   *p->codeptr++ = 0x38;
   *p->codeptr++ = code;
@@ -68,6 +68,7 @@ sse_emit_loadil (OrcCompiler *p, int reg, int value)
   if (value == 0) {
     ORC_ASM_CODE(p,"  pxor %%%s, %%%s\n", x86_get_regname_sse(reg),
         x86_get_regname_sse(reg));
+    x86_emit_rex (p, 0, reg, 0, reg);
     *p->codeptr++ = 0x0f;
     *p->codeptr++ = 0xef;
     x86_emit_modrm_reg (p, reg, reg);
@@ -76,6 +77,7 @@ sse_emit_loadil (OrcCompiler *p, int reg, int value)
 
     ORC_ASM_CODE(p,"  movd %%ecx, %%%s\n", x86_get_regname_sse(reg));
     *p->codeptr++ = 0x66;
+    x86_emit_rex (p, 0, reg, 0, X86_ECX);
     *p->codeptr++ = 0x0f;
     *p->codeptr++ = 0x6e;
     x86_emit_modrm_reg (p, X86_ECX, reg);
@@ -83,6 +85,7 @@ sse_emit_loadil (OrcCompiler *p, int reg, int value)
     ORC_ASM_CODE(p,"  pshufd $0, %%%s, %%%s\n", x86_get_regname_sse(reg),
         x86_get_regname_sse(reg));
     *p->codeptr++ = 0x66;
+    x86_emit_rex (p, 0, reg, 0, reg);
     *p->codeptr++ = 0x0f;
     *p->codeptr++ = 0x70;
     x86_emit_modrm_reg (p, reg, reg);
@@ -110,21 +113,16 @@ sse_emit_loadiw (OrcCompiler *p, int reg, int value)
 void
 sse_emit_loadpb (OrcCompiler *p, int reg, int param)
 {
-  ORC_ASM_CODE(p,"  movd %d(%%%s), %%%s\n",
+  x86_emit_mov_memoffset_sse (p, 4, 
       (int)ORC_STRUCT_OFFSET(OrcExecutor, params[param]),
-      x86_get_regname_ptr(x86_exec_ptr),
-      x86_get_regname_sse(reg));
-  *p->codeptr++ = 0x66;
-  *p->codeptr++ = 0x0f;
-  *p->codeptr++ = 0x6e;
-  x86_emit_modrm_memoffset (p, reg,
-      (int)ORC_STRUCT_OFFSET(OrcExecutor, params[param]), x86_exec_ptr);
+      x86_exec_ptr, reg, FALSE);
 
   sse_emit_660f (p, "punpcklbw", 0x60, reg, reg);
 
   ORC_ASM_CODE(p,"  pshuflw $0, %%%s, %%%s\n", x86_get_regname_sse(reg),
       x86_get_regname_sse(reg));
   *p->codeptr++ = 0xf2;
+  x86_emit_rex (p, 0, reg, 0, reg);
   *p->codeptr++ = 0x0f;
   *p->codeptr++ = 0x70;
   x86_emit_modrm_reg (p, reg, reg);
@@ -133,6 +131,7 @@ sse_emit_loadpb (OrcCompiler *p, int reg, int param)
   ORC_ASM_CODE(p,"  pshufd $0, %%%s, %%%s\n", x86_get_regname_sse(reg),
       x86_get_regname_sse(reg));
   *p->codeptr++ = 0x66;
+  x86_emit_rex (p, 0, reg, 0, reg);
   *p->codeptr++ = 0x0f;
   *p->codeptr++ = 0x70;
   x86_emit_modrm_reg (p, reg, reg);
@@ -142,19 +141,14 @@ sse_emit_loadpb (OrcCompiler *p, int reg, int param)
 void
 sse_emit_loadpw (OrcCompiler *p, int reg, int param)
 {
-  ORC_ASM_CODE(p,"  movd %d(%%%s), %%%s\n",
+  x86_emit_mov_memoffset_sse (p, 4, 
       (int)ORC_STRUCT_OFFSET(OrcExecutor, params[param]),
-      x86_get_regname_ptr(x86_exec_ptr),
-      x86_get_regname_sse(reg));
-  *p->codeptr++ = 0x66;
-  *p->codeptr++ = 0x0f;
-  *p->codeptr++ = 0x6e;
-  x86_emit_modrm_memoffset (p, reg,
-      (int)ORC_STRUCT_OFFSET(OrcExecutor, params[param]), x86_exec_ptr);
+      x86_exec_ptr, reg, FALSE);
 
   ORC_ASM_CODE(p,"  pshuflw $0, %%%s, %%%s\n", x86_get_regname_sse(reg),
       x86_get_regname_sse(reg));
   *p->codeptr++ = 0xf2;
+  x86_emit_rex (p, 0, reg, 0, reg);
   *p->codeptr++ = 0x0f;
   *p->codeptr++ = 0x70;
   x86_emit_modrm_reg (p, reg, reg);
@@ -163,6 +157,7 @@ sse_emit_loadpw (OrcCompiler *p, int reg, int param)
   ORC_ASM_CODE(p,"  pshufd $0, %%%s, %%%s\n", x86_get_regname_sse(reg),
       x86_get_regname_sse(reg));
   *p->codeptr++ = 0x66;
+  x86_emit_rex (p, 0, reg, 0, reg);
   *p->codeptr++ = 0x0f;
   *p->codeptr++ = 0x70;
   x86_emit_modrm_reg (p, reg, reg);
@@ -172,19 +167,14 @@ sse_emit_loadpw (OrcCompiler *p, int reg, int param)
 void
 sse_emit_loadpl (OrcCompiler *p, int reg, int param)
 {
-  ORC_ASM_CODE(p,"  movd %d(%%%s), %%%s\n",
+  x86_emit_mov_memoffset_sse (p, 4, 
       (int)ORC_STRUCT_OFFSET(OrcExecutor, params[param]),
-      x86_get_regname_ptr(x86_exec_ptr),
-      x86_get_regname_sse(reg));
-  *p->codeptr++ = 0x66;
-  *p->codeptr++ = 0x0f;
-  *p->codeptr++ = 0x6e;
-  x86_emit_modrm_memoffset (p, reg,
-      (int)ORC_STRUCT_OFFSET(OrcExecutor, params[param]), x86_exec_ptr);
+      x86_exec_ptr, reg, FALSE);
 
   ORC_ASM_CODE(p,"  pshufd $0, %%%s, %%%s\n", x86_get_regname_sse(reg),
       x86_get_regname_sse(reg));
   *p->codeptr++ = 0x66;
+  x86_emit_rex (p, 0, reg, 0, reg);
   *p->codeptr++ = 0x0f;
   *p->codeptr++ = 0x70;
   x86_emit_modrm_reg (p, reg, reg);
@@ -194,19 +184,14 @@ sse_emit_loadpl (OrcCompiler *p, int reg, int param)
 void
 sse_emit_loadpq (OrcCompiler *p, int reg, int param)
 {
-  ORC_ASM_CODE(p,"  movq %d(%%%s), %%%s\n",
+  x86_emit_mov_memoffset_sse (p, 8, 
       (int)ORC_STRUCT_OFFSET(OrcExecutor, params[param]),
-      x86_get_regname_ptr(x86_exec_ptr),
-      x86_get_regname_sse(reg));
-  *p->codeptr++ = 0xf3;
-  *p->codeptr++ = 0x0f;
-  *p->codeptr++ = 0x7e;
-  x86_emit_modrm_memoffset (p, reg,
-      (int)ORC_STRUCT_OFFSET(OrcExecutor, params[param]), x86_exec_ptr);
+      x86_exec_ptr, reg, FALSE);
 
   ORC_ASM_CODE(p,"  pshufd $0, %%%s, %%%s\n", x86_get_regname_sse(reg),
       x86_get_regname_sse(reg));
   *p->codeptr++ = 0x66;
+  x86_emit_rex (p, 0, reg, 0, reg);
   *p->codeptr++ = 0x0f;
   *p->codeptr++ = 0x70;
   x86_emit_modrm_reg (p, reg, reg);
@@ -229,7 +214,7 @@ sse_emit_66_rex_0f (OrcCompiler *p, OrcInstruction *insn, int code,
       x86_get_regname_sse(src), x86_get_regname_sse(dest));
 
   *p->codeptr++ = 0x66;
-  x86_emit_rex (p, 0, src, 0, dest);
+  x86_emit_rex (p, 0, dest, 0, src);
   *p->codeptr++ = 0x0f;
   if (code & 0xff00) {
     *p->codeptr++ = code >> 8;
@@ -361,6 +346,7 @@ sse_rule_accsadubl (OrcCompiler *p, void *user, OrcInstruction *insn)
 #if 0
   ORC_ASM_CODE(p,"  movd %%%s, %%ecx\n", x86_get_regname_sse(dest));
   *p->codeptr++ = 0x66;
+  x86_emit_rex (p, 0, dest, 0, X86_ECX);
   *p->codeptr++ = 0x0f;
   *p->codeptr++ = 0x7e;
   x86_emit_modrm_reg (p, X86_ECX, dest);
@@ -372,6 +358,7 @@ sse_rule_accsadubl (OrcCompiler *p, void *user, OrcInstruction *insn)
   if (p->loop_shift > 3) {
     ORC_ASM_CODE(p,"  psrldq $8, %%%s\n", x86_get_regname_sse(dest));
     *p->codeptr++ = 0x66;
+    x86_emit_rex (p, 0, 0, 0, dest);
     *p->codeptr++ = 0x0f;
     *p->codeptr++ = 0x73;
     x86_emit_modrm_reg (p, dest, 3);
@@ -379,6 +366,7 @@ sse_rule_accsadubl (OrcCompiler *p, void *user, OrcInstruction *insn)
 
     ORC_ASM_CODE(p,"  movd %%%s, %%ecx\n", x86_get_regname_sse(dest));
     *p->codeptr++ = 0x66;
+    x86_emit_rex (p, 0, dest, 0, X86_ECX);
     *p->codeptr++ = 0x0f;
     *p->codeptr++ = 0x7e;
     x86_emit_modrm_reg (p, X86_ECX, dest);
@@ -405,10 +393,11 @@ sse_rule_signX (OrcCompiler *p, void *user, OrcInstruction *insn)
     src = p->tmpreg;
   }
 
-  x86_emit_mov_imm_reg (p, 4, imm_vals[((int)user)], X86_ECX);
+  x86_emit_mov_imm_reg (p, 4, imm_vals[ORC_PTR_TO_INT(user)], X86_ECX);
 
   ORC_ASM_CODE(p,"  movd %%ecx, %%%s\n", x86_get_regname_sse(dest));
   *p->codeptr++ = 0x66;
+  x86_emit_rex (p, 0, dest, 0, X86_ECX);
   *p->codeptr++ = 0x0f;
   *p->codeptr++ = 0x6e;
   x86_emit_modrm_reg (p, X86_ECX, dest);
@@ -416,18 +405,19 @@ sse_rule_signX (OrcCompiler *p, void *user, OrcInstruction *insn)
   ORC_ASM_CODE(p,"  pshufd $0, %%%s, %%%s\n", x86_get_regname_sse(dest),
       x86_get_regname_sse(dest));
   *p->codeptr++ = 0x66;
+  x86_emit_rex (p, 0, dest, 0, dest);
   *p->codeptr++ = 0x0f;
   *p->codeptr++ = 0x70;
   x86_emit_modrm_reg (p, dest, dest);
   *p->codeptr++ = 0x00;
 
-  sse_emit_660f38 (p, names[((int)user)], codes[((int)user)], src, dest);
+  sse_emit_660f38 (p, names[ORC_PTR_TO_INT(user)], codes[ORC_PTR_TO_INT(user)], src, dest);
 }
 
 static void
 sse_rule_shift (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
-  int type = (int)user;
+  int type = ORC_PTR_TO_INT(user);
   int imm_code1[] = { 0x71, 0x71, 0x71, 0x72, 0x72, 0x72 };
   int imm_code2[] = { 6, 2, 4, 6, 2, 4 };
   int reg_code[] = { 0xf1, 0xd1, 0xe1, 0xf2, 0xd2, 0xe2 };
@@ -439,6 +429,7 @@ sse_rule_shift (OrcCompiler *p, void *user, OrcInstruction *insn)
         x86_get_regname_sse(p->vars[insn->dest_args[0]].alloc));
 
     *p->codeptr++ = 0x66;
+    x86_emit_rex (p, 0, 0, 0, p->vars[insn->dest_args[0]].alloc);
     *p->codeptr++ = 0x0f;
     *p->codeptr++ = imm_code1[type];
     x86_emit_modrm_reg (p, p->vars[insn->dest_args[0]].alloc, imm_code2[type]);
@@ -446,27 +437,19 @@ sse_rule_shift (OrcCompiler *p, void *user, OrcInstruction *insn)
   } else if (p->vars[insn->src_args[1]].vartype == ORC_VAR_TYPE_PARAM) {
     /* FIXME this is a gross hack to reload the register with a
      * 64-bit version of the parameter. */
-    ORC_ASM_CODE(p,"  movd %d(%%%s), %%%s\n",
+    x86_emit_mov_memoffset_sse (p, 4, 
         (int)ORC_STRUCT_OFFSET(OrcExecutor, params[insn->src_args[1]]),
-        x86_get_regname_ptr(x86_exec_ptr),
-        x86_get_regname_sse(p->tmpreg));
-    *p->codeptr++ = 0x66;
-    *p->codeptr++ = 0x0f;
-    *p->codeptr++ = 0x6e;
-    x86_emit_modrm_memoffset (p,
-        p->tmpreg,
-        (int)ORC_STRUCT_OFFSET(OrcExecutor, params[insn->src_args[1]]),
-        x86_exec_ptr);
+        x86_exec_ptr, p->tmpreg, FALSE);
 
     ORC_ASM_CODE(p,"  %s %%%s, %%%s\n", code[type],
         x86_get_regname_sse(p->tmpreg),
         x86_get_regname_sse(p->vars[insn->dest_args[0]].alloc));
 
     *p->codeptr++ = 0x66;
+    x86_emit_rex (p, 0, p->vars[insn->dest_args[0]].alloc, 0, p->tmpreg);
     *p->codeptr++ = 0x0f;
     *p->codeptr++ = reg_code[type];
-    x86_emit_modrm_reg (p, p->tmpreg,
-        p->vars[insn->dest_args[0]].alloc);
+    x86_emit_modrm_reg (p, p->tmpreg, p->vars[insn->dest_args[0]].alloc);
   } else {
     ORC_PROGRAM_ERROR(p,"rule only works with constants or params");
   }
@@ -483,6 +466,7 @@ sse_rule_convsbw (OrcCompiler *p, void *user, OrcInstruction *insn)
       x86_get_regname_sse(p->vars[insn->dest_args[0]].alloc));
   
   *p->codeptr++ = 0x66;
+  x86_emit_rex (p, 0, 0, 0, p->vars[insn->dest_args[0]].alloc);
   *p->codeptr++ = 0x0f;
   *p->codeptr++ = 0x71;
   x86_emit_modrm_reg (p, p->vars[insn->dest_args[0]].alloc, 4);
@@ -501,6 +485,7 @@ sse_rule_convubw (OrcCompiler *p, void *user, OrcInstruction *insn)
   ORC_ASM_CODE(p,"  psrlw $8, %%%s\n",
       x86_get_regname_sse(p->vars[insn->dest_args[0]].alloc));
   *p->codeptr++ = 0x66;
+  x86_emit_rex (p, 0, 0, 0, p->vars[insn->dest_args[0]].alloc);
   *p->codeptr++ = 0x0f;
   *p->codeptr++ = 0x71;
   x86_emit_modrm_reg (p, p->vars[insn->dest_args[0]].alloc, 2);
@@ -539,6 +524,7 @@ sse_rule_convwb (OrcCompiler *p, void *user, OrcInstruction *insn)
   ORC_ASM_CODE(p,"  psllw $8, %%%s\n",
       x86_get_regname_sse(p->vars[insn->dest_args[0]].alloc));
   *p->codeptr++ = 0x66;
+  x86_emit_rex (p, 0, 0, 0, p->vars[insn->dest_args[0]].alloc);
   *p->codeptr++ = 0x0f;
   *p->codeptr++ = 0x71;
   x86_emit_modrm_reg (p, p->vars[insn->dest_args[0]].alloc, 6);
@@ -547,6 +533,7 @@ sse_rule_convwb (OrcCompiler *p, void *user, OrcInstruction *insn)
   ORC_ASM_CODE(p,"  psrlw $8, %%%s\n",
       x86_get_regname_sse(p->vars[insn->dest_args[0]].alloc));
   *p->codeptr++ = 0x66;
+  x86_emit_rex (p, 0, 0, 0, p->vars[insn->dest_args[0]].alloc);
   *p->codeptr++ = 0x0f;
   *p->codeptr++ = 0x71;
   x86_emit_modrm_reg (p, p->vars[insn->dest_args[0]].alloc, 2);
@@ -567,6 +554,7 @@ sse_rule_convswl (OrcCompiler *p, void *user, OrcInstruction *insn)
   ORC_ASM_CODE(p,"  psrad $16, %%%s\n",
       x86_get_regname_sse(p->vars[insn->dest_args[0]].alloc));
   *p->codeptr++ = 0x66;
+  x86_emit_rex (p, 0, 0, 0, p->vars[insn->dest_args[0]].alloc);
   *p->codeptr++ = 0x0f;
   *p->codeptr++ = 0x72;
   x86_emit_modrm_reg (p, p->vars[insn->dest_args[0]].alloc, 4);
@@ -586,6 +574,7 @@ sse_rule_convuwl (OrcCompiler *p, void *user, OrcInstruction *insn)
       x86_get_regname_sse(p->vars[insn->dest_args[0]].alloc));
   
   *p->codeptr++ = 0x66;
+  x86_emit_rex (p, 0, 0, 0, p->vars[insn->dest_args[0]].alloc);
   *p->codeptr++ = 0x0f;
   *p->codeptr++ = 0x72;
   x86_emit_modrm_reg (p, p->vars[insn->dest_args[0]].alloc, 2);
@@ -608,6 +597,7 @@ sse_rule_convlw (OrcCompiler *p, void *user, OrcInstruction *insn)
   ORC_ASM_CODE(p,"  pslld $16, %%%s\n",
       x86_get_regname_sse(p->vars[insn->dest_args[0]].alloc));
   *p->codeptr++ = 0x66;
+  x86_emit_rex (p, 0, 0, 0, p->vars[insn->dest_args[0]].alloc);
   *p->codeptr++ = 0x0f;
   *p->codeptr++ = 0x72;
   x86_emit_modrm_reg (p, p->vars[insn->dest_args[0]].alloc, 6);
@@ -616,6 +606,7 @@ sse_rule_convlw (OrcCompiler *p, void *user, OrcInstruction *insn)
   ORC_ASM_CODE(p,"  psrad $16, %%%s\n",
       x86_get_regname_sse(p->vars[insn->dest_args[0]].alloc));
   *p->codeptr++ = 0x66;
+  x86_emit_rex (p, 0, 0, 0, p->vars[insn->dest_args[0]].alloc);
   *p->codeptr++ = 0x0f;
   *p->codeptr++ = 0x72;
   x86_emit_modrm_reg (p, p->vars[insn->dest_args[0]].alloc, 4);
@@ -664,6 +655,7 @@ sse_rule_maxuw_slow (OrcCompiler *p, void *user, OrcInstruction *insn)
 
   ORC_ASM_CODE(p,"  movd %%ecx, %%%s\n", x86_get_regname_sse(tmp));
   *p->codeptr++ = 0x66;
+  x86_emit_rex (p, 0, tmp, 0, X86_ECX);
   *p->codeptr++ = 0x0f;
   *p->codeptr++ = 0x6e;
   x86_emit_modrm_reg (p, X86_ECX, tmp);
@@ -671,6 +663,7 @@ sse_rule_maxuw_slow (OrcCompiler *p, void *user, OrcInstruction *insn)
   ORC_ASM_CODE(p,"  pshufd $0, %%%s, %%%s\n", x86_get_regname_sse(tmp),
       x86_get_regname_sse(tmp));
   *p->codeptr++ = 0x66;
+  x86_emit_rex (p, 0, tmp, 0, tmp);
   *p->codeptr++ = 0x0f;
   *p->codeptr++ = 0x70;
   x86_emit_modrm_reg (p, tmp, tmp);
@@ -929,6 +922,7 @@ orc_compiler_sse_register_rules (OrcTarget *target)
 
   /* SSE 3 -- no rules */
 
+if (0) {
   /* SSSE 3 */
   rule_set = orc_rule_set_new (orc_opcode_set_get("sys"), target);
 
@@ -938,6 +932,7 @@ orc_compiler_sse_register_rules (OrcTarget *target)
   REG(absb);
   REG(absw);
   REG(absl);
+}
 
 if (0) {
   /* SSE 4.1 */

diff --git a/orc/orcutils.h b/orc/orcutils.h
index d921383..31b685e 100644 (file)
--- a/orc/orcutils.h
+++ b/orc/orcutils.h
@@ -52,6 +52,7 @@ typedef unsigned int orc_bool;
 #ifndef ORC_CLAMP
 #define ORC_CLAMP(x,a,b) ((x)<(a) ? (a) : ((x)>(b) ? (b) : (x)))
 #endif
+#define ORC_PTR_TO_INT(x) ((int)(long)(x))
 #define ROUND_UP_SHIFT(x,y) (((x) + (1<<(y)) - 1)>>(y))
 #define ROUND_UP_POW2(x,y) (((x) + (1<<(y)) - 1)&((~0)<<(y)))
 #define ROUND_UP_2(x) ROUND_UP_POW2(x,1)

diff --git a/orc/x86.c b/orc/x86.c
index 976a8c7..b8dbfb5 100644 (file)
--- a/orc/x86.c
+++ b/orc/x86.c
@@ -222,9 +222,9 @@ x86_emit_rex (OrcCompiler *compiler, int size, int reg1, int reg2, int reg3)
 
   if (x86_64) {
     if (size >= 8) rex |= 0x08;
-    if (reg1 == 1 || (x86_get_regnum(reg1)>=8)) rex |= 0x4;
-    if (reg2 == 1 || (x86_get_regnum(reg2)>=8)) rex |= 0x2;
-    if (reg3 == 1 || (x86_get_regnum(reg3)>=8)) rex |= 0x1;
+    if (reg1 & 8) rex |= 0x4;
+    if (reg2 & 8) rex |= 0x2;
+    if (reg3 & 8) rex |= 0x1;
 
     if (rex != 0x40) *compiler->codeptr++ = rex;
   }
@@ -237,8 +237,10 @@ x86_emit_mov_memoffset_reg (OrcCompiler *compiler, int size, int offset,
 
   switch (size) {
     case 1:
-      ORC_ASM_CODE(compiler,"  movb %d(%%%s), %%%s\n", offset, x86_get_regname_ptr(reg1),
+      ORC_ASM_CODE(compiler,"  movb %d(%%%s), %%%s\n", offset,
+          x86_get_regname_ptr(reg1),
           x86_get_regname_8(reg2));
+      x86_emit_rex(compiler, size, reg2, 0, reg1);
       *compiler->codeptr++ = 0x8a;
       x86_emit_modrm_memoffset (compiler, reg2, offset, reg1);
       return;
@@ -302,6 +304,7 @@ x86_emit_mov_memoffset_sse (OrcCompiler *compiler, int size, int offset,
       ORC_ASM_CODE(compiler,"  movq %d(%%%s), %%%s\n", offset, x86_get_regname_ptr(reg1),
           x86_get_regname_sse(reg2));
       *compiler->codeptr++ = 0xf3;
+      x86_emit_rex(compiler, 0, reg2, 0, reg1);
       *compiler->codeptr++ = 0x0f;
       *compiler->codeptr++ = 0x7e;
       break;
@@ -337,6 +340,7 @@ x86_emit_mov_reg_memoffset (OrcCompiler *compiler, int size, int reg1, int offse
     case 1:
       ORC_ASM_CODE(compiler,"  movb %%%s, %d(%%%s)\n", x86_get_regname_8(reg1), offset,
           x86_get_regname_ptr(reg2));
+      x86_emit_rex(compiler, size, reg1, 0, reg2);
       *compiler->codeptr++ = 0x88;
       x86_emit_modrm_memoffset (compiler, reg1, offset, reg2);
       return;
@@ -410,12 +414,14 @@ x86_emit_mov_sse_memoffset (OrcCompiler *compiler, int size, int reg1, int offse
           ORC_ASM_CODE(compiler,"  movntdq %%%s, %d(%%%s)\n", x86_get_regname_sse(reg1), offset,
               x86_get_regname_ptr(reg2));
           *compiler->codeptr++ = 0x66;
+          x86_emit_rex(compiler, 0, reg1, 0, reg2);
           *compiler->codeptr++ = 0x0f;
           *compiler->codeptr++ = 0xe7;
         } else {
           ORC_ASM_CODE(compiler,"  movdqa %%%s, %d(%%%s)\n", x86_get_regname_sse(reg1), offset,
               x86_get_regname_ptr(reg2));
           *compiler->codeptr++ = 0x66;
+          x86_emit_rex(compiler, 0, reg1, 0, reg2);
           *compiler->codeptr++ = 0x0f;
           *compiler->codeptr++ = 0x7f;
         }
@@ -423,6 +429,7 @@ x86_emit_mov_sse_memoffset (OrcCompiler *compiler, int size, int reg1, int offse
         ORC_ASM_CODE(compiler,"  movdqu %%%s, %d(%%%s)\n", x86_get_regname_sse(reg1), offset,
             x86_get_regname_ptr(reg2));
         *compiler->codeptr++ = 0xf3;
+        x86_emit_rex(compiler, 0, reg1, 0, reg2);
         *compiler->codeptr++ = 0x0f;
         *compiler->codeptr++ = 0x7f;
       }
@@ -525,11 +532,10 @@ void x86_emit_mov_mmx_reg (OrcCompiler *compiler, int reg1, int reg2)
 
 void x86_emit_mov_reg_sse (OrcCompiler *compiler, int reg1, int reg2)
 {
-  /* FIXME */
   ORC_ASM_CODE(compiler,"  movd %%%s, %%%s\n", x86_get_regname(reg1),
       x86_get_regname_sse(reg2));
   *compiler->codeptr++ = 0x66;
-  x86_emit_rex(compiler, 0, reg1, 0, reg2);
+  x86_emit_rex(compiler, 0, reg2, 0, reg1);
   *compiler->codeptr++ = 0x0f;
   *compiler->codeptr++ = 0x6e;
   x86_emit_modrm_reg (compiler, reg1, reg2);
@@ -537,11 +543,10 @@ void x86_emit_mov_reg_sse (OrcCompiler *compiler, int reg1, int reg2)
 
 void x86_emit_mov_sse_reg (OrcCompiler *compiler, int reg1, int reg2)
 {
-  /* FIXME */
   ORC_ASM_CODE(compiler,"  movd %%%s, %%%s\n", x86_get_regname_sse(reg1),
       x86_get_regname(reg2));
   *compiler->codeptr++ = 0x66;
-  x86_emit_rex(compiler, 0, reg2, 0, reg1);
+  x86_emit_rex(compiler, 0, reg1, 0, reg2);
   *compiler->codeptr++ = 0x0f;
   *compiler->codeptr++ = 0x7e;
   x86_emit_modrm_reg (compiler, reg2, reg1);