x86: more sysinsn conversion

diff --git a/orc/orcrules-sse.c b/orc/orcrules-sse.c
index 5075832..875dfb2 100644 (file)
--- a/orc/orcrules-sse.c
+++ b/orc/orcrules-sse.c
@@ -1547,11 +1547,8 @@ sse_rule_mulhsl_slow (OrcCompiler *p, void *user, OrcInstruction *insn)
 
   for(i=0;i<(1<<p->insn_shift);i++) {
     orc_x86_emit_mov_memoffset_reg (p, 4, offset + 4*i, p->exec_reg, X86_EAX);
-    ORC_ASM_CODE(p,"  imull %d(%%%s)\n", offset + 16 + 4*i,
-        orc_x86_get_regname_ptr(p, p->exec_reg));
-    orc_x86_emit_rex(p, 4, 0, 0, p->exec_reg);
-    *p->codeptr++ = 0xf7;
-    orc_x86_emit_modrm_memoffset_old (p, 5, offset + 16 + 4*i, p->exec_reg);
+    orc_sse_emit_sysinsn_load_memoffset (p, ORC_X86_imul_rm, 0,
+        offset + 16 + 4*i, p->exec_reg, -1);
     orc_x86_emit_mov_reg_memoffset (p, 4, X86_EDX, offset + 4*i, p->exec_reg);
   }
 

diff --git a/orc/orcsse.c b/orc/orcsse.c
index 0c4f766..cf19766 100644 (file)
--- a/orc/orcsse.c
+++ b/orc/orcsse.c
@@ -149,8 +149,6 @@ void orc_x86_emit_mov_sse_reg (OrcCompiler *compiler, int reg1, int reg2)
 void
 orc_sse_set_mxcsr (OrcCompiler *compiler)
 {
-  int value;
-
   orc_sse_emit_sysinsn_load_memoffset (compiler, ORC_X86_stmxcsr, 0,
       (int)ORC_STRUCT_OFFSET(OrcExecutor,params[ORC_VAR_A4]),
       compiler->exec_reg, -1);
@@ -163,16 +161,8 @@ orc_sse_set_mxcsr (OrcCompiler *compiler)
       (int)ORC_STRUCT_OFFSET(OrcExecutor,params[ORC_VAR_C1]),
       compiler->exec_reg);
 
