random hacking

diff --git a/orc/orcprogram-c.c b/orc/orcprogram-c.c
index a2bdd91..d7270d9 100644 (file)
--- a/orc/orcprogram-c.c
+++ b/orc/orcprogram-c.c
@@ -10,6 +10,12 @@
 void orc_c_init (void);
 
 void
+orc_program_c_init (OrcProgram *program)
+{
+
+}
+
+void
 orc_program_assemble_c (OrcProgram *program)
 {
   int i;
@@ -18,27 +24,27 @@ orc_program_assemble_c (OrcProgram *program)
   OrcOpcode *opcode;
   OrcRule *rule;
 
-  printf("\n");
-  printf("void\n");
-  printf("test (OrcExecutor *ex)\n");
-  printf("{\n");
-  printf("  int i;\n");
+  orc_program_append_code(program,"\n");
+  orc_program_append_code(program,"void\n");
+  orc_program_append_code(program,"test (OrcExecutor *ex)\n");
+  orc_program_append_code(program,"{\n");
+  orc_program_append_code(program,"  int i;\n");
 
   for(i=0;i<program->n_vars;i++){
     OrcVariable *var = program->vars + i;
     switch (var->vartype) {
       case ORC_VAR_TYPE_CONST:
-        printf("  int16_t var%d = %d;\n", i, var->s16);
+        orc_program_append_code(program,"  int16_t var%d = %d;\n", i, var->s16);
         break;
       case ORC_VAR_TYPE_TEMP:
-        printf("  int16_t var%d;\n", i);
+        orc_program_append_code(program,"  int16_t var%d;\n", i);
         break;
       case ORC_VAR_TYPE_SRC:
       case ORC_VAR_TYPE_DEST:
-        printf("  int16_t *var%d = ex->var%d;\n", i, i);
+        orc_program_append_code(program,"  int16_t *var%d = ex->var%d;\n", i, i);
         break;
       case ORC_VAR_TYPE_PARAM:
-        printf("  int16_t var%d = ex->var%d;\n", i, i);
+        orc_program_append_code(program,"  int16_t var%d = ex->var%d;\n", i, i);
         break;
       default:
         break;
@@ -46,56 +52,26 @@ orc_program_assemble_c (OrcProgram *program)
 
   }
 
-  printf("\n");
-  printf("  for (i = 0; i < n; i++) {\n");
+  orc_program_append_code(program,"\n");
+  orc_program_append_code(program,"  for (i = 0; i < n; i++) {\n");
 
   for(j=0;j<program->n_insns;j++){
     insn = program->insns + j;
     opcode = insn->opcode;
 
-    printf("    // %d: %s\n", j, insn->opcode->name);
-
-#if 0
-    for(k=opcode->n_dest;k<opcode->n_src + opcode->n_dest;k++){
-      switch (args[k]->vartype) {
-        case ORC_VAR_TYPE_SRC:
-          x86_emit_load_src (program, args[k]);
-          break;
-        case ORC_VAR_TYPE_CONST:
-          break;
-        case ORC_VAR_TYPE_TEMP:
-          break;
-        default:
-          break;
-      }
-    }
-#endif
+    orc_program_append_code(program,"    /* %d: %s */\n", j, insn->opcode->name);
 
     rule = insn->rule;
     if (rule) {
       rule->emit (program, rule->emit_user, insn);
     } else {
-      printf("No rule for: %s\n", opcode->name);
-    }
-
-#if 0
-    for(k=0;k<opcode->n_dest;k++){
-      switch (args[k]->vartype) {
-        case ORC_VAR_TYPE_DEST:
-          x86_emit_store_dest (program, args[k]);
-          break;
-        case ORC_VAR_TYPE_TEMP:
-          break;
-        default:
-          break;
-      }
+      orc_program_append_code(program,"#error No rule for: %s\n", opcode->name);
     }
-#endif
   }
 
-  printf("  }\n");
-  printf("}\n");
-  printf("\n");
+  orc_program_append_code(program,"  }\n");
+  orc_program_append_code(program,"}\n");
+  orc_program_append_code(program,"\n");
 }
 
 
@@ -130,7 +106,7 @@ c_rule_add_s16 (OrcProgram *p, void *user, OrcInstruction *insn)
   c_get_name (src1, p, insn->args[1]);
   c_get_name (src2, p, insn->args[2]);
 
-  printf ("    %s = %s + %s;\n", dest, src1, src2);
+  orc_program_append_code(p,"    %s = %s + %s;\n", dest, src1, src2);
 }
 
 static void
