llvm: more updates

Can generate a file that can be compiled with llc

2 files changed, 662 insertions, 147 deletions

diff --git a/orc/orcprogram-llvm.c b/orc/orcprogram-llvm.c
index ea8726a..3768068 100644
--- a/orc/orcprogram-llvm.c
+++ b/orc/orcprogram-llvm.c
@@ -51,18 +51,18 @@ orc_compiler_llvm_get_default_flags (void)
 }
 
 static const char *varnames[] = {
-  "%%d1", "%%d2", "%%d3", "%%d4",
-  "%%s1", "%%s2", "%%s3", "%%s4",
-  "%%s5", "%%s6", "%%s7", "%%s8",
-  "%%a1", "%%a2", "%%a3", "%%d4",
-  "%%c1", "%%c2", "%%c3", "%%c4",
-  "%%c5", "%%c6", "%%c7", "%%c8",
-  "%%p1", "%%p2", "%%p3", "%%p4",
-  "%%p5", "%%p6", "%%p7", "%%p8",
-  "%%t1", "%%t2", "%%t3", "%%t4",
-  "%%t5", "%%t6", "%%t7", "%%t8",
-  "%%t9", "%%t10", "%%t11", "%%t12",
-  "%%t13", "%%t14", "%%t15", "%%t16",
+  "%d1", "%d2", "%d3", "%d4",
+  "%s1", "%s2", "%s3", "%s4",
+  "%s5", "%s6", "%s7", "%s8",
+  "%a1", "%a2", "%a3", "%d4",
+  "%c1", "%c2", "%c3", "%c4",
+  "%c5", "%c6", "%c7", "%c8",
+  "%p1", "%p2", "%p3", "%p4",
+  "%p5", "%p6", "%p7", "%p8",
+  "%t1", "%t2", "%t3", "%t4",
+  "%t5", "%t6", "%t7", "%t8",
+  "%t9", "%t10", "%t11", "%t12",
+  "%t13", "%t14", "%t15", "%t16",
 };
 
 static void
@@ -96,6 +96,96 @@ get_varname_stride (char *s, OrcCompiler *compiler, int var)
 }
 
 void