-  value = 0x8040;
-  ORC_ASM_CODE(compiler,"  orl $%d, %%%s\n", value,
-      orc_x86_get_regname(compiler->gp_tmpreg));
-  orc_x86_emit_rex(compiler, 4, 0, 0, compiler->gp_tmpreg);
-  *compiler->codeptr++ = 0x81;
-  orc_x86_emit_modrm_reg (compiler, compiler->gp_tmpreg, 1);
-  *compiler->codeptr++ = (value & 0xff);
-  *compiler->codeptr++ = ((value>>8) & 0xff);
-  *compiler->codeptr++ = ((value>>16) & 0xff);
-  *compiler->codeptr++ = ((value>>24) & 0xff);
+  orc_sse_emit_sysinsn_imm_reg (compiler, ORC_X86_or_imm32_rm,
+      0x8040, compiler->gp_tmpreg);
 
   orc_x86_emit_mov_reg_memoffset (compiler, 4, compiler->gp_tmpreg,
       (int)ORC_STRUCT_OFFSET(OrcExecutor,params[ORC_VAR_A4]),

diff --git a/orc/orcx86.c b/orc/orcx86.c
index f53a2f5..85d83bb 100644 (file)
--- a/orc/orcx86.c
+++ b/orc/orcx86.c
@@ -110,33 +110,13 @@ orc_x86_get_regname_ptr(OrcCompiler *compiler, int i)
 void
 orc_x86_emit_push (OrcCompiler *compiler, int size, int reg)
 {
-
-  if (size == 1) {
-    ORC_COMPILER_ERROR(compiler, "bad size");
-  } else if (size == 2) {
-    ORC_ASM_CODE(compiler,"  pushw %%%s\n", orc_x86_get_regname_16(reg));
-    *compiler->codeptr++ = 0x66;
-    *compiler->codeptr++ = 0x50 + orc_x86_get_regnum(reg);
-  } else {
-    ORC_ASM_CODE(compiler,"  pushl %%%s\n", orc_x86_get_regname(reg));
-    *compiler->codeptr++ = 0x50 + orc_x86_get_regnum(reg);
-  }
+  orc_sse_emit_sysinsn (compiler, ORC_X86_push, 0, reg, reg);
 }
 
 void
 orc_x86_emit_pop (OrcCompiler *compiler, int size, int reg)
 {
-
-  if (size == 1) {
-    ORC_COMPILER_ERROR(compiler, "bad size");
-  } else if (size == 2) {
-    ORC_ASM_CODE(compiler,"  popw %%%s\n", orc_x86_get_regname_16(reg));
-    *compiler->codeptr++ = 0x66;
-    *compiler->codeptr++ = 0x58 + orc_x86_get_regnum(reg);
-  } else {
-    ORC_ASM_CODE(compiler,"  popl %%%s\n", orc_x86_get_regname(reg));
-    *compiler->codeptr++ = 0x58 + orc_x86_get_regnum(reg);
-  }
+  orc_sse_emit_sysinsn (compiler, ORC_X86_pop, 0, reg, reg);
 }
 
 #define X86_MODRM(mod, rm, reg) ((((mod)&3)<<6)|(((rm)&7)<<0)|(((reg)&7)<<3))
@@ -266,35 +246,21 @@ orc_x86_emit_mov_memoffset_reg (OrcCompiler *compiler, int size, int offset,
 
   switch (size) {
     case 1:
-      ORC_ASM_CODE(compiler,"  movzx %d(%%%s), %%%s\n", offset,
-          orc_x86_get_regname_ptr(compiler, reg1),
-          orc_x86_get_regname(reg2));
-      orc_x86_emit_rex(compiler, size, reg2, 0, reg1);
-      *compiler->codeptr++ = 0x0f;
-      *compiler->codeptr++ = 0xb6;
-      orc_x86_emit_modrm_memoffset_old (compiler, reg2, offset, reg1);
+      orc_sse_emit_sysinsn_memoffset_reg (compiler, ORC_X86_movzx_rm_r, offset, reg1, reg2);
       return;
     case 2:
-      ORC_ASM_CODE(compiler,"  movw %d(%%%s), %%%s\n", offset, orc_x86_get_regname_ptr(compiler, reg1),
-          orc_x86_get_regname_16(reg2));
-      *compiler->codeptr++ = 0x66;
+      orc_sse_emit_sysinsn_memoffset_reg (compiler, ORC_X86_movw_rm_r, offset, reg1, reg2);
       break;
     case 4:
-      ORC_ASM_CODE(compiler,"  movl %d(%%%s), %%%s\n", offset, orc_x86_get_regname_ptr(compiler, reg1),
-          orc_x86_get_regname(reg2));
+      orc_sse_emit_sysinsn_memoffset_reg (compiler, ORC_X86_movl_rm_r, offset, reg1, reg2);
       break;
     case 8:
-      ORC_ASM_CODE(compiler,"  mov %d(%%%s), %%%s\n", offset, orc_x86_get_regname_ptr(compiler, reg1),
-          orc_x86_get_regname_64(reg2));
+      orc_sse_emit_sysinsn_memoffset_reg (compiler, ORC_X86_mov_rm_r, offset, reg1, reg2);
       break;
     default:
       ORC_COMPILER_ERROR(compiler, "bad size");
       break;
   }
-
-  orc_x86_emit_rex(compiler, size, reg2, 0, reg1);
-  *compiler->codeptr++ = 0x8b;
-  orc_x86_emit_modrm_memoffset_old (compiler, reg2, offset, reg1);
 }
 
 void
@@ -313,86 +279,40 @@ orc_x86_emit_mov_reg_memoffset (OrcCompiler *compiler, int size, int reg1, int o
       ORC_ASM_CODE(compiler,"  movw %%%s, %d(%%%s)\n", orc_x86_get_regname_16(reg1), offset,
           orc_x86_get_regname_ptr(compiler, reg2));
       *compiler->codeptr++ = 0x66;
+      orc_x86_emit_rex(compiler, size, reg1, 0, reg2);
+      *compiler->codeptr++ = 0x89;
+      orc_x86_emit_modrm_memoffset_old (compiler, reg1, offset, reg2);
       break;
     case 4:
-      ORC_ASM_CODE(compiler,"  movl %%%s, %d(%%%s)\n", orc_x86_get_regname(reg1), offset,
-          orc_x86_get_regname_ptr(compiler, reg2));
+      orc_sse_emit_sysinsn_reg_memoffset (compiler, ORC_X86_movl_r_rm,
+          reg1, offset, reg2);
       break;
     case 8:
-      ORC_ASM_CODE(compiler,"  mov %%%s, %d(%%%s)\n", orc_x86_get_regname_64(reg1), offset,
-          orc_x86_get_regname_ptr(compiler, reg2));
+      orc_sse_emit_sysinsn_reg_memoffset (compiler, ORC_X86_mov_r_rm,
+          reg1, offset, reg2);
       break;
     default:
       ORC_COMPILER_ERROR(compiler, "bad size");
       break;
   }
 
-  orc_x86_emit_rex(compiler, size, reg1, 0, reg2);
-  *compiler->codeptr++ = 0x89;
-  orc_x86_emit_modrm_memoffset_old (compiler, reg1, offset, reg2);
 }
 
 void
 orc_x86_emit_mov_imm_reg (OrcCompiler *compiler, int size, int value, int reg1)
 {
-  if (size == 2) {
-    ORC_ASM_CODE(compiler,"  movw $%d, %%%s\n", value, orc_x86_get_regname_16(reg1));
-    orc_x86_emit_rex(compiler, size, 0, 0, reg1);
-    *compiler->codeptr++ = 0x66;
-    *compiler->codeptr++ = 0xb8 + (orc_x86_get_regnum(reg1) & 0x7);
-    *compiler->codeptr++ = (value & 0xff);
-    *compiler->codeptr++ = ((value>>8) & 0xff);
-  } else if (size == 4) {
-    ORC_ASM_CODE(compiler,"  movl $%d, %%%s\n", value, orc_x86_get_regname(reg1));
-    orc_x86_emit_rex(compiler, size, 0, 0, reg1);
-    *compiler->codeptr++ = 0xb8 + (orc_x86_get_regnum(reg1) & 0x7);
-    *compiler->codeptr++ = (value & 0xff);
-    *compiler->codeptr++ = ((value>>8) & 0xff);
-    *compiler->codeptr++ = ((value>>16) & 0xff);
-    *compiler->codeptr++ = ((value>>24) & 0xff);
-  } else {
-    /* FIXME */
-  }
-
+  orc_sse_emit_sysinsn_imm_reg (compiler, ORC_X86_mov_imm32_r, value, reg1);
 }
 
 void orc_x86_emit_mov_reg_reg (OrcCompiler *compiler, int size, int reg1, int reg2)
 {
-  if (size == 2) {
-    ORC_ASM_CODE(compiler,"  movw %%%s, %%%s\n", orc_x86_get_regname_16(reg1),
-        orc_x86_get_regname_16(reg2));
-    *compiler->codeptr++ = 0x66;
-  } else if (size == 4) {
-    ORC_ASM_CODE(compiler,"  movl %%%s, %%%s\n", orc_x86_get_regname(reg1),
-        orc_x86_get_regname(reg2));
-  } else {
-    ORC_ASM_CODE(compiler,"  mov %%%s, %%%s\n", orc_x86_get_regname_64(reg1),
-        orc_x86_get_regname_64(reg2));
-  }
-
-  orc_x86_emit_rex(compiler, size, reg1, 0, reg2);
-  *compiler->codeptr++ = 0x89;
-  orc_x86_emit_modrm_reg (compiler, reg2, reg1);
+  orc_sse_emit_sysinsn (compiler, ORC_X86_mov_r_rm, 0, reg1, reg2);
 }
 
 void
 orc_x86_emit_test_reg_reg (OrcCompiler *compiler, int size, int reg1, int reg2)
 {
-  if (size == 2) {
-    ORC_ASM_CODE(compiler,"  testw %%%s, %%%s\n", orc_x86_get_regname_16(reg1),
-        orc_x86_get_regname_16(reg2));
-    *compiler->codeptr++ = 0x66;
-  } else if (size == 4) {
-    ORC_ASM_CODE(compiler,"  testl %%%s, %%%s\n", orc_x86_get_regname(reg1),
-        orc_x86_get_regname(reg2));
-  } else {
-    ORC_ASM_CODE(compiler,"  test %%%s, %%%s\n", orc_x86_get_regname(reg1),
-        orc_x86_get_regname(reg2));
-  }
-
-  orc_x86_emit_rex(compiler, size, reg2, 0, reg1);
-  *compiler->codeptr++ = 0x85;
-  orc_x86_emit_modrm_reg (compiler, reg2, reg1);
+  orc_sse_emit_sysinsn (compiler, ORC_X86_test, 0, reg1, reg2);
 }
 
 void