@@ -142,7 +118,7 @@ c_rule_sub_s16 (OrcProgram *p, void *user, OrcInstruction *insn)
   c_get_name (src1, p, insn->args[1]);
   c_get_name (src2, p, insn->args[2]);
 
-  printf ("    %s = %s - %s;\n", dest, src1, src2);
+  orc_program_append_code(p,"    %s = %s - %s;\n", dest, src1, src2);
 }
 
 static void
@@ -154,7 +130,7 @@ c_rule_mul_s16 (OrcProgram *p, void *user, OrcInstruction *insn)
   c_get_name (src1, p, insn->args[1]);
   c_get_name (src2, p, insn->args[2]);
 
-  printf ("    %s = %s * %s;\n", dest, src1, src2);
+  orc_program_append_code(p,"    %s = %s * %s;\n", dest, src1, src2);
 }
 
 static void
@@ -166,7 +142,7 @@ c_rule_lshift_s16 (OrcProgram *p, void *user, OrcInstruction *insn)
   c_get_name (src1, p, insn->args[1]);
   c_get_name (src2, p, insn->args[2]);
 
-  printf ("    %s = %s << %s;\n", dest, src1, src2);
+  orc_program_append_code(p,"    %s = %s << %s;\n", dest, src1, src2);
 }
 
 static void
@@ -178,22 +154,17 @@ c_rule_rshift_s16 (OrcProgram *p, void *user, OrcInstruction *insn)
   c_get_name (src1, p, insn->args[1]);
   c_get_name (src2, p, insn->args[2]);
 
-  printf ("    %s = %s >> %s;\n", dest, src1, src2);
+  orc_program_append_code(p,"    %s = %s >> %s;\n", dest, src1, src2);
 }
 
 
 void
 orc_c_init (void)
 {
-  orc_rule_register ("add_s16", ORC_RULE_C, c_rule_add_s16, NULL,
-      ORC_RULE_REG_REG);
-  orc_rule_register ("sub_s16", ORC_RULE_C, c_rule_sub_s16, NULL,
-      ORC_RULE_REG_REG);
-  orc_rule_register ("mul_s16", ORC_RULE_C, c_rule_mul_s16, NULL,
-      ORC_RULE_REG_REG);
-  orc_rule_register ("lshift_s16", ORC_RULE_C, c_rule_lshift_s16, NULL,
-      ORC_RULE_REG_REG);
-  orc_rule_register ("rshift_s16", ORC_RULE_C, c_rule_rshift_s16, NULL,
-      ORC_RULE_REG_REG);
+  orc_rule_register ("add_s16", ORC_RULE_C, c_rule_add_s16, NULL);
+  orc_rule_register ("sub_s16", ORC_RULE_C, c_rule_sub_s16, NULL);
+  orc_rule_register ("mul_s16", ORC_RULE_C, c_rule_mul_s16, NULL);
+  orc_rule_register ("lshift_s16", ORC_RULE_C, c_rule_lshift_s16, NULL);
+  orc_rule_register ("rshift_s16", ORC_RULE_C, c_rule_rshift_s16, NULL);
 }
 