+output_prototype (OrcCompiler *compiler)
+{
+  OrcVariable *var;
+  OrcProgram *p = compiler->program;
+  int i;
+  int need_comma;
+
+  ORC_ASM_CODE(compiler,"define void @%s (", compiler->program->name);
+  need_comma = FALSE;
+
+  for(i=0;i<4;i++){
+    var = &p->vars[ORC_VAR_D1 + i];
+    if (var->size) {
+      if (need_comma) ORC_ASM_CODE (compiler, ", ");
+      ORC_ASM_CODE (compiler, "<1 x i%d> * noalias %s", var->size*8,
+          varnames[ORC_VAR_D1 + i]);
+      if (p->is_2d) {
+        ORC_ASM_CODE (compiler, ", i32 %s_stride", varnames[ORC_VAR_D1 + i]);
+      }
+      need_comma = TRUE;
+    }
+  }
+  for(i=0;i<4;i++){
+    var = &p->vars[ORC_VAR_A1 + i];
+    if (var->size) {
+      if (need_comma) ORC_ASM_CODE (compiler, ", ");
+      ORC_ASM_CODE (compiler, "<1 x i%d> * noalias %s", var->size*8,
+          varnames[ORC_VAR_A1 + i]);
+      need_comma = TRUE;
+    }
+  }
+  for(i=0;i<8;i++){
+    var = &p->vars[ORC_VAR_S1 + i];
+    if (var->size) {
+      if (need_comma) ORC_ASM_CODE (compiler, ", ");
+      ORC_ASM_CODE (compiler, "<1 x i%d> * noalias %s", var->size*8,
+          varnames[ORC_VAR_S1 + i]);
+      if (p->is_2d) {
+        ORC_ASM_CODE (compiler, ", i32 %s_stride", varnames[ORC_VAR_S1 + i]);
+      }
+      need_comma = TRUE;
+    }
+  }
+
+  for(i=0;i<8;i++){
+    var = &p->vars[ORC_VAR_P1 + i];
+    if (var->size) {
+      if (need_comma) ORC_ASM_CODE (compiler, ", ");
+      switch (var->param_type) {
+        case ORC_PARAM_TYPE_INT:
+          if (var->size == 1)
+            ORC_ASM_CODE (compiler, "i8 %s", varnames[ORC_VAR_P1 + i]);
+          else if (var->size == 2)
+            ORC_ASM_CODE (compiler, "i16 %s", varnames[ORC_VAR_P1 + i]);
+          else if (var->size == 4)
+            ORC_ASM_CODE (compiler, "i32 %s", varnames[ORC_VAR_P1 + i]);
+          else if (var->size == 8)
+            ORC_ASM_CODE (compiler, "i86 %s", varnames[ORC_VAR_P1 + i]);
+          else
+            ORC_ASSERT(0);
+          break;
+        case ORC_PARAM_TYPE_FLOAT:
+          ORC_ASM_CODE (compiler, "float %s", varnames[ORC_VAR_P1 + i]);
+          break;
+        case ORC_PARAM_TYPE_INT64:
+          ORC_ASM_CODE (compiler, "i64 %s", varnames[ORC_VAR_P1 + i]);
+          break;
+        case ORC_PARAM_TYPE_DOUBLE:
+          ORC_ASM_CODE (compiler, "double %s", varnames[ORC_VAR_P1 + i]);
+          break;
+        default:
+          ORC_ASSERT(0);
+      }
+      need_comma = TRUE;
+    }
+  }
+  if (p->constant_n == 0) {
+    if (need_comma) ORC_ASM_CODE (compiler, ", ");
+    ORC_ASM_CODE (compiler, "i32 %%n");
+    need_comma = TRUE;
+  }
+  if (p->is_2d && p->constant_m == 0) {
+    if (need_comma) ORC_ASM_CODE (compiler, ", ");
+    ORC_ASM_CODE (compiler, "i32 %%m");
+  }
+  ORC_ASM_CODE(compiler,") {\n");
+}
+
+
+void
 orc_compiler_llvm_assemble (OrcCompiler *compiler)
 {
   int i;
@@ -106,36 +196,22 @@ orc_compiler_llvm_assemble (OrcCompiler *compiler)
   int prefix = 0;
 
   if (!(compiler->target_flags & ORC_TARGET_C_BARE)) {
-    ORC_ASM_CODE(compiler,"void\n");
-    ORC_ASM_CODE(compiler,"%s (OrcExecutor *ex)\n", compiler->program->name);
-    ORC_ASM_CODE(compiler,"{\n");
+    output_prototype (compiler);
   }
+  ORC_ASM_CODE (compiler, "  %%i = alloca i32, align 4\n");
+  ORC_ASM_CODE (compiler, "  store i32 0, i32* %%i\n\n");
 
-  ORC_ASM_CODE(compiler,"%*s  int i;\n", prefix, "");
   if (compiler->program->is_2d) {
-    ORC_ASM_CODE(compiler,"  int j;\n");
-  }
-  if (compiler->program->constant_n == 0) {
-    if (!(compiler->target_flags & ORC_TARGET_C_NOEXEC) &&
-        !(compiler->target_flags & ORC_TARGET_C_OPCODE)) {
-      ORC_ASM_CODE(compiler,"  int n = ex->n;\n");
-    }
-  } else {
-    ORC_ASM_CODE(compiler,"  int n = %d;\n", compiler->program->constant_n);
-  }
-  if (compiler->program->is_2d) {
-    if (compiler->program->constant_m == 0) {
-      if (!(compiler->target_flags & ORC_TARGET_C_NOEXEC)) {
-        ORC_ASM_CODE(compiler,"  int m = ex->params[ORC_VAR_A1];\n");
-      }
-    } else {
-      ORC_ASM_CODE(compiler,"  int m = %d;\n", compiler->program->constant_m);
-    }
-  }
+    ORC_ASM_CODE (compiler, "  %%j = alloca i32, align 4\n\n");
+
+    ORC_ASM_CODE (compiler, "  store i32 0, i32* %%j\n\n");
+
+    ORC_ASM_CODE (compiler, "  %%index_m = load i32* %%j\n");
+    ORC_ASM_CODE (compiler, "  %%cmp_m = icmp slt i32 %%index_m, %%m\n");
+    ORC_ASM_CODE (compiler, "  br i1 %%cmp_m, label %%loop_m, label %%exit_m\n\n");
+
+    ORC_ASM_CODE (compiler, "loop_m:\n");
 
-  ORC_ASM_CODE(compiler,"\n");
-  if (compiler->program->is_2d) {
-    ORC_ASM_CODE(compiler,"  for (j = 0; j < m; j++) {\n");
     prefix = 2;
 
     for(i=0;i<ORC_N_COMPILER_VARIABLES;i++){
@@ -147,9 +223,8 @@ orc_compiler_llvm_assemble (OrcCompiler *compiler)
             char s1[40], s2[40];
             get_varname(s1, compiler, i);
             get_varname_stride(s2, compiler, i);
-            ORC_ASM_CODE(compiler,
-                "    ptr%d = ORC_PTR_OFFSET(%s, %s * j);\n",
-                i, s1, s2);
+            ORC_ASM_CODE(compiler,"  %%ptr%d = getelementptr <1 x i%d>* %s\n",
+                i, var->size*8, varnames[i]);
           }
           break;
         case ORC_VAR_TYPE_DEST:
@@ -157,9 +232,8 @@ orc_compiler_llvm_assemble (OrcCompiler *compiler)
             char s1[40], s2[40];
             get_varname(s1, compiler, i),
             get_varname_stride(s2, compiler, i),
-            ORC_ASM_CODE(compiler,
-                "    ptr%d = ORC_PTR_OFFSET(%s, %s * j);\n",
-                i, s1, s2);
+            ORC_ASM_CODE(compiler,"  %%ptr%d = getelementptr <1 x i%d>* %s\n",
+                i, var->size*8, varnames[i]);
           }
           break;
         default:
@@ -169,15 +243,15 @@ orc_compiler_llvm_assemble (OrcCompiler *compiler)
   } else {
     for(i=0;i<ORC_N_COMPILER_VARIABLES;i++){
       OrcVariable *var = compiler->vars + i;
-      char s[40],tn[40];
       if (var->name == NULL) continue;
-      get_varname(s, compiler, i);
       switch (var->vartype) {
         case ORC_VAR_TYPE_SRC:
-          ORC_ASM_CODE(compiler,"  ptr%d = (%s *)%s;\n", i, tn, s);
+          ORC_ASM_CODE(compiler,"  %%ptr%d = getelementptr <1 x i%d>* %s\n",
+              i, var->size*8, varnames[i]);
           break;
         case ORC_VAR_TYPE_DEST:
-          ORC_ASM_CODE(compiler,"  ptr%d = (%s *)%s;\n", i, tn, s);
+          ORC_ASM_CODE(compiler,"  %%ptr%d = getelementptr <1 x i%d>* %s\n",
+              i, var->size*8, varnames[i]);
           break;
         default:
           break;
@@ -185,14 +259,13 @@ orc_compiler_llvm_assemble (OrcCompiler *compiler)
     }
   }
 
-  ORC_ASM_CODE(compiler,"\n");
   for(j=0;j<compiler->n_insns;j++){
     insn = compiler->insns + j;
     opcode = insn->opcode;
 
     if (!(insn->flags & ORC_INSN_FLAG_INVARIANT)) continue;
 
-    ORC_ASM_CODE(compiler,"%*s    /* %d: %s */\n", prefix, "",
+    ORC_ASM_CODE(compiler,"%*s    ; %d: %s \n", prefix, "",
         j, insn->opcode->name);
 
     rule = insn->rule;
@@ -206,8 +279,14 @@ orc_compiler_llvm_assemble (OrcCompiler *compiler)
     rule->emit (compiler, rule->emit_user, insn);
   }
 
-  ORC_ASM_CODE(compiler,"\n");
-  ORC_ASM_CODE(compiler,"%*s  for (i = 0; i < n; i++) {\n", prefix, "");
+  ORC_ASM_CODE (compiler, "%*s  br label %%head_n\n\n", prefix, "");
+
+  ORC_ASM_CODE (compiler, "%*shead_n:\n", prefix, "");
+  ORC_ASM_CODE (compiler, "%*s  %%index_n = load i32* %%i\n", prefix, "");
+  ORC_ASM_CODE (compiler, "%*s  %%cmp_n = icmp slt i32 %%index_n, %%n\n", prefix, "");
+  ORC_ASM_CODE (compiler, "%*s  br i1 %%cmp_n, label %%loop_n, label %%exit_n\n\n", prefix, "");
+
+  ORC_ASM_CODE (compiler, "loop_n:\n");
 
   /* Emit instructions */
   for(j=0;j<compiler->n_insns;j++){
@@ -216,7 +295,7 @@ orc_compiler_llvm_assemble (OrcCompiler *compiler)
 
     if (insn->flags & ORC_INSN_FLAG_INVARIANT) continue;
 
-    ORC_ASM_CODE(compiler,"%*s    /* %d: %s */\n", prefix, "",
+    ORC_ASM_CODE(compiler,"%*s    ; %d: %s\n", prefix, "",
         j, insn->opcode->name);
 
     rule = insn->rule;
@@ -229,9 +308,17 @@ orc_compiler_llvm_assemble (OrcCompiler *compiler)
     ORC_ASM_CODE(compiler,"%*s", prefix, "");
     rule->emit (compiler, rule->emit_user, insn);
   }
-  ORC_ASM_CODE(compiler,"%*s  }\n", prefix, "");
+
+  ORC_ASM_CODE (compiler, "%*s  %%next_n = add i32 %%index_n, 1\n", prefix, "");
+  ORC_ASM_CODE (compiler, "%*s  store i32 %%next_n, i32* %%i\n", prefix, "");
+  ORC_ASM_CODE (compiler, "%*s  br label %%head_n\n", prefix, "");
+  ORC_ASM_CODE (compiler, "%*sexit_n:\n", prefix, "");
+
   if (compiler->program->is_2d) {
-    ORC_ASM_CODE(compiler,"  }\n");
+    ORC_ASM_CODE (compiler, "  %%next_m = add i32 %%index_m, 1\n");
+    ORC_ASM_CODE (compiler, "  store i32 %%next_m, i32* %%j\n");
+    ORC_ASM_CODE (compiler, "  br label %%loop_m\n");
+    ORC_ASM_CODE (compiler, "exit_m:\n");
   }
 
   for(i=0;i<ORC_N_COMPILER_VARIABLES;i++){
@@ -272,11 +359,35 @@ orc_compiler_llvm_assemble (OrcCompiler *compiler)
   }
 
   if (!(compiler->target_flags & ORC_TARGET_C_BARE)) {
+    ORC_ASM_CODE(compiler,"  ret void\n");
     ORC_ASM_CODE(compiler,"}\n");
-    ORC_ASM_CODE(compiler,"\n");
   }
 }
 
+static void
+get_vector_constant (char *name, int len, int bits, orc_int64 val)
+{
+  if (len == 1) {
+      sprintf(name, "<i%d %ld>", bits, val);
+  } else if (len == 2) {
+      sprintf(name, "<i%d %ld, i%d %ld>", bits, val, bits, val);
+  } else if (len == 4) {
+      sprintf(name, "<i%d %ld, i%d %ld, i%d %ld, i%d %ld>", bits, val,
+            bits, val, bits, val, bits, val);
+  } else if (len == 8) {
+      sprintf(name, "<i%d %ld, i%d %ld, i%d %ld, i%d %ld, i%d %ld, i%d %ld, i%d %ld, i%d %ld>",
+          bits, val, bits, val, bits, val, bits, val,
+          bits, val, bits, val, bits, val, bits, val);
+  } else if (len == 16) {
+      sprintf(name, "<i%d %ld, i%d %ld, i%d %ld, i%d %ld, i%d %ld, i%d %ld, i%d %ld, i%d %ld, "
+              "i%d %ld, i%d %ld, i%d %ld, i%d %ld, i%d %ld, i%d %ld, i%d %ld, i%d %ld>",
+          bits, val, bits, val, bits, val, bits, val,
+          bits, val, bits, val, bits, val, bits, val,
+          bits, val, bits, val, bits, val, bits, val,
+          bits, val, bits, val, bits, val, bits, val);
+  } else
+    ORC_ASSERT(0);
+}
 
 /* rules */
 
@@ -310,15 +421,15 @@ llvm_get_name_int (char *name, OrcCompiler *p, OrcInstruction *insn, int var, in
       }
     }
   } else if (p->vars[var].vartype == ORC_VAR_TYPE_CONST) {
-    if (p->vars[var].value.i == 0x80000000) {
-      sprintf(name,"0x80000000");
-    } else {
-      if (p->vars[var].value.i == (int)p->vars[var].value.i) {
-        sprintf(name, "%d", (int)p->vars[var].value.i);
-      } else {
-        ORC_ASSERT(0);
-      }
-    }
+    int bits = p->vars[var].size * 8;
+
+    if (insn && (insn->flags & (ORC_INSTRUCTION_FLAG_X2|ORC_INSTRUCTION_FLAG_X4))) {
+      if (insn->flags & ORC_INSTRUCTION_FLAG_X4)
+        get_vector_constant (name, 4, bits, p->vars[var].value.i);
+      else
+        get_vector_constant (name, 2, bits, p->vars[var].value.i);
+    } else
+      get_vector_constant (name, 1, bits, p->vars[var].value.i);
   } else {
     if (insn && (insn->flags & (ORC_INSTRUCTION_FLAG_X2|ORC_INSTRUCTION_FLAG_X4))) {
       int bits = p->vars[var].size * 8;
@@ -468,7 +579,7 @@ llvm_rule_andb (OrcCompiler *p, void *user, OrcInstruction *insn)
 static void
 llvm_rule_andnb (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
-  char dest[40], src1[40], src2[40], t1[40];
+  char dest[40], src1[40], src2[40], t1[40], c[40];
   int sh = get_shift (p, insn);
 
   get_temp (t1, p);
@@ -477,7 +588,9 @@ llvm_rule_andnb (OrcCompiler *p, void *user, OrcInstruction *insn)
   llvm_get_src_int (src1, p, insn, insn->src_args[0]);
   llvm_get_src_int (src2, p, insn, insn->src_args[1]);
 
-  ORC_ASM_CODE (p, "   %s = xor <%d x i8> %s, 255\n", t1, sh, src2);
+  get_vector_constant (c, sh, 8, 255);
+
+  ORC_ASM_CODE (p, "   %s = xor <%d x i8> %s, %s\n", t1, sh, src2, c);
   ORC_ASM_CODE (p, "   %s = and <%d x i8> %s, %s\n", dest, sh, src1, t1);
 
   llvm_store_dst_int (dest, p, insn, insn->dest_args[0]);
@@ -486,20 +599,57 @@ static void
 llvm_rule_avgsb (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
   char dest[40], src1[40], src2[40];
+  int sh = get_shift (p, insn);
+  char t1[40], t2[40], t3[40], t4[40], t5[40], c[40];
+
+  get_temp (t1, p);
+  get_temp (t2, p);
+  get_temp (t3, p);
+  get_temp (t4, p);
+  get_temp (t5, p);
 
   llvm_get_dst_int (dest, p, insn, insn->dest_args[0]);
   llvm_get_src_int (src1, p, insn, insn->src_args[0]);
   llvm_get_src_int (src2, p, insn, insn->src_args[1]);
 
+  get_vector_constant (c, sh, 16, 1);
+
+  ORC_ASM_CODE (p, "   %s = sext <%d x i8> %s to <%d x i16>\n", t1, sh, src1, sh);
+  ORC_ASM_CODE (p, "   %s = sext <%d x i8> %s to <%d x i16>\n", t2, sh, src2, sh);
+  ORC_ASM_CODE (p, "   %s = add <%d x i16> %s, %s\n", t3, sh, t1, t2);
+  ORC_ASM_CODE (p, "   %s = add <%d x i16> %s, %s\n", t4, sh, t3, c);
+  ORC_ASM_CODE (p, "   %s = ashr <%d x i16> %s, %s\n", t5, sh, t4, c);
+  ORC_ASM_CODE (p, "   %s = trunc <%d x i16> %s to <%d x i8>\n", dest, sh, t5, sh);
+
+  llvm_store_dst_int (dest, p, insn, insn->dest_args[0]);
 }
 static void
 llvm_rule_avgub (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
   char dest[40], src1[40], src2[40];
+  int sh = get_shift (p, insn);
+  char t1[40], t2[40], t3[40], t4[40], t5[40], c[40];
+
+  get_temp (t1, p);
+  get_temp (t2, p);
+  get_temp (t3, p);
+  get_temp (t4, p);
+  get_temp (t5, p);
 
   llvm_get_dst_int (dest, p, insn, insn->dest_args[0]);
   llvm_get_src_int (src1, p, insn, insn->src_args[0]);
   llvm_get_src_int (src2, p, insn, insn->src_args[1]);
+
+  get_vector_constant (c, sh, 16, 1);
+
+  ORC_ASM_CODE (p, "   %s = zext <%d x i8> %s to <%d x i16>\n", t1, sh, src1, sh);
+  ORC_ASM_CODE (p, "   %s = zext <%d x i8> %s to <%d x i16>\n", t2, sh, src2, sh);
+  ORC_ASM_CODE (p, "   %s = add <%d x i16> %s, %s\n", t3, sh, t1, t2);
+  ORC_ASM_CODE (p, "   %s = add <%d x i16> %s, %s\n", t4, sh, t3, c);
+  ORC_ASM_CODE (p, "   %s = ashr <%d x i16> %s, %s\n", t5, sh, t4, c);
+  ORC_ASM_CODE (p, "   %s = trunc <%d x i16> %s to <%d x i8>\n", dest, sh, t5, sh);
+
+  llvm_store_dst_int (dest, p, insn, insn->dest_args[0]);
 }
 static void
 llvm_rule_cmpeqb (OrcCompiler *p, void *user, OrcInstruction *insn)
@@ -523,11 +673,12 @@ static void
 llvm_rule_copyb (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
   char dest[40], src[40];
+  int sh = get_shift (p, insn);
 
   llvm_get_dst_int (dest, p, insn, insn->dest_args[0]);
   llvm_get_src_int (src, p, insn, insn->src_args[0]);
 
-  ORC_ASM_CODE (p, "   %s = %s\n", dest, src);
+  ORC_ASM_CODE (p, "   %s = bitcast <%d x i8> %s to <%d x i8>\n", dest, sh, src, sh);
 
   llvm_store_dst_int (dest, p, insn, insn->dest_args[0]);
 }
@@ -541,8 +692,8 @@ llvm_rule_loadb (OrcCompiler *p, void *user, OrcInstruction *insn)
 
   llvm_get_dst_int (dest, p, insn, insn->dest_args[0]);
 
-  ORC_ASM_CODE (p, "   %s = getelementptr <%d x i8>* %%ptr%d, <%d x i64> %%i\n",
-      t1, sh, insn->src_args[0], sh);
+  ORC_ASM_CODE (p, "   %s = getelementptr <%d x i8>* %%ptr%d, i32 %%index_n\n",
+      t1, sh, insn->src_args[0]);
   ORC_ASM_CODE (p, "   %s = load <%d x i8>* %s\n", dest, sh, t1);
 
   llvm_store_dst_int (dest, p, insn, insn->dest_args[0]);
@@ -550,34 +701,141 @@ llvm_rule_loadb (OrcCompiler *p, void *user, OrcInstruction *insn)
 static void
 llvm_rule_loadoffb (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
+  char dest[40], t1[40];
+  int sh = get_shift (p, insn);
+
+  get_temp (t1, p);
+
+  llvm_get_dst_int (dest, p, insn, insn->dest_args[0]);
+
+  /* FIXME */
+  ORC_ASM_CODE (p, "   %s = getelementptr <%d x i8>* %%ptr%d, i32 %%index_n\n",
+      t1, sh, insn->src_args[0]);
+  ORC_ASM_CODE (p, "   %s = load <%d x i8>* %s\n", dest, sh, t1);
+
+  llvm_store_dst_int (dest, p, insn, insn->dest_args[0]);
 }
 static void
 llvm_rule_loadupdb (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
+  char dest[40], t1[40];
+  int sh = get_shift (p, insn);
+
+  get_temp (t1, p);
+
+  llvm_get_dst_int (dest, p, insn, insn->dest_args[0]);
+
+  /* FIXME */
+  ORC_ASM_CODE (p, "   %s = getelementptr <%d x i8>* %%ptr%d, i32 %%index_n\n",
+      t1, sh, insn->src_args[0]);
+  ORC_ASM_CODE (p, "   %s = load <%d x i8>* %s\n", dest, sh, t1);
+
+  llvm_store_dst_int (dest, p, insn, insn->dest_args[0]);
 }
 static void
 llvm_rule_loadupib (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
+  char dest[40], t1[40];
+  int sh = get_shift (p, insn);
+
+  get_temp (t1, p);
+
+  llvm_get_dst_int (dest, p, insn, insn->dest_args[0]);
+
+  /* FIXME */
+  ORC_ASM_CODE (p, "   %s = getelementptr <%d x i8>* %%ptr%d, i32 %%index_n\n",
+      t1, sh, insn->src_args[0]);
+  ORC_ASM_CODE (p, "   %s = load <%d x i8>* %s\n", dest, sh, t1);
+
+  llvm_store_dst_int (dest, p, insn, insn->dest_args[0]);
 }
 static void
 llvm_rule_loadpb (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
+  char dest[40], c[40];
+  int sh = get_shift (p, insn);
+
+  llvm_get_dst_int (dest, p, insn, insn->dest_args[0]);
+
+  if (p->vars[insn->src_args[0]].vartype == ORC_VAR_TYPE_PARAM) {
+    ORC_ASM_CODE(p,"    %s = bitcast i%d %s to <%d x i8>;\n", dest, p->vars[insn->src_args[0]].size * 8,
+        varnames[insn->src_args[0]], sh);
+  } else if (p->vars[insn->src_args[0]].vartype == ORC_VAR_TYPE_CONST) {
+    get_vector_constant (c, sh, 8, p->vars[insn->src_args[0]].value.i);
+    ORC_ASM_CODE(p,"    %s = bitcast <%d x i8> %s to <%d x i8>;\n", dest, sh, c, sh);
+  } else {
+    ORC_COMPILER_ERROR(p, "expected param or constant");
+  }
+
+  llvm_store_dst_int (dest, p, insn, insn->dest_args[0]);
 }
 static void
 llvm_rule_ldresnearb (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
+  char dest[40], t1[40];
+  int sh = get_shift (p, insn);
+
+  get_temp (t1, p);
+
+  llvm_get_dst_int (dest, p, insn, insn->dest_args[0]);
+
+  /* FIXME */
+  ORC_ASM_CODE (p, "   %s = getelementptr <%d x i8>* %%ptr%d, i32 %%index_n\n",
+      t1, sh, insn->src_args[0]);
+  ORC_ASM_CODE (p, "   %s = load <%d x i8>* %s\n", dest, sh, t1);
+
+  llvm_store_dst_int (dest, p, insn, insn->dest_args[0]);
 }
 static void
 llvm_rule_ldresnearl (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
+  char dest[40], t1[40];
+  int sh = get_shift (p, insn);
+
+  get_temp (t1, p);
+
+  llvm_get_dst_int (dest, p, insn, insn->dest_args[0]);
+
+  /* FIXME */
+  ORC_ASM_CODE (p, "   %s = getelementptr <%d x i32>* %%ptr%d, i32 %%index_n\n",
+      t1, sh, insn->src_args[0]);
+  ORC_ASM_CODE (p, "   %s = load <%d x i32>* %s\n", dest, sh, t1);
+
+  llvm_store_dst_int (dest, p, insn, insn->dest_args[0]);
 }
 static void
 llvm_rule_ldreslinb (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
+  char dest[40], t1[40];
+  int sh = get_shift (p, insn);
+
+  get_temp (t1, p);
+
+  llvm_get_dst_int (dest, p, insn, insn->dest_args[0]);
+
+  /* FIXME */
+  ORC_ASM_CODE (p, "   %s = getelementptr <%d x i8>* %%ptr%d, i32 %%index_n\n",
+      t1, sh, insn->src_args[0]);
+  ORC_ASM_CODE (p, "   %s = load <%d x i8>* %s\n", dest, sh, t1);
+
+  llvm_store_dst_int (dest, p, insn, insn->dest_args[0]);
 }
 static void
 llvm_rule_ldreslinl (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
+  char dest[40], t1[40];
+  int sh = get_shift (p, insn);
+
+  get_temp (t1, p);
+
+  llvm_get_dst_int (dest, p, insn, insn->dest_args[0]);
+
+  /* FIXME */
+  ORC_ASM_CODE (p, "   %s = getelementptr <%d x i32>* %%ptr%d, i32 %%index_n\n",
+      t1, sh, insn->src_args[0]);
+  ORC_ASM_CODE (p, "   %s = load <%d x i32>* %s\n", dest, sh, t1);
+
+  llvm_store_dst_int (dest, p, insn, insn->dest_args[0]);
 }
 static void
 llvm_rule_maxsb (OrcCompiler *p, void *user, OrcInstruction *insn)
@@ -634,16 +892,23 @@ llvm_rule_mulhsb (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
   char dest[40], src1[40], src2[40];
   int sh = get_shift (p, insn);
-  char t1[40], t2[40], t3[40], t4[40];
+  char t1[40], t2[40], t3[40], t4[40], c[40];
+
+  get_temp (t1, p);
+  get_temp (t2, p);
+  get_temp (t3, p);
+  get_temp (t4, p);
 
   llvm_get_dst_int (dest, p, insn, insn->dest_args[0]);
   llvm_get_src_int (src1, p, insn, insn->src_args[0]);
   llvm_get_src_int (src2, p, insn, insn->src_args[1]);
 
+  get_vector_constant (c, sh, 16, 8);
+
   ORC_ASM_CODE (p, "   %s = sext <%d x i8> %s to <%d x i16>\n", t1, sh, src1, sh);
   ORC_ASM_CODE (p, "   %s = sext <%d x i8> %s to <%d x i16>\n", t2, sh, src2, sh);
   ORC_ASM_CODE (p, "   %s = mul <%d x i16> %s, %s\n", t3, sh, t1, t2);
-  ORC_ASM_CODE (p, "   %s = ashr <%d x i16> %s, 8\n", t4, sh, t3);
+  ORC_ASM_CODE (p, "   %s = ashr <%d x i16> %s, %s\n", t4, sh, t3, c);
   ORC_ASM_CODE (p, "   %s = trunc <%d x i16> %s to <%d x i8>\n", dest, sh, t4, sh);
 
   llvm_store_dst_int (dest, p, insn, insn->dest_args[0]);
@@ -651,7 +916,7 @@ llvm_rule_mulhsb (OrcCompiler *p, void *user, OrcInstruction *insn)
 static void
 llvm_rule_mulhub (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
-  char dest[40], src1[40], src2[40], t1[40], t2[40], t3[40], t4[40];
+  char dest[40], src1[40], src2[40], t1[40], t2[40], t3[40], t4[40], c[40];
   int sh = get_shift (p, insn);
 
   get_temp (t1, p);
@@ -663,10 +928,12 @@ llvm_rule_mulhub (OrcCompiler *p, void *user, OrcInstruction *insn)
   llvm_get_src_int (src1, p, insn, insn->src_args[0]);
   llvm_get_src_int (src2, p, insn, insn->src_args[1]);
 
+  get_vector_constant (c, sh, 16, 8);
+
   ORC_ASM_CODE (p, "   %s = zext <%d x i8> %s to <%d x i16>\n", t1, sh, src1, sh);
   ORC_ASM_CODE (p, "   %s = zext <%d x i8> %s to <%d x i16>\n", t2, sh, src2, sh);
   ORC_ASM_CODE (p, "   %s = mul <%d x i16> %s, %s\n", t3, sh, t1, t2);
-  ORC_ASM_CODE (p, "   %s = lshr <%d x i16> %s, 8\n", t4, sh, t3);
+  ORC_ASM_CODE (p, "   %s = lshr <%d x i16> %s, %s\n", t4, sh, t3, c);
   ORC_ASM_CODE (p, "   %s = trunc <%d x i16> %s to <%d x i8>\n", dest, sh, t4, sh);
 
   llvm_store_dst_int (dest, p, insn, insn->dest_args[0]);
@@ -745,9 +1012,9 @@ llvm_rule_storeb (OrcCompiler *p, void *user, OrcInstruction *insn)
 
   llvm_get_dst_int (src, p, insn, insn->src_args[0]);
 
-  ORC_ASM_CODE (p, "   %s = getelementptr <%d x i8>* %%ptr%d, <%d x i64> %%i\n",
-      t1, sh, insn->dest_args[0], sh);
-  ORC_ASM_CODE (p, "   store <%d x i8> %s, %s\n", sh, src, t1);
+  ORC_ASM_CODE (p, "   %s = getelementptr <%d x i8>* %%ptr%d, i32 %%index_n\n",
+      t1, sh, insn->dest_args[0]);
+  ORC_ASM_CODE (p, "   store <%d x i8> %s, <%d x i8>* %s\n", sh, src, sh, t1);
 }
 
 static void
@@ -887,7 +1154,7 @@ llvm_rule_andnw (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
   char dest[40], src1[40], src2[40];
   int sh = get_shift (p, insn);
-  char t1[40];
+  char t1[40], c[40];
 
   get_temp (t1, p);
 
@@ -895,7 +1162,9 @@ llvm_rule_andnw (OrcCompiler *p, void *user, OrcInstruction *insn)
   llvm_get_src_int (src1, p, insn, insn->src_args[0]);
   llvm_get_src_int (src2, p, insn, insn->src_args[1]);
 
-  ORC_ASM_CODE (p, "   %s = xor <%d x i16> %s, 65535\n", t1, sh, src2);
+  get_vector_constant (c, sh, 16, 65535);
+
+  ORC_ASM_CODE (p, "   %s = xor <%d x i16> %s, %s\n", t1, sh, src2, c);
   ORC_ASM_CODE (p, "   %s = and <%d x i16> %s, %s\n", dest, sh, src1, t1);
 
   llvm_store_dst_int (dest, p, insn, insn->dest_args[0]);
@@ -904,19 +1173,57 @@ static void
 llvm_rule_avgsw (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
   char dest[40], src1[40], src2[40];
+  int sh = get_shift (p, insn);
+  char t1[40], t2[40], t3[40], t4[40], t5[40], c[40];
+
+  get_temp (t1, p);
+  get_temp (t2, p);
+  get_temp (t3, p);
+  get_temp (t4, p);
+  get_temp (t5, p);
 
   llvm_get_dst_int (dest, p, insn, insn->dest_args[0]);
   llvm_get_src_int (src1, p, insn, insn->src_args[0]);
   llvm_get_src_int (src2, p, insn, insn->src_args[1]);
+
+  get_vector_constant (c, sh, 32, 1);
+
+  ORC_ASM_CODE (p, "   %s = sext <%d x i16> %s to <%d x i32>\n", t1, sh, src1, sh);
+  ORC_ASM_CODE (p, "   %s = sext <%d x i16> %s to <%d x i32>\n", t2, sh, src2, sh);
+  ORC_ASM_CODE (p, "   %s = add <%d x i32> %s, %s\n", t3, sh, t1, t2);
+  ORC_ASM_CODE (p, "   %s = add <%d x i32> %s, %s\n", t4, sh, t3, c);
+  ORC_ASM_CODE (p, "   %s = ashr <%d x i32> %s, %s\n", t5, sh, t4, c);
+  ORC_ASM_CODE (p, "   %s = trunc <%d x i32> %s to <%d x i16>\n", dest, sh, t5, sh);
+
+  llvm_store_dst_int (dest, p, insn, insn->dest_args[0]);
 }
 static void
 llvm_rule_avguw (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
   char dest[40], src1[40], src2[40];
+  int sh = get_shift (p, insn);
+  char t1[40], t2[40], t3[40], t4[40], t5[40], c[40];
+
+  get_temp (t1, p);
+  get_temp (t2, p);
+  get_temp (t3, p);
+  get_temp (t4, p);
+  get_temp (t5, p);
 
   llvm_get_dst_int (dest, p, insn, insn->dest_args[0]);
   llvm_get_src_int (src1, p, insn, insn->src_args[0]);
   llvm_get_src_int (src2, p, insn, insn->src_args[1]);
+
+  get_vector_constant (c, sh, 32, 1);
+
+  ORC_ASM_CODE (p, "   %s = zext <%d x i16> %s to <%d x i32>\n", t1, sh, src1, sh);
+  ORC_ASM_CODE (p, "   %s = zext <%d x i16> %s to <%d x i32>\n", t2, sh, src2, sh);
+  ORC_ASM_CODE (p, "   %s = add <%d x i32> %s, %s\n", t3, sh, t1, t2);
+  ORC_ASM_CODE (p, "   %s = add <%d x i32> %s, %s\n", t4, sh, t3, c);
+  ORC_ASM_CODE (p, "   %s = ashr <%d x i32> %s, %s\n", t5, sh, t4, c);
+  ORC_ASM_CODE (p, "   %s = trunc <%d x i32> %s to <%d x i16>\n", dest, sh, t5, sh);
+
+  llvm_store_dst_int (dest, p, insn, insn->dest_args[0]);
 }
 static void
 llvm_rule_cmpeqw (OrcCompiler *p, void *user, OrcInstruction *insn)
@@ -940,21 +1247,29 @@ static void
 llvm_rule_copyw (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
   char dest[40], src[40];
+  int sh = get_shift (p, insn);
 
   llvm_get_dst_int (dest, p, insn, insn->dest_args[0]);
   llvm_get_src_int (src, p, insn, insn->src_args[0]);
 
-  ORC_ASM_CODE (p, "   %s = %s\n", dest, src);
+  ORC_ASM_CODE (p, "   %s = bitcast <%d x i16> %s to <%d x i16>\n", dest, sh, src, sh);
 
   llvm_store_dst_int (dest, p, insn, insn->dest_args[0]);
 }
 static void
 llvm_rule_div255w (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
-  char dest[40], src[40];
+  char dest[40], src[40], c[40];
+  int sh = get_shift (p, insn);
 
   llvm_get_dst_int (dest, p, insn, insn->dest_args[0]);
   llvm_get_src_int (src, p, insn, insn->src_args[0]);
+
+  get_vector_constant (c, sh, 16, 255);
+
+  ORC_ASM_CODE (p, "   %s = sdiv <%d x i16> %s, %s\n", dest, sh, src, c);
+
+  llvm_store_dst_int (dest, p, insn, insn->dest_args[0]);
 }
 static void
 llvm_rule_divluw (OrcCompiler *p, void *user, OrcInstruction *insn)
@@ -975,8 +1290,8 @@ llvm_rule_loadw (OrcCompiler *p, void *user, OrcInstruction *insn)
 
   llvm_get_dst_int (dest, p, insn, insn->dest_args[0]);
 
-  ORC_ASM_CODE (p, "   %s = getelementptr <%d x i16>* %%ptr%d, <%d x i64> %%i\n",
-      t1, sh, insn->src_args[0], sh);
+  ORC_ASM_CODE (p, "   %s = getelementptr <%d x i16>* %%ptr%d, i32 %%index_n\n",
+      t1, sh, insn->src_args[0]);
   ORC_ASM_CODE (p, "   %s = load <%d x i16>* %s\n", dest, sh, t1);
 
   llvm_store_dst_int (dest, p, insn, insn->dest_args[0]);
@@ -984,10 +1299,52 @@ llvm_rule_loadw (OrcCompiler *p, void *user, OrcInstruction *insn)
 static void
 llvm_rule_loadoffw (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
+  char dest[40], t1[40];
+  int sh = get_shift (p, insn);
+
+  get_temp (t1, p);
+
+  llvm_get_dst_int (dest, p, insn, insn->dest_args[0]);
+
+  /* FIXME */
+  ORC_ASM_CODE (p, "   %s = getelementptr <%d x i16>* %%ptr%d, i32 %%index_n\n",
+      t1, sh, insn->src_args[0]);
+  ORC_ASM_CODE (p, "   %s = load <%d x i16>* %s\n", dest, sh, t1);
+
+  llvm_store_dst_int (dest, p, insn, insn->dest_args[0]);
 }
 static void
 llvm_rule_loadpw (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
+  char dest[40], t1[40];
+  int sh = get_shift (p, insn);
+
+  llvm_get_dst_int (dest, p, insn, insn->dest_args[0]);
+
+  if (p->vars[insn->src_args[0]].vartype == ORC_VAR_TYPE_PARAM) {
+    if (p->vars[insn->src_args[0]].size < 2) {
+      get_temp (t1, p);
+
+      ORC_ASM_CODE(p,"    %s = sext i8 %s to i16\n", t1,
+          varnames[insn->src_args[0]]);
+      ORC_ASM_CODE(p,"    %s = bitcast i16 %s to <1 x i16>\n", dest, t1);
+    } else if (p->vars[insn->src_args[0]].size > 2) {
+      ORC_ASSERT (0);
+    } else {
+      ORC_ASM_CODE(p,"    %s = bitcast i16 %s to <1 x i16>\n", dest,
+          varnames[insn->src_args[0]]);
+    }
+
+  } else if (p->vars[insn->src_args[0]].vartype == ORC_VAR_TYPE_CONST) {
+    get_vector_constant (t1, sh, 16, p->vars[insn->src_args[0]].value.i);
+
+    ORC_ASM_CODE(p,"    %s = bitcast <%d x i16> %s to <%d x i16>\n", dest, sh,
+        t1, sh);
+  } else {
+    ORC_COMPILER_ERROR(p, "expected param or constant");
+  }
+
+  llvm_store_dst_int (dest, p, insn, insn->dest_args[0]);
 }
 static void
 llvm_rule_maxsw (OrcCompiler *p, void *user, OrcInstruction *insn)
@@ -1044,7 +1401,7 @@ llvm_rule_mulhsw (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
   char dest[40], src1[40], src2[40];
   int sh = get_shift (p, insn);
-  char t1[40], t2[40], t3[40], t4[40];
+  char t1[40], t2[40], t3[40], t4[40], c[40];
 
   get_temp (t1, p);
   get_temp (t2, p);
@@ -1055,10 +1412,12 @@ llvm_rule_mulhsw (OrcCompiler *p, void *user, OrcInstruction *insn)
   llvm_get_src_int (src1, p, insn, insn->src_args[0]);
   llvm_get_src_int (src2, p, insn, insn->src_args[1]);
 
+  get_vector_constant (c, sh, 32, 16);
+
   ORC_ASM_CODE (p, "   %s = sext <%d x i16> %s to <%d x i32>\n", t1, sh, src1, sh);
   ORC_ASM_CODE (p, "   %s = sext <%d x i16> %s to <%d x i32>\n", t2, sh, src2, sh);
   ORC_ASM_CODE (p, "   %s = mul <%d x i32> %s, %s\n", t3, sh, t1, t2);
-  ORC_ASM_CODE (p, "   %s = ashr <%d x i32> %s, 16\n", t4, sh, t3);
+  ORC_ASM_CODE (p, "   %s = ashr <%d x i32> %s, %s\n", t4, sh, t3, c);
   ORC_ASM_CODE (p, "   %s = trunc <%d x i32> %s to <%d x i16>\n", dest, sh, t4, sh);
 
   llvm_store_dst_int (dest, p, insn, insn->dest_args[0]);
@@ -1068,7 +1427,7 @@ llvm_rule_mulhuw (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
   char dest[40], src1[40], src2[40];
   int sh = get_shift (p, insn);
-  char t1[40], t2[40], t3[40], t4[40];
+  char t1[40], t2[40], t3[40], t4[40], c[40];
 
   get_temp (t1, p);
   get_temp (t2, p);
@@ -1079,10 +1438,12 @@ llvm_rule_mulhuw (OrcCompiler *p, void *user, OrcInstruction *insn)
   llvm_get_src_int (src1, p, insn, insn->src_args[0]);
   llvm_get_src_int (src2, p, insn, insn->src_args[1]);
 
+  get_vector_constant (c, sh, 32, 16);
+
   ORC_ASM_CODE (p, "   %s = zext <%d x i16> %s to <%d x i32>\n", t1, sh, src1, sh);
   ORC_ASM_CODE (p, "   %s = zext <%d x i16> %s to <%d x i32>\n", t2, sh, src2, sh);
   ORC_ASM_CODE (p, "   %s = mul <%d x i32> %s, %s\n", t3, sh, t1, t2);
-  ORC_ASM_CODE (p, "   %s = ashr <%d x i32> %s, 16\n", t4, sh, t3);
+  ORC_ASM_CODE (p, "   %s = ashr <%d x i32> %s, %s\n", t4, sh, t3, c);
   ORC_ASM_CODE (p, "   %s = trunc <%d x i32> %s to <%d x i16>\n", dest, sh, t4, sh);
 
   llvm_store_dst_int (dest, p, insn, insn->dest_args[0]);
@@ -1161,9 +1522,9 @@ llvm_rule_storew (OrcCompiler *p, void *user, OrcInstruction *insn)
 
   llvm_get_dst_int (src, p, insn, insn->src_args[0]);
 
-  ORC_ASM_CODE (p, "   %s = getelementptr <%d x i16>* %%ptr%d, <%d x i64> %%i\n",
-      t1, sh, insn->dest_args[0], sh);
-  ORC_ASM_CODE (p, "   store <%d x i16> %s, %s\n", sh, src, t1);
+  ORC_ASM_CODE (p, "   %s = getelementptr <%d x i16>* %%ptr%d, i32 %%index_n\n",
+      t1, sh, insn->dest_args[0]);
+  ORC_ASM_CODE (p, "   store <%d x i16> %s, <%d x i16>* %s\n", sh, src, sh, t1);
 }
 static void
 llvm_rule_subw (OrcCompiler *p, void *user, OrcInstruction *insn)
@@ -1302,7 +1663,7 @@ llvm_rule_andnl (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
   char dest[40], src1[40], src2[40];
   int sh = get_shift (p, insn);
-  char t1[40];
+  char t1[40], c[40];
 
   get_temp (t1, p);
 
@@ -1310,7 +1671,9 @@ llvm_rule_andnl (OrcCompiler *p, void *user, OrcInstruction *insn)
   llvm_get_src_int (src1, p, insn, insn->src_args[0]);
   llvm_get_src_int (src2, p, insn, insn->src_args[1]);
 
-  ORC_ASM_CODE (p, "   %s = xor <%d x i32> %s, 0xffffffff\n", t1, sh, src2);
+  get_vector_constant (c, sh, 32, 0xffffffff);
+
+  ORC_ASM_CODE (p, "   %s = xor <%d x i32> %s, %s\n", t1, sh, src2, c);
   ORC_ASM_CODE (p, "   %s = and <%d x i32> %s, %s\n", dest, sh, src1, t1);
 
   llvm_store_dst_int (dest, p, insn, insn->dest_args[0]);
@@ -1355,11 +1718,12 @@ static void
 llvm_rule_copyl (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
   char dest[40], src[40];
+  int sh = get_shift (p, insn);
 
   llvm_get_dst_int (dest, p, insn, insn->dest_args[0]);
   llvm_get_src_int (src, p, insn, insn->src_args[0]);
 
-  ORC_ASM_CODE (p, "   %s = %s\n", dest, src);
+  ORC_ASM_CODE (p, "   %s = bitcast <%d x i32> %s to <%d x i32>\n", dest, sh, src, sh);
 
   llvm_store_dst_int (dest, p, insn, insn->dest_args[0]);
 }
@@ -1373,8 +1737,8 @@ llvm_rule_loadl (OrcCompiler *p, void *user, OrcInstruction *insn)
 
   llvm_get_dst_int (dest, p, insn, insn->dest_args[0]);
 
-  ORC_ASM_CODE (p, "   %s = getelementptr <%d x i32>* %%ptr%d, <%d x i64> %%i\n",
-      t1, sh, insn->src_args[0], sh);
+  ORC_ASM_CODE (p, "   %s = getelementptr <%d x i32>* %%ptr%d, i32 %%index_n\n",
+      t1, sh, insn->src_args[0]);
   ORC_ASM_CODE (p, "   %s = load <%d x i32>* %s\n", dest, sh, t1);
 
   llvm_store_dst_int (dest, p, insn, insn->dest_args[0]);
@@ -1386,6 +1750,34 @@ llvm_rule_loadoffl (OrcCompiler *p, void *user, OrcInstruction *insn)
 static void
 llvm_rule_loadpl (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
+  char dest[40], t1[40];
+  int sh = get_shift (p, insn);
+
+  llvm_get_dst_int (dest, p, insn, insn->dest_args[0]);
+
+  if (p->vars[insn->src_args[0]].vartype == ORC_VAR_TYPE_PARAM) {
+    if (p->vars[insn->src_args[0]].size < 4) {
+      get_temp (t1, p);
+
+      ORC_ASM_CODE(p,"    %s = sext i%d %s to i32\n", t1,
+          p->vars[insn->src_args[0]].size * 8, varnames[insn->src_args[0]]);
+      ORC_ASM_CODE(p,"    %s = bitcast i32 %s to <1 x i32>\n", dest, t1);
+    } else if (p->vars[insn->src_args[0]].size > 4) {
+      ORC_ASSERT (0);
+    } else {
+      ORC_ASM_CODE(p,"    %s = bitcast i32 %s to <1 x i32>\n", dest,
+          varnames[insn->src_args[0]]);
+    }
+
+  } else if (p->vars[insn->src_args[0]].vartype == ORC_VAR_TYPE_CONST) {
+    get_vector_constant (t1, sh, 32, p->vars[insn->src_args[0]].value.i);
+    ORC_ASM_CODE(p,"    %s = bitcast <%d x i32> %s to <%d x i32>\n", dest, sh,
+        t1, sh);
+  } else {
+    ORC_COMPILER_ERROR(p, "expected param or constant");
+  }
+
+  llvm_store_dst_int (dest, p, insn, insn->dest_args[0]);
 }
 static void
 llvm_rule_maxsl (OrcCompiler *p, void *user, OrcInstruction *insn)
@@ -1442,7 +1834,7 @@ llvm_rule_mulhsl (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
   char dest[40], src1[40], src2[40];
   int sh = get_shift (p, insn);
-  char t1[40], t2[40], t3[40], t4[40];
+  char t1[40], t2[40], t3[40], t4[40], c[40];
 
   get_temp (t1, p);
   get_temp (t2, p);
@@ -1453,10 +1845,12 @@ llvm_rule_mulhsl (OrcCompiler *p, void *user, OrcInstruction *insn)
   llvm_get_src_int (src1, p, insn, insn->src_args[0]);
   llvm_get_src_int (src2, p, insn, insn->src_args[1]);
 
+  get_vector_constant (c, sh, 64, 32);
+
   ORC_ASM_CODE (p, "   %s = sext <%d x i32> %s to <%d x i64>\n", t1, sh, src1, sh);
   ORC_ASM_CODE (p, "   %s = sext <%d x i32> %s to <%d x i64>\n", t2, sh, src2, sh);
   ORC_ASM_CODE (p, "   %s = mul <%d x i64> %s, %s\n", t3, sh, t1, t2);
-  ORC_ASM_CODE (p, "   %s = ashr <%d x i64> %s, 32\n", t4, sh, t3);
+  ORC_ASM_CODE (p, "   %s = ashr <%d x i64> %s, %s\n", t4, sh, t3, c);
   ORC_ASM_CODE (p, "   %s = trunc <%d x i64> %s to <%d x i32>\n", dest, sh, t4, sh);
 
   llvm_store_dst_int (dest, p, insn, insn->dest_args[0]);
@@ -1466,7 +1860,7 @@ llvm_rule_mulhul (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
   char dest[40], src1[40], src2[40];
   int sh = get_shift (p, insn);
-  char t1[40], t2[40], t3[40], t4[40];
+  char t1[40], t2[40], t3[40], t4[40], c[40];
 
   get_temp (t1, p);
   get_temp (t2, p);
@@ -1477,10 +1871,12 @@ llvm_rule_mulhul (OrcCompiler *p, void *user, OrcInstruction *insn)
   llvm_get_src_int (src1, p, insn, insn->src_args[0]);
   llvm_get_src_int (src2, p, insn, insn->src_args[1]);
 
+  get_vector_constant (c, sh, 64, 32);
+
   ORC_ASM_CODE (p, "   %s = zext <%d x i32> %s to <%d x i64>\n", t1, sh, src1, sh);
   ORC_ASM_CODE (p, "   %s = zext <%d x i32> %s to <%d x i64>\n", t2, sh, src2, sh);
   ORC_ASM_CODE (p, "   %s = mul <%d x i64> %s, %s\n", t3, sh, t1, t2);
-  ORC_ASM_CODE (p, "   %s = ashr <%d x i64> %s, 32\n", t4, sh, t3);
+  ORC_ASM_CODE (p, "   %s = ashr <%d x i64> %s, %s\n", t4, sh, t3, c);
   ORC_ASM_CODE (p, "   %s = trunc <%d x i64> %s to <%d x i32>\n", dest, sh, t4, sh);
 
   llvm_store_dst_int (dest, p, insn, insn->dest_args[0]);
@@ -1559,9 +1955,9 @@ llvm_rule_storel (OrcCompiler *p, void *user, OrcInstruction *insn)
 
   llvm_get_dst_int (src, p, insn, insn->src_args[0]);
 
-  ORC_ASM_CODE (p, "   %s = getelementptr <%d x i32>* %%ptr%d, <%d x i64> %%i\n",
-      t1, sh, insn->dest_args[0], sh);
-  ORC_ASM_CODE (p, "   store <%d x i32> %s, %s\n", sh, src, t1);
+  ORC_ASM_CODE (p, "   %s = getelementptr <%d x i32>* %%ptr%d, i32 %%index_n\n",
+      t1, sh, insn->dest_args[0]);
+  ORC_ASM_CODE (p, "   store <%d x i32> %s, <%d x i32>* %s\n", sh, src, sh, t1);
 }
 static void
 llvm_rule_subl (OrcCompiler *p, void *user, OrcInstruction *insn)
@@ -1630,8 +2026,8 @@ llvm_rule_loadq (OrcCompiler *p, void *user, OrcInstruction *insn)
 
   llvm_get_dst_int (dest, p, insn, insn->dest_args[0]);
 
-  ORC_ASM_CODE (p, "   %s = getelementptr <%d x i64>* %%ptr%d, <%d x i64> %%i\n",
-      t1, sh, insn->src_args[0], sh);
+  ORC_ASM_CODE (p, "   %s = getelementptr <%d x i64>* %%ptr%d, i32 %%index_n\n",
+      t1, sh, insn->src_args[0]);
   ORC_ASM_CODE (p, "   %s = load <%d x i64>* %s\n", dest, sh, t1);
 
   llvm_store_dst_int (dest, p, insn, insn->dest_args[0]);
@@ -1639,6 +2035,32 @@ llvm_rule_loadq (OrcCompiler *p, void *user, OrcInstruction *insn)
 static void
 llvm_rule_loadpq (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
+  char dest[40], t1[40];
+
+  llvm_get_dst_int (dest, p, insn, insn->dest_args[0]);
+
+  if (p->vars[insn->src_args[0]].vartype == ORC_VAR_TYPE_PARAM) {
+    if (p->vars[insn->src_args[0]].size < 8) {
+      get_temp (t1, p);
+
+      ORC_ASM_CODE(p,"    %s = sext i%d %s to i64\n", t1,
+          p->vars[insn->src_args[0]].size * 8, varnames[insn->src_args[0]]);
+      ORC_ASM_CODE(p,"    %s = bitcast i64 %s to <1 x i64>\n", dest, t1);
+    } else if (p->vars[insn->src_args[0]].size > 8) {
+      ORC_ASSERT (0);
+    } else {
+      ORC_ASM_CODE(p,"    %s = bitcast i64 %s to <1 x i64>\n", dest,
+          varnames[insn->src_args[0]]);
+    }
+
+  } else if (p->vars[insn->src_args[0]].vartype == ORC_VAR_TYPE_CONST) {
+    ORC_ASM_CODE(p,"    %s = bitcast <1 x i64> <i64 %ld> to <1 x i64>\n", dest,
+        p->vars[insn->src_args[0]].value.i);
+  } else {
+    ORC_COMPILER_ERROR(p, "expected param or constant");
+  }
+
+  llvm_store_dst_int (dest, p, insn, insn->dest_args[0]);
 }
 static void
 llvm_rule_storeq (OrcCompiler *p, void *user, OrcInstruction *insn)
@@ -1650,9 +2072,9 @@ llvm_rule_storeq (OrcCompiler *p, void *user, OrcInstruction *insn)
 
   llvm_get_dst_int (src, p, insn, insn->src_args[0]);
 
-  ORC_ASM_CODE (p, "   %s = getelementptr <%d x i64>* %%ptr%d, <%d x i64> %%i\n",
-      t1, sh, insn->dest_args[0], sh);
-  ORC_ASM_CODE (p, "   store <%d x i64> %s, %s\n", sh, src, t1);
+  ORC_ASM_CODE (p, "   %s = getelementptr <%d x i64>* %%ptr%d, i32 %%index_n\n",
+      t1, sh, insn->dest_args[0]);
+  ORC_ASM_CODE (p, "   store <%d x i64> %s, <%d x i64>* %s\n", sh, src, sh, t1);
 }
 static void
 llvm_rule_splatw3q (OrcCompiler *p, void *user, OrcInstruction *insn)
@@ -1666,11 +2088,12 @@ static void
 llvm_rule_copyq (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
   char dest[40], src[40];
+  int sh = get_shift (p, insn);
 
   llvm_get_dst_int (dest, p, insn, insn->dest_args[0]);
   llvm_get_src_int (src, p, insn, insn->src_args[0]);
 
-  ORC_ASM_CODE (p, "   %s = %s\n", dest, src);
+  ORC_ASM_CODE (p, "   %s = bitcast <%d x i64> %s to <%d x i64>\n", dest, sh, src, sh);
 
   llvm_store_dst_int (dest, p, insn, insn->dest_args[0]);
 }
@@ -1711,7 +2134,7 @@ llvm_rule_andnq (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
   char dest[40], src1[40], src2[40];
   int sh = get_shift (p, insn);
-  char t1[40];
+  char t1[40], c[40];
 
   get_temp (t1, p);
 
@@ -1719,7 +2142,9 @@ llvm_rule_andnq (OrcCompiler *p, void *user, OrcInstruction *insn)
   llvm_get_src_int (src1, p, insn, insn->src_args[0]);
   llvm_get_src_int (src2, p, insn, insn->src_args[1]);
 
-  ORC_ASM_CODE (p, "   %s = xor <%d x i64> %s, 0xffffffffffffffff\n", t1, sh, src2);
+  get_vector_constant (c, sh, 64, 0xffffffffffffffff);
+
+  ORC_ASM_CODE (p, "   %s = xor <%d x i64> %s, %s\n", t1, sh, src2, c);
   ORC_ASM_CODE (p, "   %s = and <%d x i64> %s, %s\n", dest, sh, src1, t1);
 
   llvm_store_dst_int (dest, p, insn, insn->dest_args[0]);
@@ -1855,10 +2280,13 @@ llvm_rule_splatbw (OrcCompiler *p, void *user, OrcInstruction *insn)
   char dest[40], src[40];
   int sh = get_shift (p, insn);
   const char *mask;
+  char t1[40];
 
   llvm_get_dst_int (dest, p, insn, insn->dest_args[0]);
   llvm_get_src_int (src, p, insn, insn->src_args[0]);
 
+  get_temp (t1, p);
+
   if (sh == 1)
     mask = "<2 x i32> <i32 0, i32 0>";
   else if (sh == 2)
@@ -1869,7 +2297,9 @@ llvm_rule_splatbw (OrcCompiler *p, void *user, OrcInstruction *insn)
     mask = "ERROR";
 
   ORC_ASM_CODE (p, "   %s = shufflevector <%d x i8> %s, <%d x i8> %s, %s\n",
-      dest, sh, src, sh, src, mask);
+      t1, sh, src, sh, src, mask);
+  ORC_ASM_CODE (p, "   %s = bitcast <%d x i8> %s to <%d x i16>\n",
+      dest, sh * 2, t1, sh);
 
   llvm_store_dst_int (dest, p, insn, insn->dest_args[0]);
 }
@@ -1879,10 +2309,13 @@ llvm_rule_splatbl (OrcCompiler *p, void *user, OrcInstruction *insn)
   char dest[40], src[40];
   int sh = get_shift (p, insn);
   const char *mask;
+  char t1[40];
 
   llvm_get_dst_int (dest, p, insn, insn->dest_args[0]);
   llvm_get_src_int (src, p, insn, insn->src_args[0]);
 
+  get_temp (t1, p);
+
   if (sh == 1)
     mask = "<4 x i32> <i32 0, i32 0, i32 0, i32 0>";
   else if (sh == 2)
@@ -1891,7 +2324,9 @@ llvm_rule_splatbl (OrcCompiler *p, void *user, OrcInstruction *insn)
     mask = "ERROR";
 
   ORC_ASM_CODE (p, "   %s = shufflevector <%d x i8> %s, <%d x i8> %s, %s\n",
-      dest, sh, src, sh, src, mask);
+      t1, sh, src, sh, src, mask);
+  ORC_ASM_CODE (p, "   %s = bitcast <%d x i8> %s to <%d x i32>\n",
+      dest, sh * 4, t1, sh);
 
   llvm_store_dst_int (dest, p, insn, insn->dest_args[0]);
 }
@@ -1967,14 +2402,16 @@ llvm_rule_convhwb (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
   char dest[40], src[40];
   int sh = get_shift (p, insn);
-  char t1[40];
+  char t1[40], c[40];
 
   get_temp (t1, p);
 
   llvm_get_dst_int (dest, p, insn, insn->dest_args[0]);
   llvm_get_src_int (src, p, insn, insn->src_args[0]);
 
-  ORC_ASM_CODE (p, "   %s = asr <%d x i16> %s, 8\n", t1, sh, src);
+  get_vector_constant (c, sh, 16, 8);
+
+  ORC_ASM_CODE (p, "   %s = ashr <%d x i16> %s, %s\n", t1, sh, src, c);
   ORC_ASM_CODE (p, "   %s = trunc <%d x i16> %s to <%d x i8>\n", dest, sh, t1, sh);
 
   llvm_store_dst_int (dest, p, insn, insn->dest_args[0]);
@@ -1996,23 +2433,23 @@ llvm_rule_convssswb (OrcCompiler *p, void *user, OrcInstruction *insn)
   llvm_get_src_int (src, p, insn, insn->src_args[0]);
 
   if (sh == 1) {
-    mask1 = "<1 x i16> <i16 127>";
-    mask2 = "<1 x i16> <i16 -128>";
+    mask1 = "<i16 127>";
+    mask2 = "<i16 -128>";
   } else if (sh == 2) {
-    mask1 = "<2 x i16> <i16 127, i16 127>";
-    mask2 = "<2 x i16> <i16 -128, i16 -128>";
+    mask1 = "<i16 127, i16 127>";
+    mask2 = "<i16 -128, i16 -128>";
   } else if (sh == 4) {
-    mask1 = "<4 x i16> <i16 127, i16 127, i16 127, i16 127>";
-    mask2 = "<4 x i16> <i16 -128, i16 -128, i16 -128, i16 -128>";
+    mask1 = "<i16 127, i16 127, i16 127, i16 127>";
+    mask2 = "<i16 -128, i16 -128, i16 -128, i16 -128>";
   } else {
     mask1 = "ERROR";
     mask2 = "ERROR";
   }
 
   ORC_ASM_CODE (p, "   %s = icmp sgt <%d x i16> %s, %s\n", t1, sh, src, mask1);
-  ORC_ASM_CODE (p, "   %s = select <%d x i1> %s, %s, <%d x i16> %s\n", t2, sh, t1, mask1, sh, src);
+  ORC_ASM_CODE (p, "   %s = select <%d x i1> %s, <%d x i16> %s, <%d x i16> %s\n", t2, sh, t1, sh, mask1, sh, src);
   ORC_ASM_CODE (p, "   %s = icmp sle <%d x i16> %s, %s\n", t3, sh, src, mask2);
-  ORC_ASM_CODE (p, "   %s = select <%d x i1> %s, %s, <%d x i16> %s\n", t4, sh, t3, mask2, sh, t2);
+  ORC_ASM_CODE (p, "   %s = select <%d x i1> %s, <%d x i16> %s, <%d x i16> %s\n", t4, sh, t3, sh, mask2, sh, t2);
   ORC_ASM_CODE (p, "   %s = trunc <%d x i16> %s to <%d x i8>\n", dest, sh, t4, sh);
 
   llvm_store_dst_int (dest, p, insn, insn->dest_args[0]);
@@ -2035,22 +2472,22 @@ llvm_rule_convsuswb (OrcCompiler *p, void *user, OrcInstruction *insn)
   llvm_get_src_int (src, p, insn, insn->src_args[0]);
 
   if (sh == 1) {
-    mask1 = "<1 x i16> <i16 255>";
-    mask2 = "<1 x i16> <i16 0>";
+    mask1 = "<i16 255>";
+    mask2 = "<i16 0>";
   } else if (sh == 2) {
-    mask1 = "<2 x i16> <i16 255, i16 255>";
-    mask2 = "<2 x i16> <i16 0, i16 0>";
+    mask1 = "<i16 255, i16 255>";
+    mask2 = "<i16 0, i16 0>";
   } else if (sh == 4) {
-    mask1 = "<4 x i16> <i16 255, i16 255, i16 255, i16 255>";
-    mask2 = "<4 x i16> <i16 0, i16 0, i16 0, i16 0>";
+    mask1 = "<i16 255, i16 255, i16 255, i16 255>";
+    mask2 = "<i16 0, i16 0, i16 0, i16 0>";
   } else {
     mask1 = "ERROR";
     mask2 = "ERROR";
   }
   ORC_ASM_CODE (p, "   %s = icmp sgt <%d x i16> %s, %s\n", t1, sh, src, mask1);
-  ORC_ASM_CODE (p, "   %s = select <%d x i1> %s, %s, <%d x i16> %s\n", t2, sh, t1, mask1, sh, src);
+  ORC_ASM_CODE (p, "   %s = select <%d x i1> %s, <%d x i16> %s, <%d x i16> %s\n", t2, sh, t1, sh, mask1, sh, src);
   ORC_ASM_CODE (p, "   %s = icmp sle <%d x i16> %s, %s\n", t3, sh, src, mask2);
-  ORC_ASM_CODE (p, "   %s = select <%d x i1> %s, %s, <%d x i16> %s\n", t4, sh, t3, mask2, sh, t2);
+  ORC_ASM_CODE (p, "   %s = select <%d x i1> %s, <%d x i16> %s, <%d x i16> %s\n", t4, sh, t3, sh, mask2, sh, t2);
   ORC_ASM_CODE (p, "   %s = trunc <%d x i16> %s to <%d x i8>\n", dest, sh, t4, sh);
 
   llvm_store_dst_int (dest, p, insn, insn->dest_args[0]);
@@ -2090,14 +2527,16 @@ llvm_rule_convhlw (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
   char dest[40], src[40];
   int sh = get_shift (p, insn);
-  char t1[40];
+  char t1[40], c[40];
 
   get_temp (t1, p);
 
   llvm_get_dst_int (dest, p, insn, insn->dest_args[0]);
   llvm_get_src_int (src, p, insn, insn->src_args[0]);
 
-  ORC_ASM_CODE (p, "   %s = asr <%d x i32> %s, 16\n", t1, sh, src);
+  get_vector_constant (c, sh, 32, 16);
+
+  ORC_ASM_CODE (p, "   %s = ashr <%d x i32> %s, %s\n", t1, sh, src, c);
   ORC_ASM_CODE (p, "   %s = trunc <%d x i32> %s to <%d x i16>\n", dest, sh, t1, sh);
 
   llvm_store_dst_int (dest, p, insn, insn->dest_args[0]);
@@ -2114,9 +2553,38 @@ static void
 llvm_rule_convsuslw (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
   char dest[40], src[40];
+  int sh = get_shift (p, insn);
+  char t1[40], t2[40], t3[40], t4[40];
+  const char *mask1, *mask2;
+
+  get_temp (t1, p);
+  get_temp (t2, p);
+  get_temp (t3, p);
+  get_temp (t4, p);
 
   llvm_get_dst_int (dest, p, insn, insn->dest_args[0]);
   llvm_get_src_int (src, p, insn, insn->src_args[0]);
+
+  if (sh == 1) {
+    mask1 = "<i32 65535>";
+    mask2 = "<i32 0>";
+  } else if (sh == 2) {
+    mask1 = "<i32 65535, i32 65535>";
+    mask2 = "<i32 0, i32 0>";
+  } else if (sh == 4) {
+    mask1 = "<i32 65535, i32 65535, i32 65535, i32 65535>";
+    mask2 = "<i32 0, i32 0, i32 0, i32 0>";
+  } else {
+    mask1 = "ERROR";
+    mask2 = "ERROR";
+  }
+  ORC_ASM_CODE (p, "   %s = icmp sgt <%d x i32> %s, %s\n", t1, sh, src, mask1);
+  ORC_ASM_CODE (p, "   %s = select <%d x i1> %s, <%d x i32> %s, <%d x i32> %s\n", t2, sh, t1, sh, mask1, sh, src);
+  ORC_ASM_CODE (p, "   %s = icmp sle <%d x i32> %s, %s\n", t3, sh, src, mask2);
+  ORC_ASM_CODE (p, "   %s = select <%d x i1> %s, <%d x i32> %s, <%d x i32> %s\n", t4, sh, t3, sh, mask2, sh, t2);
+  ORC_ASM_CODE (p, "   %s = trunc <%d x i32> %s to <%d x i16>\n", dest, sh, t4, sh);
+
+  llvm_store_dst_int (dest, p, insn, insn->dest_args[0]);
 }
 static void
 llvm_rule_convusslw (OrcCompiler *p, void *user, OrcInstruction *insn)
@@ -2363,6 +2831,21 @@ get_swap_mask1 (OrcCompiler *p, int sh)
   return mask;
 }
 
+static const char *
+get_swap_mask2 (OrcCompiler *p, int sh)
+{
+  const char *mask;
+
+  if (sh == 1)
+    mask = "<4 x i32> <i32 3, i32 2, i32 1, i32 0>";
+  else if (sh == 2)
+    mask = "<8 x i32> <i32 3, i32 2, i32 1, i32 0, i32 3, i32 2, i32 1, i32 0>";
+  else
+    mask = "ERROR";
+
+  return mask;
+}
+
 static void
 llvm_rule_swapw (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
@@ -2392,9 +2875,25 @@ static void
 llvm_rule_swapl (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
   char dest[40], src[40];
+  int sh = get_shift (p, insn);
+  char t1[40], t2[40];
+  const char *mask;
 
   llvm_get_dst_int (dest, p, insn, insn->dest_args[0]);
   llvm_get_src_int (src, p, insn, insn->src_args[0]);
+  get_temp (t1, p);
+  get_temp (t2, p);
+
+  mask = get_swap_mask2 (p, sh);
+
+  ORC_ASM_CODE (p, "   %s = bitcast <%d x i32> %s to <%d x i8>\n",
+      t1, sh, src, sh * 4);
+  ORC_ASM_CODE (p, "   %s = shufflevector <%d x i8> %s, <%d x i8> %s, %s\n",
+      t2, sh * 4, t1, sh * 4, t1, mask);
+  ORC_ASM_CODE (p, "   %s = bitcast <%d x i8> %s to <%d x i32>\n",
+      dest, sh * 4, t2, sh);
+
+  llvm_store_dst_int (dest, p, insn, insn->dest_args[0]);
 }
 static void
 llvm_rule_swapwl (OrcCompiler *p, void *user, OrcInstruction *insn)
@@ -2472,7 +2971,7 @@ llvm_rule_select0wb (OrcCompiler *p, void *user, OrcInstruction *insn)
 static void
 llvm_rule_select1wb (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
-  char dest[40], src[40];
+  char dest[40], src[40], c[40];
   int sh = get_shift (p, insn);
   char t1[40];
 
@@ -2481,7 +2980,9 @@ llvm_rule_select1wb (OrcCompiler *p, void *user, OrcInstruction *insn)
   llvm_get_dst_int (dest, p, insn, insn->dest_args[0]);
   llvm_get_src_int (src, p, insn, insn->src_args[0]);
 
-  ORC_ASM_CODE (p, "   %s = asr <%d x i16> %s, 8\n", t1, sh, src);
+  get_vector_constant (c, sh, 16, 8);
+
+  ORC_ASM_CODE (p, "   %s = ashr <%d x i16> %s, %s\n", t1, sh, src, c);
   ORC_ASM_CODE (p, "   %s = trunc <%d x i16> %s to <%d x i8>\n",
       dest, sh, t1, sh);
 
@@ -2506,7 +3007,7 @@ llvm_rule_select0lw (OrcCompiler *p, void *user, OrcInstruction *insn)
 static void
 llvm_rule_select1lw (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
-  char dest[40], src[40];
+  char dest[40], src[40], c[40];
   int sh = get_shift (p, insn);
   char t1[40];
 
@@ -2515,7 +3016,9 @@ llvm_rule_select1lw (OrcCompiler *p, void *user, OrcInstruction *insn)
   llvm_get_dst_int (dest, p, insn, insn->dest_args[0]);
   llvm_get_src_int (src, p, insn, insn->src_args[0]);
 
-  ORC_ASM_CODE (p, "   %s = asr <%d x i32> %s, 16\n", t1, sh, src);
+  get_vector_constant (c, sh, 32, 16);
+
+  ORC_ASM_CODE (p, "   %s = ashr <%d x i32> %s, %s\n", t1, sh, src, c);
   ORC_ASM_CODE (p, "   %s = trunc <%d x i32> %s to <%d x i16>\n",
       dest, sh, t1, sh);
 
@@ -2541,7 +3044,7 @@ llvm_rule_select0ql (OrcCompiler *p, void *user, OrcInstruction *insn)
 static void
 llvm_rule_select1ql (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
-  char dest[40], src[40];
+  char dest[40], src[40], c[40];
   int sh = get_shift (p, insn);
   char t1[40];
 
@@ -2549,8 +3052,9 @@ llvm_rule_select1ql (OrcCompiler *p, void *user, OrcInstruction *insn)
 
   llvm_get_dst_int (dest, p, insn, insn->dest_args[0]);
   llvm_get_src_int (src, p, insn, insn->src_args[0]);
+  get_vector_constant (c, sh, 64, 32);
 
-  ORC_ASM_CODE (p, "   %s = asr <%d x i64> %s, 32\n", t1, sh, src);
+  ORC_ASM_CODE (p, "   %s = ashr <%d x i64> %s, %s\n", t1, sh, src, c);
   ORC_ASM_CODE (p, "   %s = trunc <%d x i64> %s to <%d x i32>\n",
       dest, sh, t1, sh);
 
@@ -2611,18 +3115,21 @@ get_split_mask2 (OrcCompiler *p, int sh)
 static void
 llvm_rule_mergelq (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
-  char dest[40], src1[40], src2[40];
+  char dest[40], src1[40], src2[40], t1[40];
   int sh = get_shift (p, insn);
   const char *mask;
 
   llvm_get_dst_int (dest, p, insn, insn->dest_args[0]);
   llvm_get_src_int (src1, p, insn, insn->src_args[0]);
   llvm_get_src_int (src2, p, insn, insn->src_args[1]);
+  get_temp (t1, p);
 
   mask = get_merge_mask (p, sh);
 
   ORC_ASM_CODE (p, "   %s = shufflevector <%d x i32> %s, <%d x i32> %s, %s\n",
-      dest, sh, src1, sh, src2, mask);
+      t1, sh, src1, sh, src2, mask);
+  ORC_ASM_CODE (p, "   %s = bitcast <%d x i32> %s to <%d x i64>\n",
+      dest, sh * 2, t1, sh);
 
   llvm_store_dst_int (dest, p, insn, insn->dest_args[0]);
 }
@@ -2630,18 +3137,21 @@ llvm_rule_mergelq (OrcCompiler *p, void *user, OrcInstruction *insn)
 static void
 llvm_rule_mergewl (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
-  char dest[40], src1[40], src2[40];
+  char dest[40], src1[40], src2[40], t1[40];
   int sh = get_shift (p, insn);
   const char *mask;
 
   llvm_get_dst_int (dest, p, insn, insn->dest_args[0]);
   llvm_get_src_int (src1, p, insn, insn->src_args[0]);
   llvm_get_src_int (src2, p, insn, insn->src_args[1]);
+  get_temp (t1, p);
 
   mask = get_merge_mask (p, sh);
 
   ORC_ASM_CODE (p, "   %s = shufflevector <%d x i16> %s, <%d x i16> %s, %s\n",
-      dest, sh, src1, sh, src2, mask);
+      t1, sh, src1, sh, src2, mask);
+  ORC_ASM_CODE (p, "   %s = bitcast <%d x i16> %s to <%d x i32>\n",
+      dest, sh * 2, t1, sh);
 
   llvm_store_dst_int (dest, p, insn, insn->dest_args[0]);
 }
@@ -2649,18 +3159,21 @@ llvm_rule_mergewl (OrcCompiler *p, void *user, OrcInstruction *insn)
 static void
 llvm_rule_mergebw (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
-  char dest[40], src1[40], src2[40];
+  char dest[40], src1[40], src2[40], t1[40];
   int sh = get_shift (p, insn);
   const char *mask;
 
   llvm_get_dst_int (dest, p, insn, insn->dest_args[0]);
   llvm_get_src_int (src1, p, insn, insn->src_args[0]);
   llvm_get_src_int (src2, p, insn, insn->src_args[1]);
+  get_temp (t1, p);
 
   mask = get_merge_mask (p, sh);
 
   ORC_ASM_CODE (p, "   %s = shufflevector <%d x i8> %s, <%d x i8> %s, %s\n",
-      dest, sh, src1, sh, src2, mask);
+      t1, sh, src1, sh, src2, mask);
+  ORC_ASM_CODE (p, "   %s = bitcast <%d x i8> %s to <%d x i16>\n",
+      dest, sh * 2, t1, sh);
 
   llvm_store_dst_int (dest, p, insn, insn->dest_args[0]);
 }
diff --git a/tools/orcc.c b/tools/orcc.c
index e29adb1..c5dda8d 100644
--- a/tools/orcc.c
+++ b/tools/orcc.c
@@ -23,7 +23,7 @@ void output_code_execute (OrcProgram *p, FILE *output, int is_inline);
 void output_program_generation (OrcProgram *p, FILE *output, int is_inline);
 void output_init_function (FILE *output);
 static char * get_barrier (const char *s);
-static const char * my_basename (const char *s);
+//static const char * my_basename (const char *s);
 
 int verbose = 0;
 int error = 0;
@@ -263,7 +263,7 @@ main (int argc, char *argv[])
   }
 
   fprintf(output, "\n");
-  fprintf(output, "/* autogenerated from %s */\n", my_basename(input_file));
+  //fprintf(output, "/* autogenerated from %s */\n", my_basename(input_file));
   fprintf(output, "\n");
 
   if (mode == MODE_IMPL) {
@@ -1464,7 +1464,7 @@ void
 output_code_assembly (OrcProgram *p, FILE *output)
 {
 
-  fprintf(output, "/* %s */\n", p->name);
+//  fprintf(output, "/* %s */\n", p->name);
   /* output_prototype (p, output); */
   {
     OrcCompileResult result;
@@ -1483,6 +1483,7 @@ output_code_assembly (OrcProgram *p, FILE *output)
 
 }
 
+/*
 static const char *
 my_basename (const char *s)
 {
@@ -1497,4 +1498,5 @@ my_basename (const char *s)
 
   return ret;
 }
+*/