@@ -468,19 +388,13 @@ orc_x86_emit_add_imm_reg (OrcCompiler *compiler, int size, int value, int reg, o
 {
   if (!record) {
     if (size == 4 && !compiler->is_64bit) {
-      ORC_ASM_CODE(compiler,"  leal %d(%%%s), %%%s\n", value,
-          orc_x86_get_regname(reg), orc_x86_get_regname(reg));
-      orc_x86_emit_rex(compiler, size, 0, 0, reg);
-      *compiler->codeptr++ = 0x8d;
-      orc_x86_emit_modrm_memoffset_old (compiler, reg, value, reg);
+      orc_sse_emit_sysinsn_memoffset_reg (compiler, ORC_X86_leal,
+          value, reg, reg);
       return;
     }
     if (size == 8 && compiler->is_64bit) {
-      ORC_ASM_CODE(compiler,"  leaq %d(%%%s), %%%s\n", value,
-          orc_x86_get_regname_64(reg), orc_x86_get_regname_64(reg));
-      orc_x86_emit_rex(compiler, size, reg, 0, reg);
-      *compiler->codeptr++ = 0x8d;
-      orc_x86_emit_modrm_memoffset_old (compiler, reg, value, reg);
+      orc_sse_emit_sysinsn_memoffset_reg (compiler, ORC_X86_leaq,
+          value, reg, reg);
       return;
     }
   }
@@ -499,20 +413,12 @@ orc_x86_emit_add_reg_reg_shift (OrcCompiler *compiler, int size, int reg1,
     int reg2, int shift)
 {
   if (size == 4) {
-    ORC_ASM_CODE(compiler,"  leal (%%%s, %%%s, %d), %%%s\n",
-        orc_x86_get_regname(reg2),
-        orc_x86_get_regname(reg1), 1<<shift,
-        orc_x86_get_regname(reg2));
+    orc_sse_emit_sysinsn_load_memindex (compiler, ORC_X86_leal, 0,
+        0, reg2, reg1, shift, reg2);
   } else {
-    ORC_ASM_CODE(compiler,"  leaq (%%%s, %%%s, %d), %%%s\n",
-        orc_x86_get_regname_ptr(compiler, reg2),
-        orc_x86_get_regname_ptr(compiler, reg1), 1<<shift,
-        orc_x86_get_regname_ptr(compiler, reg2));
+    orc_sse_emit_sysinsn_load_memindex (compiler, ORC_X86_leaq, 0,
+        0, reg2, reg1, shift, reg2);
   }
-
-  orc_x86_emit_rex(compiler, size, reg2, reg1, reg2);
-  *compiler->codeptr++ = 0x8d;
-  orc_x86_emit_modrm_memindex (compiler, reg2, 0, reg2, reg1, shift);
 }
 
 void
@@ -531,14 +437,8 @@ void
 orc_x86_emit_imul_memoffset_reg (OrcCompiler *compiler, int size,
     int offset, int reg, int destreg)
 {
-  ORC_ASM_CODE(compiler,"  imul %d(%%%s), %%%s\n", offset,
-      orc_x86_get_regname_ptr(compiler, reg),
-      orc_x86_get_regname(destreg));
-
-  orc_x86_emit_rex(compiler, size, 0, 0, reg);
-  *compiler->codeptr++ = 0x0f;
-  *compiler->codeptr++ = 0xaf;
-  orc_x86_emit_modrm_memoffset_old (compiler, destreg, offset, reg);
+  orc_sse_emit_sysinsn_load_memoffset (compiler, ORC_X86_imul_rm_r, 0,
+      offset, reg, destreg);
 }
 
 void
@@ -590,28 +490,7 @@ void
 orc_x86_emit_test_imm_memoffset (OrcCompiler *compiler, int size, int value,
     int offset, int reg)
 {
-  if (size == 2) {
-    ORC_ASM_CODE(compiler,"  testw $%d, %d(%%%s)\n", value, offset,
-        orc_x86_get_regname_ptr(compiler, reg));
-    *compiler->codeptr++ = 0x66;
-  } else if (size == 4) {
-    ORC_ASM_CODE(compiler,"  testl $%d, %d(%%%s)\n", value, offset,
-        orc_x86_get_regname_ptr(compiler, reg));
-  } else {
-    ORC_ASM_CODE(compiler,"  test $%d, %d(%%%s)\n", value, offset,
-        orc_x86_get_regname_ptr(compiler, reg));
-  }
-
-  orc_x86_emit_rex(compiler, size, 0, 0, reg);
-
-  *compiler->codeptr++ = 0xf7;
-  orc_x86_emit_modrm_memoffset_old (compiler, 0, offset, reg);
-  *compiler->codeptr++ = (value & 0xff);
-  *compiler->codeptr++ = ((value>>8) & 0xff);
-  if (size == 4) {
-    *compiler->codeptr++ = ((value>>16) & 0xff);
-    *compiler->codeptr++ = ((value>>24) & 0xff);
-  }
+  orc_sse_emit_sysinsn_imm_memoffset (compiler, ORC_X86_test_imm, value, offset, reg);
 }
 
 void
@@ -622,11 +501,8 @@ orc_x86_emit_dec_memoffset (OrcCompiler *compiler, int size,
     ORC_ASM_CODE(compiler,"  decw %d(%%%s)\n", offset, orc_x86_get_regname_ptr(compiler, reg));
     *compiler->codeptr++ = 0x66;
   } else if (size == 4) {
-    ORC_ASM_CODE(compiler,"  addl $-1, %d(%%%s)\n", offset, orc_x86_get_regname_ptr(compiler, reg));
-    orc_x86_emit_rex(compiler, size, 0, 0, reg);
-    *compiler->codeptr++ = 0x83;
-    orc_x86_emit_modrm_memoffset_old (compiler, 0, offset, reg);
-    *compiler->codeptr++ = 0xff;
+    orc_sse_emit_sysinsn_imm_memoffset (compiler, ORC_X86_add_imm8_rm,
+        -1, offset, reg);
     return;
   } else {
     ORC_ASM_CODE(compiler,"  dec %d(%%%s)\n", offset, orc_x86_get_regname_ptr(compiler, reg));
@@ -821,8 +697,7 @@ orc_x86_emit_align (OrcCompiler *compiler)
 
   diff = (compiler->code - compiler->codeptr)&((1<<align_shift) - 1);
   while (diff) {
-    ORC_ASM_CODE(compiler,"  nop\n");
-    *compiler->codeptr++ = 0x90;
+    orc_sse_emit_sysinsn_none (compiler, ORC_X86_nop);
     diff--;
   }
 }

diff --git a/orc/orcx86insn.c b/orc/orcx86insn.c
index ed6d68a..759c526 100644 (file)
--- a/orc/orcx86insn.c
+++ b/orc/orcx86insn.c
@@ -219,9 +219,25 @@ static const OrcSysOpcode orc_x86_opcodes[] = {
   { "retq", ORC_X86_INSN_TYPE_NONE, 0, 0xc3 },
   { "emms", ORC_X86_INSN_TYPE_NONE, 0, 0x0f77 },
   { "rdtsc", ORC_X86_INSN_TYPE_NONE, 0, 0x0f31 },
+  { "nop", ORC_X86_INSN_TYPE_NONE, 0, 0x90 },
   { "rep movsb", ORC_X86_INSN_TYPE_NONE, 0, 0xf3a4 },
   { "rep movsw", ORC_X86_INSN_TYPE_NONE, 0, 0x66f3a5 },
   { "rep movsl", ORC_X86_INSN_TYPE_NONE, 0, 0xf3a5 },
+  { "push", ORC_X86_INSN_TYPE_STACK, 0, 0x50 },
+  { "pop", ORC_X86_INSN_TYPE_STACK, 0, 0x58 },
+  { "movzx", ORC_X86_INSN_TYPE_rm_r, 0, 0x0fb6 },
+  { "movw", ORC_X86_INSN_TYPE_rm_r, 0, 0x668b },
+  { "movl", ORC_X86_INSN_TYPE_rm_r, 0, 0x8b },
+  { "mov", ORC_X86_INSN_TYPE_rm_r, 0, 0x8b },
+  { "mov", ORC_X86_INSN_TYPE_mov_imm32, 0, 0xb8 },
+  { "movl", ORC_X86_INSN_TYPE_r_rm, 0, 0x89 },
+  { "mov", ORC_X86_INSN_TYPE_r_rm, 0, 0x89 },
+  { "test", ORC_X86_INSN_TYPE_rm_r, 0, 0x85 },
+  { "testl", ORC_X86_INSN_TYPE_imm32_rm, 0, 0xf7, 0 },
+  { "leal", ORC_X86_INSN_TYPE_rm_r, 0, 0x8d },
+  { "leaq", ORC_X86_INSN_TYPE_rm_r, 0, 0x8d },
+  { "imul", ORC_X86_INSN_TYPE_rm_r, 0, 0x0faf },
+  { "imul", ORC_X86_INSN_TYPE_MEM, 0, 0xf7, 5 },
 
 };
 
@@ -292,13 +308,19 @@ orc_sse_emit_sysinsn (OrcCompiler *p, int index, int imm, int src, int dest)
           orc_x86_get_regname(src),
           orc_x86_get_regname(dest));
       break;
+    case ORC_X86_INSN_TYPE_STACK:
+      ORC_ASM_CODE(p,"  %s %%%s\n", opcode->name,
+          orc_x86_get_regname(dest));
+      break;
     case ORC_X86_INSN_TYPE_MEM:
     default:
       ORC_ASSERT(0);
       break;
   }
 