diff --git a/orc/orcprogram-powerpc.c b/orc/orcprogram-powerpc.c
index bfb3a28..4b9c7b3 100644 (file)
--- a/orc/orcprogram-powerpc.c
+++ b/orc/orcprogram-powerpc.c
@@ -677,16 +677,11 @@ powerpc_rule_rshift_s16 (OrcProgram *p, void *user, OrcInstruction *insn)
 void
 orc_program_powerpc_register_rules (void)
 {
-  orc_rule_register ("add_s16", ORC_RULE_ALTIVEC_1, powerpc_rule_add_s16, NULL,
-      ORC_RULE_REG_REG);
-  orc_rule_register ("sub_s16", ORC_RULE_ALTIVEC_1, powerpc_rule_sub_s16, NULL,
-      ORC_RULE_REG_REG);
-  orc_rule_register ("mul_s16", ORC_RULE_ALTIVEC_1, powerpc_rule_mul_s16, NULL,
-      ORC_RULE_REG_REG);
-  orc_rule_register ("lshift_s16", ORC_RULE_ALTIVEC_1, powerpc_rule_lshift_s16, NULL,
-      ORC_RULE_REG_REG);
-  orc_rule_register ("rshift_s16", ORC_RULE_ALTIVEC_1, powerpc_rule_rshift_s16, NULL,
-      ORC_RULE_REG_REG);
+  orc_rule_register ("add_s16", ORC_RULE_ALTIVEC_1, powerpc_rule_add_s16, NULL);
+  orc_rule_register ("sub_s16", ORC_RULE_ALTIVEC_1, powerpc_rule_sub_s16, NULL);
+  orc_rule_register ("mul_s16", ORC_RULE_ALTIVEC_1, powerpc_rule_mul_s16, NULL);
+  orc_rule_register ("lshift_s16", ORC_RULE_ALTIVEC_1, powerpc_rule_lshift_s16, NULL);
+  orc_rule_register ("rshift_s16", ORC_RULE_ALTIVEC_1, powerpc_rule_rshift_s16, NULL);
 }
 
 /* code generation */

diff --git a/orc/orcprogram-x86.c b/orc/orcprogram-x86.c
index 9f87195..8b75522 100644 (file)
--- a/orc/orcprogram-x86.c
+++ b/orc/orcprogram-x86.c
@@ -75,8 +75,8 @@ void orc_program_dump (OrcProgram *program);
 void
 x86_emit_prologue (OrcProgram *program)
 {
-  printf(".global test\n");
-  printf("test:\n");
+  orc_program_append_code(program,".global test\n");
+  orc_program_append_code(program,"test:\n");
   if (x86_64) {
 
   } else {
@@ -137,7 +137,6 @@ x86_do_fixups (OrcProgram *program)
 void
 orc_x86_init (void)
 {
-  orc_program_x86_register_rules ();
   orc_program_mmx_register_rules ();
   orc_program_sse_register_rules ();
 }
@@ -185,7 +184,13 @@ orc_program_x86_init (OrcProgram *program)
     program->used_regs[i] = 0;
   }
 
-  program->data_register_class = 2;
+  if (program->target == ORC_TARGET_MMX) {
+    program->data_register_class = 2;
+    program->rule_set = ORC_RULE_MMX_1;
+  } else {
+    program->data_register_class = 3;
+    program->rule_set = ORC_RULE_SSE_1;
+  }
 }
 
 void
@@ -314,6 +319,12 @@ orc_program_assemble_x86 (OrcProgram *program)
 {
   x86_emit_prologue (program);
 
+  if (program->target == ORC_TARGET_SSE) {
+    program->loop_shift = 3;
+  } else {
+    program->loop_shift = 2;
+  }
+
   x86_emit_mov_memoffset_reg (program, 4, (int)ORC_STRUCT_OFFSET(OrcExecutor,n),
       x86_exec_ptr, X86_ECX);
   x86_emit_sar_imm_reg (program, 4, program->loop_shift, X86_ECX);
@@ -332,17 +343,21 @@ orc_program_assemble_x86 (OrcProgram *program)
       (int)ORC_STRUCT_OFFSET(OrcExecutor,counter1), x86_exec_ptr);
   x86_emit_je (program, 1);
 
-  program->rule_set = ORC_RULE_MMX_1;
-  program->n_per_loop = 1;
-  program->loop_shift = 0;
+  if (program->target == ORC_TARGET_SSE) {
+    program->rule_set = ORC_RULE_SSE_1;
+    program->n_per_loop = 1;
+    program->loop_shift = 0;
+  } else {
+    program->rule_set = ORC_RULE_MMX_1;
+    program->n_per_loop = 1;
+    program->loop_shift = 0;
+  }
+
   x86_emit_label (program, 0);
   x86_emit_loop (program);
   x86_emit_dec_memoffset (program, 4,
       (int)ORC_STRUCT_OFFSET(OrcExecutor,counter1),
       x86_exec_ptr);
-  x86_emit_cmp_imm_memoffset (program, 4, 0,
-      (int)ORC_STRUCT_OFFSET(OrcExecutor,counter1),
-      x86_exec_ptr);
   x86_emit_jne (program, 0);
   x86_emit_label (program, 1);
 
@@ -350,9 +365,16 @@ orc_program_assemble_x86 (OrcProgram *program)
       (int)ORC_STRUCT_OFFSET(OrcExecutor,counter2), x86_exec_ptr);
   x86_emit_je (program, 3);
 
-  program->rule_set = ORC_RULE_MMX_4;
-  program->n_per_loop = 4;
-  program->loop_shift = 2;
+  if (program->target == ORC_TARGET_SSE) {
+    program->rule_set = ORC_RULE_SSE_8;
+    program->n_per_loop = 8;
+    program->loop_shift = 3;
+  } else {
+    program->rule_set = ORC_RULE_MMX_4;
+    program->n_per_loop = 4;
+    program->loop_shift = 2;
+  }
+
   x86_emit_label (program, 2);
   x86_emit_loop (program);
   x86_emit_dec_memoffset (program, 4,
@@ -380,18 +402,18 @@ x86_emit_loop (OrcProgram *program)
     insn = program->insns + j;
     opcode = insn->opcode;
 
-    printf("# %d: %s", j, insn->opcode->name);
+    orc_program_append_code(program,"# %d: %s", j, insn->opcode->name);
 
     /* set up args */
     for(k=0;k<opcode->n_src + opcode->n_dest;k++){
       args[k] = program->vars + insn->args[k];
-      printf(" %d", args[k]->alloc);
+      orc_program_append_code(program," %d", args[k]->alloc);
       if (args[k]->is_chained) {
-        printf(" (chained)");
+        orc_program_append_code(program," (chained)");
       }
     }
-    printf(" rule_flag=%d", insn->rule_flag);
-    printf("\n");
+    orc_program_append_code(program," rule_flag=%d", insn->rule_flag);
+    orc_program_append_code(program,"\n");
 
     for(k=opcode->n_dest;k<opcode->n_src + opcode->n_dest;k++){
       switch (args[k]->vartype) {
@@ -409,12 +431,12 @@ x86_emit_loop (OrcProgram *program)
 
     rule = insn->rule;
     if (rule) {
-      if (!(rule->flags & ORC_RULE_3REG) && args[0]->alloc != args[1]->alloc) {
+      if (args[0]->alloc != args[1]->alloc) {
         x86_emit_mov_reg_reg (program, 2, args[1]->alloc, args[0]->alloc);
       }
       rule->emit (program, rule->emit_user, insn);
     } else {
-      printf("No rule for: %s\n", opcode->name);
+      orc_program_append_code(program,"No rule for: %s\n", opcode->name);
     }
 
     for(k=0;k<opcode->n_dest;k++){

diff --git a/orc/orcprogram.c b/orc/orcprogram.c
index 9a1b9c9..074d4e0 100644 (file)
--- a/orc/orcprogram.c
+++ b/orc/orcprogram.c
@@ -4,6 +4,7 @@
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
+#include <stdarg.h>
 
 #include <orc/orcprogram.h>
 
@@ -21,6 +22,8 @@ orc_program_new (void)
   p = malloc(sizeof(OrcProgram));
   memset (p, 0, sizeof(OrcProgram));
 
+  p->target = ORC_TARGET_C;
+
   return p;
 }
 
@@ -214,36 +217,60 @@ orc_program_allocate_register (OrcProgram *program, int data_reg)
 void
 orc_program_compile (OrcProgram *program)
 {
-#if defined(HAVE_POWERPC)
-  orc_program_powerpc_init (program);
-#elif defined(HAVE_I386)
-  orc_program_x86_init (program);
-#elif defined(HAVE_AMD64)
-  orc_program_x86_init (program);
-#else
-#error FIXME
-#endif
+  int i;
+
+  for(i=0;i<32;i++) {
+    program->valid_regs[i] = 1;
+  }
+
+  switch (program->target) {
+    case ORC_TARGET_C:
+      orc_program_c_init (program);
+      break;
+    case ORC_TARGET_ALTIVEC:
+      orc_program_powerpc_init (program);
+      break;
+    case ORC_TARGET_SSE:
+      orc_program_x86_init (program);
+      break;
+    case ORC_TARGET_MMX:
+      orc_program_x86_init (program);
+      break;
+    default:
+      break;
+  }
 
   orc_program_assign_rules (program);
   orc_program_rewrite_vars (program);
 
-  orc_program_global_reg_alloc (program);
+  if (program->target != ORC_TARGET_C) {
+    orc_program_global_reg_alloc (program);
 
-  orc_program_do_regs (program);
+    orc_program_do_regs (program);
+  }
 
   orc_program_rewrite_vars2 (program);
 
-  orc_program_allocate_codemem (program);
-#if defined(HAVE_POWERPC)
-  orc_program_assemble_powerpc (program);
-#elif defined(HAVE_I386)
-  orc_program_assemble_x86 (program);
-#elif defined(HAVE_AMD64)
-  orc_program_assemble_x86 (program);
-#else
-#error FIXME
-#endif
-  //orc_program_assemble_c (program);
+  if (program->target != ORC_TARGET_C) {
+    orc_program_allocate_codemem (program);
+  }
+
+  switch (program->target) {
+    case ORC_TARGET_C:
+      orc_program_assemble_c (program);
+      break;
+    case ORC_TARGET_ALTIVEC:
+      orc_program_assemble_powerpc (program);
+      break;
+    case ORC_TARGET_MMX:
+      orc_program_assemble_x86 (program);
+      break;
+    case ORC_TARGET_SSE:
+      orc_program_assemble_x86 (program);
+      break;
+    default:
+      break;
+  }
 
   orc_program_dump_code (program);
 }
@@ -255,17 +282,8 @@ orc_program_assign_rules (OrcProgram *program)
 
   for(i=0;i<program->n_insns;i++) {
     OrcInstruction *insn = program->insns + i;
-    unsigned int flags;
 
     insn->rule = insn->opcode->rules + program->rule_set;
-
-    flags = insn->rule->flags;
-    if (flags & ORC_RULE_REG_IMM &&
-        program->vars[insn->args[2]].vartype == ORC_VAR_TYPE_CONST) {
-      program->insns[i].rule_flag = ORC_RULE_REG_IMM;
-    } else {
-      program->insns[i].rule_flag = ORC_RULE_REG_REG;
-    }
   }
 }
 
@@ -409,7 +427,7 @@ orc_program_rewrite_vars2 (OrcProgram *program)
      *  - rule must handle it
      *  - src1 must be last_use
      */
-    if (1 || program->insns[j].rule->flags & ORC_RULE_REG_REG) {
+    if (1) {
       int src1 = program->insns[j].args[1];
       int dest = program->insns[j].args[0];
       if (program->vars[src1].last_use == j) {
@@ -423,7 +441,7 @@ orc_program_rewrite_vars2 (OrcProgram *program)
     }
 #endif
 
-    if (program->insns[j].rule_flag == ORC_RULE_REG_IMM) {
+    if (0) {
       /* immediate operand, don't load */
       int src2 = program->insns[j].args[2];
       program->vars[src2].alloc = 1;
@@ -514,3 +532,13 @@ orc_variable_get_size (OrcVariable *var)
   return 2;
 }
 
+void
+orc_program_append_code (OrcProgram *p, const char *fmt, ...)
+{
+  va_list varargs;
+
+  va_start (varargs, fmt);
+  vprintf(fmt, varargs);
+  va_end (varargs);
+}
+

diff --git a/orc/orcprogram.h b/orc/orcprogram.h
index 3281f0e..165bf32 100644 (file)
--- a/orc/orcprogram.h
+++ b/orc/orcprogram.h
@@ -59,6 +59,13 @@ enum {
   ORC_RULE_ALTIVEC_1
 };
 
+enum {
+  ORC_TARGET_C = 0,
+  ORC_TARGET_ALTIVEC = 1,
+  ORC_TARGET_MMX = 2,
+  ORC_TARGET_SSE = 3
+};
+
 struct _OrcType {
   char *name;
   int size;
@@ -94,7 +101,6 @@ struct _OrcVariable {
 };
 
 struct _OrcRule {
-  unsigned int flags;
   OrcRuleEmitFunc emit;
   void *emit_user;
 };
@@ -178,6 +184,7 @@ struct _OrcProgram {
   int used_regs[ORC_N_REGS];
   int alloc_regs[ORC_N_REGS];
 
+  int target;
   int loop_shift;
   int n_per_loop;
 };
@@ -196,16 +203,6 @@ struct _OrcExecutor {
 
 };
 
-enum {
-  ORC_RULE_3REG = (1<<0),
-  ORC_RULE_REG_REG = (1<<1),
-  ORC_RULE_MEM_REG = (1<<2),
-  ORC_RULE_REG_MEM = (1<<3),
-  ORC_RULE_REG_IMM = (1<<4),
-  ORC_RULE_MEM_IMM = (1<<5),
-  ORC_RULE_REG_CL = (1<<6)
-};
-
 
 void orc_init (void);
 
@@ -223,7 +220,10 @@ void orc_x86_init (void);
 void orc_powerpc_init (void);
 void orc_c_init (void);
 
+void orc_program_set_target (OrcProgram *p, const char *target);
+
 void orc_program_compile (OrcProgram *p);
+void orc_program_c_init (OrcProgram *p);
 void orc_program_x86_init (OrcProgram *p);
 void orc_program_powerpc_init (OrcProgram *p);
 void orc_program_assemble_x86 (OrcProgram *p);
@@ -257,7 +257,7 @@ void orc_executor_emulate (OrcExecutor *ex);
 void orc_executor_run (OrcExecutor *ex);
 
 void orc_rule_register (const char *opcode_name, unsigned int mode,
-    OrcRuleEmitFunc emit, void *emit_user, unsigned int flags);
+    OrcRuleEmitFunc emit, void *emit_user);
 
 int orc_program_allocate_register (OrcProgram *program, int is_data);
 int orc_program_x86_allocate_register (OrcProgram *program, int is_data);
@@ -268,6 +268,8 @@ void orc_program_allocate_codemem (OrcProgram *program);
 void orc_program_dump_code (OrcProgram *program);
 
 int orc_variable_get_size (OrcVariable *var);
+
+void orc_program_append_code (OrcProgram *p, const char *fmt, ...);
  
 #endif
 

diff --git a/orc/orcrule.c b/orc/orcrule.c
index 1919e76..70e06a4 100644 (file)
--- a/orc/orcrule.c
+++ b/orc/orcrule.c
@@ -10,7 +10,7 @@
 
 void
 orc_rule_register (const char *opcode_name, unsigned int mode,
-    OrcRuleEmitFunc emit, void *emit_user, unsigned int flags)
+    OrcRuleEmitFunc emit, void *emit_user)
 {
   OrcOpcode *opcode;
 
@@ -18,6 +18,5 @@ orc_rule_register (const char *opcode_name, unsigned int mode,
 
   opcode->rules[mode].emit = emit;
   opcode->rules[mode].emit_user = emit_user;
-  opcode->rules[mode].flags = flags;
 }
 

diff --git a/orc/orcrules-mmx.c b/orc/orcrules-mmx.c
index 1998483..8a86acd 100644 (file)
--- a/orc/orcrules-mmx.c
+++ b/orc/orcrules-mmx.c
@@ -148,20 +148,14 @@ orc_program_mmx_register_rules (void)
 {
   int i;
 
-  orc_rule_register ("_loadi_s16", ORC_RULE_MMX_4, mmx_rule_loadi_s16, NULL,
-      ORC_RULE_REG_IMM);
+  orc_rule_register ("_loadi_s16", ORC_RULE_MMX_4, mmx_rule_loadi_s16, NULL);
 
   for(i=ORC_RULE_MMX_1; i <= ORC_RULE_MMX_4; i++) {
-    orc_rule_register ("add_s16", i, mmx_rule_add_s16, NULL,
-        ORC_RULE_REG_REG);
-    orc_rule_register ("sub_s16", i, mmx_rule_sub_s16, NULL,
-        ORC_RULE_REG_REG);
-    orc_rule_register ("mul_s16", i, mmx_rule_mul_s16, NULL,
-        ORC_RULE_REG_REG);
-    orc_rule_register ("lshift_s16", i, mmx_rule_lshift_s16, NULL,
-        ORC_RULE_REG_REG);
-    orc_rule_register ("rshift_s16", i, mmx_rule_rshift_s16, NULL,
-        ORC_RULE_REG_REG);
+    orc_rule_register ("add_s16", i, mmx_rule_add_s16, NULL);
+    orc_rule_register ("sub_s16", i, mmx_rule_sub_s16, NULL);
+    orc_rule_register ("mul_s16", i, mmx_rule_mul_s16, NULL);
+    orc_rule_register ("lshift_s16", i, mmx_rule_lshift_s16, NULL);
+    orc_rule_register ("rshift_s16", i, mmx_rule_rshift_s16, NULL);
   }
 }
 

diff --git a/orc/orcrules-sse.c b/orc/orcrules-sse.c
index 9f559e0..f829b6c 100644 (file)
--- a/orc/orcrules-sse.c
+++ b/orc/orcrules-sse.c
@@ -153,20 +153,14 @@ orc_program_sse_register_rules (void)
 {
   int i;
 
-  orc_rule_register ("_loadi_s16", ORC_RULE_SSE_4, sse_rule_loadi_s16, NULL,
-      ORC_RULE_REG_IMM);
+  orc_rule_register ("_loadi_s16", ORC_RULE_SSE_4, sse_rule_loadi_s16, NULL);
 
   for(i=ORC_RULE_SSE_1; i <= ORC_RULE_SSE_8; i++) {
-    orc_rule_register ("add_s16", i, sse_rule_add_s16, NULL,
-        ORC_RULE_REG_REG);
-    orc_rule_register ("sub_s16", i, sse_rule_sub_s16, NULL,
-        ORC_RULE_REG_REG);
-    orc_rule_register ("mul_s16", i, sse_rule_mul_s16, NULL,
-        ORC_RULE_REG_REG);
-    orc_rule_register ("lshift_s16", i, sse_rule_lshift_s16, NULL,
-        ORC_RULE_REG_REG);
-    orc_rule_register ("rshift_s16", i, sse_rule_rshift_s16, NULL,
-        ORC_RULE_REG_REG);
+    orc_rule_register ("add_s16", i, sse_rule_add_s16, NULL);
+    orc_rule_register ("sub_s16", i, sse_rule_sub_s16, NULL);
+    orc_rule_register ("mul_s16", i, sse_rule_mul_s16, NULL);
+    orc_rule_register ("lshift_s16", i, sse_rule_lshift_s16, NULL);
+    orc_rule_register ("rshift_s16", i, sse_rule_rshift_s16, NULL);
   }
 }
 

diff --git a/orc/orcrules-x86.c b/orc/orcrules-x86.c
index 4becb48..e69de29 100644 (file)
--- a/orc/orcrules-x86.c
+++ b/orc/orcrules-x86.c
@@ -1,146 +0,0 @@
-
-#include "config.h"
-
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-
-#include <unistd.h>
-#include <sys/types.h>
-#include <sys/mman.h>
-
-#include <orc/orcprogram.h>
-#include <orc/x86.h>
-
-#define SIZE 65536
-
-/* rules */
-
-static void
-x86_rule_loadi_s16 (OrcProgram *p, void *user, OrcInstruction *insn)
-{
-  x86_emit_mov_imm_reg (p, 2,  p->vars[insn->args[2]].s16,
-      p->vars[insn->args[0]].alloc);
-}
-
-static void
-x86_rule_add_s16 (OrcProgram *p, void *user, OrcInstruction *insn)
-{
-  if (insn->rule_flag == ORC_RULE_REG_IMM) {
-    int value = p->vars[insn->args[2]].s16;
-    printf("  addw $%d, %%%s\n", value,
-        x86_get_regname_16(p->vars[insn->args[0]].alloc));
-
-    if (value >= -128 && value < 128) {
-      *p->codeptr++ = 0x66;
-      *p->codeptr++ = 0x83;
-      x86_emit_modrm_reg (p, p->vars[insn->args[0]].alloc, 0);
-      *p->codeptr++ = value;
-    } else {
-      *p->codeptr++ = 0x66;
-      *p->codeptr++ = 0x81;
-      x86_emit_modrm_reg (p, p->vars[insn->args[0]].alloc, 0);
-      *p->codeptr++ = value & 0xff;
-      *p->codeptr++ = value >> 8;
-    }
-  } else {
-    printf("  addw %%%s, %%%s\n",
-        x86_get_regname_16(p->vars[insn->args[2]].alloc),
-        x86_get_regname_16(p->vars[insn->args[0]].alloc));
-
-    *p->codeptr++ = 0x66;
-    *p->codeptr++ = 0x03;
-    x86_emit_modrm_reg (p, p->vars[insn->args[2]].alloc,
-        p->vars[insn->args[0]].alloc);
-  }
-}
-
-static void
-x86_rule_sub_s16 (OrcProgram *p, void *user, OrcInstruction *insn)
-{
-  printf("  subw %%%s, %%%s\n",
-      x86_get_regname_16(p->vars[insn->args[2]].alloc),
-      x86_get_regname_16(p->vars[insn->args[0]].alloc));
-
-  *p->codeptr++ = 0x66;
-  *p->codeptr++ = 0x2b;
-  x86_emit_modrm_reg (p, p->vars[insn->args[2]].alloc,
-      p->vars[insn->args[0]].alloc);
-}
-
-static void
-x86_rule_mul_s16 (OrcProgram *p, void *user, OrcInstruction *insn)
-{
-  printf("  imulw %%%s, %%%s\n",
-      x86_get_regname_16(p->vars[insn->args[2]].alloc),
-      x86_get_regname_16(p->vars[insn->args[0]].alloc));
-
-  *p->codeptr++ = 0x66;
-  *p->codeptr++ = 0x0f;
-  *p->codeptr++ = 0xaf;
-  x86_emit_modrm_reg (p, p->vars[insn->args[2]].alloc,
-      p->vars[insn->args[0]].alloc);
-}
-
-static void
-x86_rule_lshift_s16 (OrcProgram *p, void *user, OrcInstruction *insn)
-{
-  x86_emit_mov_reg_reg(p, 4, p->vars[insn->args[2]].alloc, X86_ECX);
-
-  printf("  shlw %%cl, %%%s\n",
-      x86_get_regname_16(p->vars[insn->args[0]].alloc));
-
-  *p->codeptr++ = 0x66;
-  *p->codeptr++ = 0xd3;
-  x86_emit_modrm_reg (p, p->vars[insn->args[0]].alloc, 4);
-}
-
-static void
-x86_rule_rshift_s16 (OrcProgram *p, void *user, OrcInstruction *insn)
-{
-  if (insn->rule_flag == ORC_RULE_REG_IMM) {
-    printf("  sarw $%d, %%%s\n",
-        p->vars[insn->args[2]].s16,
-        x86_get_regname_16(p->vars[insn->args[0]].alloc));
-
-    if (p->vars[insn->args[2]].s16 == 1) {
-      *p->codeptr++ = 0x66;
-      *p->codeptr++ = 0xd1;
-      x86_emit_modrm_reg (p, p->vars[insn->args[0]].alloc, 7);
-    } else {
-      *p->codeptr++ = 0x66;
-      *p->codeptr++ = 0xc1;
-      x86_emit_modrm_reg (p, p->vars[insn->args[0]].alloc, 7);
-      *p->codeptr++ = p->vars[insn->args[2]].s16;
-    }
-  } else {
-    x86_emit_mov_reg_reg(p, 4, p->vars[insn->args[2]].alloc, X86_ECX);
-
-    printf("  sarw %%cl, %%%s\n",
-        x86_get_regname_16(p->vars[insn->args[0]].alloc));
-
-    *p->codeptr++ = 0x66;
-    *p->codeptr++ = 0xd3;
-    x86_emit_modrm_reg (p, p->vars[insn->args[0]].alloc, 7);
-  }
-}
-
-
-void
-orc_program_x86_register_rules (void)
-{
-  orc_rule_register ("_loadi_s16", ORC_RULE_SCALAR_1, x86_rule_loadi_s16, NULL,
-      ORC_RULE_REG_IMM);
-
-  orc_rule_register ("add_s16", ORC_RULE_SCALAR_1, x86_rule_add_s16, NULL,
-      ORC_RULE_REG_REG | ORC_RULE_REG_IMM);
-  orc_rule_register ("sub_s16", ORC_RULE_SCALAR_1, x86_rule_sub_s16, NULL,
-      ORC_RULE_REG_REG);
-  orc_rule_register ("mul_s16", ORC_RULE_SCALAR_1, x86_rule_mul_s16, NULL,
-      ORC_RULE_REG_REG);
-  orc_rule_register ("lshift_s16", ORC_RULE_SCALAR_1, x86_rule_lshift_s16, NULL,
-      ORC_RULE_REG_REG);
-  orc_rule_register ("rshift_s16", ORC_RULE_SCALAR_1, x86_rule_rshift_s16, NULL,
-      ORC_RULE_REG_REG | ORC_RULE_REG_IMM);
-}
-