-  output_opcode (p, opcode, 4, src, dest);
+  if (opcode->type != ORC_X86_INSN_TYPE_STACK) {
+    output_opcode (p, opcode, 4, src, dest);
+  }
 
   switch (opcode->type) {
     case ORC_X86_INSN_TYPE_rm_r:
@@ -323,6 +345,9 @@ orc_sse_emit_sysinsn (OrcCompiler *p, int index, int imm, int src, int dest)
       orc_x86_emit_modrm_reg (p, src, dest);
       *p->codeptr++ = opcode->code2;
       break;
+    case ORC_X86_INSN_TYPE_STACK:
+      *p->codeptr++ = opcode->code + (dest&0x7);
+      break;
     case ORC_X86_INSN_TYPE_MEM:
     default:
       ORC_ASSERT(0);
@@ -360,6 +385,11 @@ orc_sse_emit_sysinsn_load_memoffset (OrcCompiler *p, int index, int imm, int off
           offset,
           orc_x86_get_regname_ptr(p, src));
       break;
+    case ORC_X86_INSN_TYPE_rm_r:
+      ORC_ASM_CODE(p,"  %s %d(%%%s), %%%s\n", opcode->name,
+          offset, orc_x86_get_regname_ptr(p, src),
+          orc_x86_get_regname(src));
+      break;
     default:
       ORC_ASSERT(0);
       break;
@@ -370,6 +400,7 @@ orc_sse_emit_sysinsn_load_memoffset (OrcCompiler *p, int index, int imm, int off
   switch (opcode->type) {
     case ORC_X86_INSN_TYPE_SD:
     case ORC_X86_INSN_TYPE_ED:
+    case ORC_X86_INSN_TYPE_rm_r:
       orc_x86_emit_modrm_memoffset (p, offset, src, dest);
       break;
     case ORC_X86_INSN_TYPE_SDI:
@@ -481,6 +512,13 @@ orc_sse_emit_sysinsn_load_memindex (OrcCompiler *p, int index, int imm,
           orc_x86_get_regname_ptr(p, src_index), 1<<shift,
           orc_x86_get_regname_sse(dest));
       break;
+    case ORC_X86_INSN_TYPE_rm_r:
+      ORC_ASM_CODE(p,"  %s %d(%%%s,%%%s,%d), %%%s\n", opcode->name,
+          offset,
+          orc_x86_get_regname_ptr(p, src),
+          orc_x86_get_regname_ptr(p, src_index), 1<<shift,
+          orc_x86_get_regname(dest));
+      break;
     default:
       ORC_ASSERT(0);
       break;
@@ -492,6 +530,7 @@ orc_sse_emit_sysinsn_load_memindex (OrcCompiler *p, int index, int imm,
     case ORC_X86_INSN_TYPE_SD:
     case ORC_X86_INSN_TYPE_ED:
     case ORC_X86_INSN_TYPE_ED_REV:
+    case ORC_X86_INSN_TYPE_rm_r:
       orc_x86_emit_modrm_memindex2 (p, offset, src, src_index, shift, dest);
       break;
     case ORC_X86_INSN_TYPE_SDI:
@@ -524,6 +563,7 @@ orc_sse_emit_sysinsn_imm_reg (OrcCompiler *p, int index, int imm, int dest)
   switch (opcode->type) {
     case ORC_X86_INSN_TYPE_imm8_rm:
     case ORC_X86_INSN_TYPE_imm32_rm:
+    case ORC_X86_INSN_TYPE_mov_imm32:
       if (size == 4) {
         ORC_ASM_CODE(p,"  %s $%d, %%%s\n", opcode->name,
             imm,
@@ -539,7 +579,9 @@ orc_sse_emit_sysinsn_imm_reg (OrcCompiler *p, int index, int imm, int dest)
       break;
   }
 
-  output_opcode (p, opcode, size, 0, dest);
+  if (opcode->type != ORC_X86_INSN_TYPE_mov_imm32) {
+    output_opcode (p, opcode, size, 0, dest);
+  }
 
   switch (opcode->type) {
     case ORC_X86_INSN_TYPE_imm8_rm:
@@ -553,6 +595,13 @@ orc_sse_emit_sysinsn_imm_reg (OrcCompiler *p, int index, int imm, int dest)
       *p->codeptr++ = (imm>>16)&0xff;
       *p->codeptr++ = (imm>>24)&0xff;
       break;
+    case ORC_X86_INSN_TYPE_mov_imm32:
+      *p->codeptr++ = opcode->code + (dest&7);
+      *p->codeptr++ = imm&0xff;
+      *p->codeptr++ = (imm>>8)&0xff;
+      *p->codeptr++ = (imm>>16)&0xff;
+      *p->codeptr++ = (imm>>24)&0xff;
+      break;
     default:
       ORC_ASSERT(0);
       break;

diff --git a/orc/orcx86insn.h b/orc/orcx86insn.h
index 8a2815d..5a15993 100644 (file)
--- a/orc/orcx86insn.h
+++ b/orc/orcx86insn.h
@@ -17,7 +17,9 @@ enum {
   ORC_X86_INSN_TYPE_rm_r,
   ORC_X86_INSN_TYPE_r_rm,
   ORC_X86_INSN_TYPE_LABEL,
-  ORC_X86_INSN_TYPE_NONE
+  ORC_X86_INSN_TYPE_NONE,
+  ORC_X86_INSN_TYPE_STACK,
+  ORC_X86_INSN_TYPE_mov_imm32,
 };
 
 enum {
@@ -231,9 +233,25 @@ enum {
   ORC_X86_retq,
   ORC_X86_emms,
   ORC_X86_rdtsc,
+  ORC_X86_nop,
   ORC_X86_rep_movsb,
   ORC_X86_rep_movsw,
   ORC_X86_rep_movsl,
+  ORC_X86_push,
+  ORC_X86_pop,
+  ORC_X86_movzx_rm_r,
+  ORC_X86_movw_rm_r,
+  ORC_X86_movl_rm_r,
+  ORC_X86_mov_rm_r,
+  ORC_X86_mov_imm32_r,
+  ORC_X86_movl_r_rm,
+  ORC_X86_mov_r_rm,
+  ORC_X86_test,
+  ORC_X86_test_imm,
+  ORC_X86_leal,
+  ORC_X86_leaq,
+  ORC_X86_imul_rm_r,
+  ORC_X86_imul_rm,
 
 };