From 3c6ba978b943362500014bce213d1db3899175ef Mon Sep 17 00:00:00 2001
From: David Schleef <ds@schleef.org>
Date: Sun, 17 May 2009 12:26:04 -0700
Subject: [PATCH] neon: add orc_ prefix to all functions

---
 orc/arm.c             | 142 +++++++++---------
 orc/arm.h             |  58 ++++----
 orc/neon.h            |  26 ++--
 orc/orcprogram-arm.c  |  84 +++++------
 orc/orcprogram-neon.c | 238 +++++++++++++++---------------
 orc/orcrules-arm.c    | 102 ++++++-------
 orc/orcrules-neon.c   | 400 +++++++++++++++++++++++++-------------------------
 7 files changed, 525 insertions(+), 525 deletions(-)

diff --git a/orc/arm.c b/orc/arm.c
index 399da22..cc5a885 100644
--- a/orc/arm.c
+++ b/orc/arm.c
@@ -17,7 +17,7 @@
 
 
 const char *
-arm_reg_name (int reg)
+orc_arm_reg_name (int reg)
 {
 #if 0
   static const char *gp_regs[] = {
@@ -42,21 +42,21 @@ arm_reg_name (int reg)
 }
 
 void
-arm_emit (OrcCompiler *compiler, uint32_t insn)
+orc_arm_emit (OrcCompiler *compiler, uint32_t insn)
 {
   ORC_WRITE_UINT32_LE (compiler->codeptr, insn);
   compiler->codeptr+=4;
 }
 
 void
-arm_emit_bx_lr (OrcCompiler *compiler)
+orc_arm_emit_bx_lr (OrcCompiler *compiler)
 {
   ORC_ASM_CODE(compiler,"  bx lr\n");
-  arm_emit (compiler, 0xe12fff1e);
+  orc_arm_emit (compiler, 0xe12fff1e);
 }
 
 void
-arm_emit_push (OrcCompiler *compiler, int regs)
+orc_arm_emit_push (OrcCompiler *compiler, int regs)
 {
   int i;
   int x = 0;
@@ -73,11 +73,11 @@ arm_emit_push (OrcCompiler *compiler, int regs)
   }
   ORC_ASM_CODE(compiler,"}\n");
 
-  arm_emit (compiler, 0xe92d0000 | regs);
+  orc_arm_emit (compiler, 0xe92d0000 | regs);
 }
 
 void
-arm_emit_pop (OrcCompiler *compiler, int regs)
+orc_arm_emit_pop (OrcCompiler *compiler, int regs)
 {
   int i;
   int x = 0;
@@ -94,11 +94,11 @@ arm_emit_pop (OrcCompiler *compiler, int regs)
   }
   ORC_ASM_CODE(compiler,"}\n");
 
-  arm_emit (compiler, 0xe8bd0000 | regs);
+  orc_arm_emit (compiler, 0xe8bd0000 | regs);
 }
 
 void
-arm_emit_mov (OrcCompiler *compiler, int dest, int src)
+orc_arm_emit_mov (OrcCompiler *compiler, int dest, int src)
 {
   uint32_t code;
 
@@ -106,13 +106,13 @@ arm_emit_mov (OrcCompiler *compiler, int dest, int src)
   code |= (src&0xf) << 0;
   code |= (dest&0xf) << 12;
 
-  ORC_ASM_CODE(compiler,"  mov %s, %s\n", arm_reg_name (dest), arm_reg_name (src));
+  ORC_ASM_CODE(compiler,"  mov %s, %s\n", orc_arm_reg_name (dest), orc_arm_reg_name (src));
 
-  arm_emit (compiler, code);
+  orc_arm_emit (compiler, code);
 }
 
 void
-arm_emit_label (OrcCompiler *compiler, int label)
+orc_arm_emit_label (OrcCompiler *compiler, int label)
 {
   ORC_ASM_CODE(compiler,".L%d:\n", label);
 
@@ -120,7 +120,7 @@ arm_emit_label (OrcCompiler *compiler, int label)
 }
 
 void
-arm_add_fixup (OrcCompiler *compiler, int label, int type)
+orc_arm_add_fixup (OrcCompiler *compiler, int label, int type)
 {
   compiler->fixups[compiler->n_fixups].ptr = compiler->codeptr;
   compiler->fixups[compiler->n_fixups].label = label;
@@ -129,7 +129,7 @@ arm_add_fixup (OrcCompiler *compiler, int label, int type)
 }
 
 void
-arm_do_fixups (OrcCompiler *compiler)
+orc_arm_do_fixups (OrcCompiler *compiler)
 {
   int i;
   for(i=0;i<compiler->n_fixups;i++){
@@ -146,7 +146,7 @@ arm_do_fixups (OrcCompiler *compiler)
 }
 
 void
-arm_emit_branch (OrcCompiler *compiler, int cond, int label)
+orc_arm_emit_branch (OrcCompiler *compiler, int cond, int label)
 {
   static const char *cond_names[] = {
     "eq", "ne", "cs", "cc", "mi", "pl", "vs", "vc",
@@ -155,14 +155,14 @@ arm_emit_branch (OrcCompiler *compiler, int cond, int label)
 
   code = 0x0afffffe;
   code |= (cond&0xf) << 28;
-  arm_add_fixup (compiler, label, 0);
-  arm_emit (compiler, code);
+  orc_arm_add_fixup (compiler, label, 0);
+  orc_arm_emit (compiler, code);
 
   ORC_ASM_CODE(compiler,"  b%s .L%d\n", cond_names[cond], label);
 }
 
 void
-arm_emit_load_imm (OrcCompiler *compiler, int dest, int imm)
+orc_arm_emit_load_imm (OrcCompiler *compiler, int dest, int imm)
 {
   uint32_t code;
   int shift2;
@@ -188,12 +188,12 @@ arm_emit_load_imm (OrcCompiler *compiler, int dest, int imm)
   code |= (((16-shift2)&0xf) << 8);
   code |= (x&0xff);
 
-  ORC_ASM_CODE(compiler,"  mov %s, #0x%08x\n", arm_reg_name (dest), imm);
-  arm_emit (compiler, code);
+  ORC_ASM_CODE(compiler,"  mov %s, #0x%08x\n", orc_arm_reg_name (dest), imm);
+  orc_arm_emit (compiler, code);
 }
 
 void
-arm_emit_add (OrcCompiler *compiler, int dest, int src1, int src2)
+orc_arm_emit_add (OrcCompiler *compiler, int dest, int src1, int src2)
 {
   uint32_t code;
 
@@ -203,14 +203,14 @@ arm_emit_add (OrcCompiler *compiler, int dest, int src1, int src2)
   code |= (src2&0xf) << 0;
 
   ORC_ASM_CODE(compiler,"  add %s, %s, %s\n",
-      arm_reg_name (dest),
-      arm_reg_name (src1),
-      arm_reg_name (src2));
-  arm_emit (compiler, code);
+      orc_arm_reg_name (dest),
+      orc_arm_reg_name (src1),
+      orc_arm_reg_name (src2));
+  orc_arm_emit (compiler, code);
 }
 
 void
-arm_emit_sub (OrcCompiler *compiler, int dest, int src1, int src2)
+orc_arm_emit_sub (OrcCompiler *compiler, int dest, int src1, int src2)
 {
   uint32_t code;
 
@@ -220,14 +220,14 @@ arm_emit_sub (OrcCompiler *compiler, int dest, int src1, int src2)
   code |= (src2&0xf) << 0;
 
   ORC_ASM_CODE(compiler,"  sub %s, %s, %s\n",
-      arm_reg_name (dest),
-      arm_reg_name (src1),
-      arm_reg_name (src2));
-  arm_emit (compiler, code);
+      orc_arm_reg_name (dest),
+      orc_arm_reg_name (src1),
+      orc_arm_reg_name (src2));
+  orc_arm_emit (compiler, code);
 }
 
 void
-arm_emit_add_imm (OrcCompiler *compiler, int dest, int src1, int imm)
+orc_arm_emit_add_imm (OrcCompiler *compiler, int dest, int src1, int imm)
 {
 #if 0
   uint32_t code;
@@ -238,10 +238,10 @@ arm_emit_add_imm (OrcCompiler *compiler, int dest, int src1, int imm)
   code |= (value) << 0;
 
   ORC_ASM_CODE(compiler,"  add %s, %s, #%d\n",
-      arm_reg_name (dest),
-      arm_reg_name (src1),
+      orc_arm_reg_name (dest),
+      orc_arm_reg_name (src1),
       value);
-  arm_emit (compiler, code);
+  orc_arm_emit (compiler, code);
 #endif
   uint32_t code;
   int shift2;
@@ -268,13 +268,13 @@ arm_emit_add_imm (OrcCompiler *compiler, int dest, int src1, int imm)
   code |= (((16-shift2)&0xf) << 8);
   code |= (x&0xff);
 
-  ORC_ASM_CODE(compiler,"  add %s, %s, #0x%08x\n", arm_reg_name (dest),
-      arm_reg_name(src1), imm);
-  arm_emit (compiler, code);
+  ORC_ASM_CODE(compiler,"  add %s, %s, #0x%08x\n", orc_arm_reg_name (dest),
+      orc_arm_reg_name(src1), imm);
+  orc_arm_emit (compiler, code);
 }
 
 void
-arm_emit_and_imm (OrcCompiler *compiler, int dest, int src1, int value)
+orc_arm_emit_and_imm (OrcCompiler *compiler, int dest, int src1, int value)
 {
   uint32_t code;
 
@@ -284,14 +284,14 @@ arm_emit_and_imm (OrcCompiler *compiler, int dest, int src1, int value)
   code |= (value) << 0;
 
   ORC_ASM_CODE(compiler,"  and %s, %s, #%d\n",
-      arm_reg_name (dest),
-      arm_reg_name (src1),
+      orc_arm_reg_name (dest),
+      orc_arm_reg_name (src1),
       value);
-  arm_emit (compiler, code);
+  orc_arm_emit (compiler, code);
 }
 
 void
-arm_emit_sub_imm (OrcCompiler *compiler, int dest, int src1, int value)
+orc_arm_emit_sub_imm (OrcCompiler *compiler, int dest, int src1, int value)
 {
   uint32_t code;
 
@@ -301,14 +301,14 @@ arm_emit_sub_imm (OrcCompiler *compiler, int dest, int src1, int value)
   code |= (value) << 0;
 
   ORC_ASM_CODE(compiler,"  subs %s, %s, #%d\n",
-      arm_reg_name (dest),
-      arm_reg_name (src1),
+      orc_arm_reg_name (dest),
+      orc_arm_reg_name (src1),
       value);
-  arm_emit (compiler, code);
+  orc_arm_emit (compiler, code);
 }
 
 void
-arm_emit_cmp_imm (OrcCompiler *compiler, int src1, int value)
+orc_arm_emit_cmp_imm (OrcCompiler *compiler, int src1, int value)
 {
   uint32_t code;
 
@@ -317,13 +317,13 @@ arm_emit_cmp_imm (OrcCompiler *compiler, int src1, int value)
   code |= (value) << 0;
 
   ORC_ASM_CODE(compiler,"  cmp %s, #%d\n",
-      arm_reg_name (src1),
+      orc_arm_reg_name (src1),
       value);
-  arm_emit (compiler, code);
+  orc_arm_emit (compiler, code);
 }
 
 void
-arm_emit_cmp (OrcCompiler *compiler, int src1, int src2)
+orc_arm_emit_cmp (OrcCompiler *compiler, int src1, int src2)
 {
   uint32_t code;
 
@@ -332,13 +332,13 @@ arm_emit_cmp (OrcCompiler *compiler, int src1, int src2)
   code |= (src2&0xf) << 0;
 
   ORC_ASM_CODE(compiler,"  cmp %s, %s\n",
-      arm_reg_name (src1),
-      arm_reg_name (src2));
-  arm_emit (compiler, code);
+      orc_arm_reg_name (src1),
+      orc_arm_reg_name (src2));
+  orc_arm_emit (compiler, code);
 }
 
 void
-arm_emit_asr_imm (OrcCompiler *compiler, int dest, int src1, int value)
+orc_arm_emit_asr_imm (OrcCompiler *compiler, int dest, int src1, int value)
 {
   uint32_t code;
 
@@ -351,14 +351,14 @@ arm_emit_asr_imm (OrcCompiler *compiler, int dest, int src1, int value)
   code |= (value) << 7;
 
   ORC_ASM_CODE(compiler,"  asr %s, %s, #%d\n",
-      arm_reg_name (dest),
-      arm_reg_name (src1),
+      orc_arm_reg_name (dest),
+      orc_arm_reg_name (src1),
       value);
-  arm_emit (compiler, code);
+  orc_arm_emit (compiler, code);
 }
 
 void
-arm_emit_load_reg (OrcCompiler *compiler, int dest, int src1, int offset)
+orc_arm_emit_load_reg (OrcCompiler *compiler, int dest, int src1, int offset)
 {
   uint32_t code;
 
@@ -368,13 +368,13 @@ arm_emit_load_reg (OrcCompiler *compiler, int dest, int src1, int offset)
   code |= offset&0xfff;
 
   ORC_ASM_CODE(compiler,"  ldr %s, [%s, #%d]\n",
-      arm_reg_name (dest),
-      arm_reg_name (src1), offset);
-  arm_emit (compiler, code);
+      orc_arm_reg_name (dest),
+      orc_arm_reg_name (src1), offset);
+  orc_arm_emit (compiler, code);
 }
 
 void
-arm_emit_store_reg (OrcCompiler *compiler, int src1, int dest, int offset)
+orc_arm_emit_store_reg (OrcCompiler *compiler, int src1, int dest, int offset)
 {
   uint32_t code;
 
@@ -384,14 +384,14 @@ arm_emit_store_reg (OrcCompiler *compiler, int src1, int dest, int offset)
   code |= offset&0xfff;
 
   ORC_ASM_CODE(compiler,"  str %s, [%s, #%d]\n",
-      arm_reg_name (src1),
-      arm_reg_name (dest), offset);
-  arm_emit (compiler, code);
+      orc_arm_reg_name (src1),
+      orc_arm_reg_name (dest), offset);
+  orc_arm_emit (compiler, code);
 }
 
 
 void
-arm_emit_dp_reg (OrcCompiler *compiler, int cond, int opcode, int dest,
+orc_arm_emit_dp_reg (OrcCompiler *compiler, int cond, int opcode, int dest,
     int src1, int src2)
 {
   static const char *dp_insn_names[] = {
@@ -419,16 +419,16 @@ arm_emit_dp_reg (OrcCompiler *compiler, int cond, int opcode, int dest,
     ORC_ASM_CODE(compiler,"  %s%s %s, %s\n",
         dp_insn_names[opcode],
         update ? "s" : "",
-        arm_reg_name (src1),
-        arm_reg_name (src2));
+        orc_arm_reg_name (src1),
+        orc_arm_reg_name (src2));
   } else {
     ORC_ASM_CODE(compiler,"  %s%s %s, %s, %s\n",
         dp_insn_names[opcode],
         update ? "s" : "",
-        arm_reg_name (dest),
-        arm_reg_name (src1),
-        arm_reg_name (src2));
+        orc_arm_reg_name (dest),
+        orc_arm_reg_name (src1),
+        orc_arm_reg_name (src2));
   }
-  arm_emit (compiler, code);
+  orc_arm_emit (compiler, code);
 }
 
diff --git a/orc/arm.h b/orc/arm.h
index 662ae04..726b9ac 100644
--- a/orc/arm.h
+++ b/orc/arm.h
@@ -62,40 +62,40 @@ enum {
   ARM_COND_AL,
 };
 
-void arm_emit (OrcCompiler *compiler, uint32_t insn);
-void arm_emit_bx_lr (OrcCompiler *compiler);
-const char * arm_reg_name (int reg);
-void arm_emit_load_imm (OrcCompiler *compiler, int dest, int imm);
-
-void arm_emit_add (OrcCompiler *compiler, int dest, int src1, int src2);
-void arm_emit_sub (OrcCompiler *compiler, int dest, int src1, int src2);
-void arm_emit_add_imm (OrcCompiler *compiler, int dest, int src1, int value);
-void arm_emit_and_imm (OrcCompiler *compiler, int dest, int src1, int value);
-void arm_emit_sub_imm (OrcCompiler *compiler, int dest, int src1, int value);
-void arm_emit_asr_imm (OrcCompiler *compiler, int dest, int src1, int value);
-void arm_emit_cmp_imm (OrcCompiler *compiler, int src1, int value);
-void arm_emit_cmp (OrcCompiler *compiler, int src1, int src2);
-
-void arm_emit_label (OrcCompiler *compiler, int label);
-void arm_emit_push (OrcCompiler *compiler, int regs);
-void arm_emit_pop (OrcCompiler *compiler, int regs);
-void arm_emit_mov (OrcCompiler *compiler, int dest, int src);
-void arm_emit_branch (OrcCompiler *compiler, int cond, int label);
-
-void arm_emit_dp_reg (OrcCompiler *compiler, int cond, int opcode, int dest,
+void orc_arm_emit (OrcCompiler *compiler, uint32_t insn);
+void orc_arm_emit_bx_lr (OrcCompiler *compiler);
+const char * orc_arm_reg_name (int reg);
+void orc_arm_emit_load_imm (OrcCompiler *compiler, int dest, int imm);
+
+void orc_arm_emit_add (OrcCompiler *compiler, int dest, int src1, int src2);
+void orc_arm_emit_sub (OrcCompiler *compiler, int dest, int src1, int src2);
+void orc_arm_emit_add_imm (OrcCompiler *compiler, int dest, int src1, int value);
+void orc_arm_emit_and_imm (OrcCompiler *compiler, int dest, int src1, int value);
+void orc_arm_emit_sub_imm (OrcCompiler *compiler, int dest, int src1, int value);
+void orc_arm_emit_asr_imm (OrcCompiler *compiler, int dest, int src1, int value);
+void orc_arm_emit_cmp_imm (OrcCompiler *compiler, int src1, int value);
+void orc_arm_emit_cmp (OrcCompiler *compiler, int src1, int src2);
+
+void orc_arm_emit_label (OrcCompiler *compiler, int label);
+void orc_arm_emit_push (OrcCompiler *compiler, int regs);
+void orc_arm_emit_pop (OrcCompiler *compiler, int regs);
+void orc_arm_emit_mov (OrcCompiler *compiler, int dest, int src);
+void orc_arm_emit_branch (OrcCompiler *compiler, int cond, int label);
+
+void orc_arm_emit_dp_reg (OrcCompiler *compiler, int cond, int opcode, int dest,
     int src1, int src2);
 
-void arm_loadw (OrcCompiler *compiler, int dest, int src1, int offset);
-void arm_storew (OrcCompiler *compiler, int dest, int offset, int src1);
+void orc_arm_loadw (OrcCompiler *compiler, int dest, int src1, int offset);
+void orc_arm_storew (OrcCompiler *compiler, int dest, int offset, int src1);
 
-void arm_emit_load_reg (OrcCompiler *compiler, int dest, int src1, int offset);
-void arm_emit_store_reg (OrcCompiler *compiler, int src, int dest, int offset);
+void orc_arm_emit_load_reg (OrcCompiler *compiler, int dest, int src1, int offset);
+void orc_arm_emit_store_reg (OrcCompiler *compiler, int src, int dest, int offset);
 
-void arm_do_fixups (OrcCompiler *compiler);
+void orc_arm_do_fixups (OrcCompiler *compiler);
 
-const char *neon_reg_name (int reg);
-const char *neon_reg_name_quad (int reg);
-void neon_emit_mov (OrcCompiler *compiler, int src, int dest);
+const char *orc_neon_reg_name (int reg);
+const char *orc_neon_reg_name_quad (int reg);
+void orc_neon_emit_mov (OrcCompiler *compiler, int src, int dest);
 
 #endif
 
diff --git a/orc/neon.h b/orc/neon.h
index 0385481..e44d30e 100644
--- a/orc/neon.h
+++ b/orc/neon.h
@@ -5,19 +5,19 @@
 #include <orc/orc.h>
 #include <orc/arm.h>
 
-void neon_loadb (OrcCompiler *compiler, int dest, int src1, int update, int is_aligned);
-void neon_loadw (OrcCompiler *compiler, int dest, int src1, int update, int is_aligned);
-void neon_loadl (OrcCompiler *compiler, int dest, int src1, int update, int is_aligned);
-void neon_neg (OrcCompiler *compiler, int dest);
-void neon_storeb (OrcCompiler *compiler, int dest, int update, int src1, int is_aligned);
-void neon_storew (OrcCompiler *compiler, int dest, int update, int src1, int is_aligned);
-void neon_storel (OrcCompiler *compiler, int dest, int update, int src1, int is_aligned);
-void neon_emit_loadib (OrcCompiler *p, int reg, int value);
-void neon_emit_loadiw (OrcCompiler *p, int reg, int value);
-void neon_emit_loadil (OrcCompiler *p, int reg, int value);
-void neon_emit_loadpb (OrcCompiler *p, int reg, int param);
-void neon_emit_loadpw (OrcCompiler *p, int reg, int param);
-void neon_emit_loadpl (OrcCompiler *p, int reg, int param);
+void orc_neon_loadb (OrcCompiler *compiler, int dest, int src1, int update, int is_aligned);
+void orc_neon_loadw (OrcCompiler *compiler, int dest, int src1, int update, int is_aligned);
+void orc_neon_loadl (OrcCompiler *compiler, int dest, int src1, int update, int is_aligned);
+void orc_neon_neg (OrcCompiler *compiler, int dest);
+void orc_neon_storeb (OrcCompiler *compiler, int dest, int update, int src1, int is_aligned);
+void orc_neon_storew (OrcCompiler *compiler, int dest, int update, int src1, int is_aligned);
+void orc_neon_storel (OrcCompiler *compiler, int dest, int update, int src1, int is_aligned);
+void orc_neon_emit_loadib (OrcCompiler *p, int reg, int value);
+void orc_neon_emit_loadiw (OrcCompiler *p, int reg, int value);
+void orc_neon_emit_loadil (OrcCompiler *p, int reg, int value);
+void orc_neon_emit_loadpb (OrcCompiler *p, int reg, int param);
+void orc_neon_emit_loadpw (OrcCompiler *p, int reg, int param);
+void orc_neon_emit_loadpl (OrcCompiler *p, int reg, int param);
 
 
 #endif
diff --git a/orc/orcprogram-arm.c b/orc/orcprogram-arm.c
index a2d1af0..8e8b82e 100644
--- a/orc/orcprogram-arm.c
+++ b/orc/orcprogram-arm.c
@@ -17,7 +17,7 @@
 
 int arm_exec_ptr = ARM_R0;
 
-void arm_emit_loop (OrcCompiler *compiler);
+void orc_arm_emit_loop (OrcCompiler *compiler);
 
 void orc_compiler_arm_register_rules (OrcTarget *target);
 
@@ -29,7 +29,7 @@ void orc_compiler_rewrite_vars (OrcCompiler *compiler);
 void orc_compiler_dump (OrcCompiler *compiler);
 
 void
-arm_emit_prologue (OrcCompiler *compiler)
+orc_arm_emit_prologue (OrcCompiler *compiler)
 {
   unsigned int regs = 0;
   int i;
@@ -43,31 +43,31 @@ arm_emit_prologue (OrcCompiler *compiler)
       regs |= (1<<i);
     }
   }
-  if (regs) arm_emit_push (compiler, regs);
+  if (regs) orc_arm_emit_push (compiler, regs);
 
 }
 
 void
-arm_dump_insns (OrcCompiler *compiler)
+orc_arm_dump_insns (OrcCompiler *compiler)
 {
 
-  arm_emit_label (compiler, 0);
+  orc_arm_emit_label (compiler, 0);
 
-  arm_emit_add (compiler, ARM_A2, ARM_A3, ARM_A4);
-  arm_emit_sub (compiler, ARM_A2, ARM_A3, ARM_A4);
-  arm_emit_push (compiler, 0x06);
-  arm_emit_mov (compiler, ARM_A2, ARM_A3);
+  orc_arm_emit_add (compiler, ARM_A2, ARM_A3, ARM_A4);
+  orc_arm_emit_sub (compiler, ARM_A2, ARM_A3, ARM_A4);
+  orc_arm_emit_push (compiler, 0x06);
+  orc_arm_emit_mov (compiler, ARM_A2, ARM_A3);
 
-  arm_emit_branch (compiler, ARM_COND_LE, 0);
-  arm_emit_branch (compiler, ARM_COND_AL, 0);
+  orc_arm_emit_branch (compiler, ARM_COND_LE, 0);
+  orc_arm_emit_branch (compiler, ARM_COND_AL, 0);
 
-  arm_emit_load_imm (compiler, ARM_A3, 0xa500);
-  arm_loadw (compiler, ARM_A3, ARM_A4, 0xa5);
-  arm_emit_load_reg (compiler, ARM_A3, ARM_A4, 0x5a5);
+  orc_arm_emit_load_imm (compiler, ARM_A3, 0xa500);
+  orc_arm_loadw (compiler, ARM_A3, ARM_A4, 0xa5);
+  orc_arm_emit_load_reg (compiler, ARM_A3, ARM_A4, 0x5a5);
 }
 
 void
-arm_emit_epilogue (OrcCompiler *compiler)
+orc_arm_emit_epilogue (OrcCompiler *compiler)
 {
   int i;
   unsigned int regs = 0;
@@ -78,8 +78,8 @@ arm_emit_epilogue (OrcCompiler *compiler)
       regs |= (1<<i);
     }
   }
-  if (regs) arm_emit_pop (compiler, regs);
-  arm_emit_bx_lr (compiler);
+  if (regs) orc_arm_emit_pop (compiler, regs);
+  orc_arm_emit_bx_lr (compiler);
 
   //arm_dump_insns (compiler);
 }
@@ -138,7 +138,7 @@ orc_compiler_arm_init (OrcCompiler *compiler)
 }
 
 void
-arm_load_constants (OrcCompiler *compiler)
+orc_arm_load_constants (OrcCompiler *compiler)
 {
   int i;
   for(i=0;i<ORC_N_VARIABLES;i++){
@@ -154,7 +154,7 @@ arm_load_constants (OrcCompiler *compiler)
         break;
       case ORC_VAR_TYPE_SRC:
       case ORC_VAR_TYPE_DEST:
-        arm_emit_load_reg (compiler, 
+        orc_arm_emit_load_reg (compiler, 
             compiler->vars[i].ptr_register,
             arm_exec_ptr, ORC_STRUCT_OFFSET(OrcExecutor, arrays[i]));
         break;
@@ -165,7 +165,7 @@ arm_load_constants (OrcCompiler *compiler)
 }
 
 void
-arm_emit_load_src (OrcCompiler *compiler, OrcVariable *var)
+orc_arm_emit_load_src (OrcCompiler *compiler, OrcVariable *var)
 {
   int ptr_reg;
   if (var->ptr_register == 0) {
@@ -184,7 +184,7 @@ arm_emit_load_src (OrcCompiler *compiler, OrcVariable *var)
       //arm_emit_mov_reg_arm (compiler, X86_ECX, var->alloc);
       break;
     case 2:
-      arm_loadw (compiler, var->alloc, ptr_reg, 0);
+      orc_arm_loadw (compiler, var->alloc, ptr_reg, 0);
       //arm_emit_mov_memoffset_reg (compiler, 2, 0, ptr_reg, X86_ECX);
       //arm_emit_mov_reg_arm (compiler, X86_ECX, var->alloc);
       break;
@@ -203,7 +203,7 @@ arm_emit_load_src (OrcCompiler *compiler, OrcVariable *var)
 }
 
 void
-arm_emit_store_dest (OrcCompiler *compiler, OrcVariable *var)
+orc_arm_emit_store_dest (OrcCompiler *compiler, OrcVariable *var)
 {
   int ptr_reg;
   if (var->ptr_register == 0) {
@@ -219,7 +219,7 @@ arm_emit_store_dest (OrcCompiler *compiler, OrcVariable *var)
       //arm_emit_mov_reg_memoffset (compiler, 1, X86_ECX, 0, ptr_reg);
       break;
     case 2:
-      arm_storew (compiler, ptr_reg, 0, var->alloc);
+      orc_arm_storew (compiler, ptr_reg, 0, var->alloc);
       //arm_emit_mov_arm_reg (compiler, var->alloc, X86_ECX);
       //arm_emit_mov_reg_memoffset (compiler, 2, X86_ECX, 0, ptr_reg);
       break;
@@ -247,31 +247,31 @@ orc_compiler_arm_assemble (OrcCompiler *compiler)
 
   compiler->vars[dest_var].is_aligned = FALSE;
 
-  arm_emit_prologue (compiler);
+  orc_arm_emit_prologue (compiler);
 
-  arm_emit_load_reg (compiler, ARM_IP, arm_exec_ptr,
+  orc_arm_emit_load_reg (compiler, ARM_IP, arm_exec_ptr,
       (int)ORC_STRUCT_OFFSET(OrcExecutor,n));
-  arm_load_constants (compiler);
+  orc_arm_load_constants (compiler);
 
-  arm_emit_label (compiler, 1);
+  orc_arm_emit_label (compiler, 1);
 
-  arm_emit_cmp_imm (compiler, ARM_IP, 0);
-  arm_emit_branch (compiler, ARM_COND_EQ, 3);
+  orc_arm_emit_cmp_imm (compiler, ARM_IP, 0);
+  orc_arm_emit_branch (compiler, ARM_COND_EQ, 3);
 
-  arm_emit_label (compiler, 2);
-  arm_emit_loop (compiler);
-  arm_emit_sub_imm (compiler, ARM_IP, ARM_IP, 1);
-  arm_emit_cmp_imm (compiler, ARM_IP, 0);
-  arm_emit_branch (compiler, ARM_COND_NE, 2);
-  arm_emit_label (compiler, 3);
+  orc_arm_emit_label (compiler, 2);
+  orc_arm_emit_loop (compiler);
+  orc_arm_emit_sub_imm (compiler, ARM_IP, ARM_IP, 1);
+  orc_arm_emit_cmp_imm (compiler, ARM_IP, 0);
+  orc_arm_emit_branch (compiler, ARM_COND_NE, 2);
+  orc_arm_emit_label (compiler, 3);
 
-  arm_emit_epilogue (compiler);
+  orc_arm_emit_epilogue (compiler);
 
-  arm_do_fixups (compiler);
+  orc_arm_do_fixups (compiler);
 }
 
 void
-arm_emit_loop (OrcCompiler *compiler)
+orc_arm_emit_loop (OrcCompiler *compiler)
 {
   int j;
   int k;
@@ -302,7 +302,7 @@ arm_emit_loop (OrcCompiler *compiler)
 
       switch (compiler->vars[insn->src_args[k]].vartype) {
         case ORC_VAR_TYPE_SRC:
-          arm_emit_load_src (compiler, &compiler->vars[insn->src_args[k]]);
+          orc_arm_emit_load_src (compiler, &compiler->vars[insn->src_args[k]]);
           break;
         case ORC_VAR_TYPE_CONST:
           break;
@@ -319,7 +319,7 @@ arm_emit_loop (OrcCompiler *compiler)
     if (rule && rule->emit) {
       if (compiler->vars[insn->dest_args[0]].alloc !=
           compiler->vars[insn->src_args[0]].alloc) {
-        arm_emit_mov (compiler, compiler->vars[insn->src_args[0]].alloc,
+        orc_arm_emit_mov (compiler, compiler->vars[insn->src_args[0]].alloc,
             compiler->vars[insn->dest_args[0]].alloc);
       }
       rule->emit (compiler, rule->emit_user, insn);
@@ -332,7 +332,7 @@ arm_emit_loop (OrcCompiler *compiler)
 
       switch (compiler->vars[insn->dest_args[k]].vartype) {
         case ORC_VAR_TYPE_DEST:
-          arm_emit_store_dest (compiler, &compiler->vars[insn->dest_args[k]]);
+          orc_arm_emit_store_dest (compiler, &compiler->vars[insn->dest_args[k]]);
           break;
         case ORC_VAR_TYPE_TEMP:
           break;
@@ -347,7 +347,7 @@ arm_emit_loop (OrcCompiler *compiler)
     if (compiler->vars[k].vartype == ORC_VAR_TYPE_SRC ||
         compiler->vars[k].vartype == ORC_VAR_TYPE_DEST) {
       if (compiler->vars[k].ptr_register) {
-        arm_emit_add_imm (compiler,
+        orc_arm_emit_add_imm (compiler,
             compiler->vars[k].ptr_register,
             compiler->vars[k].ptr_register,
             compiler->vars[k].size << compiler->loop_shift);
diff --git a/orc/orcprogram-neon.c b/orc/orcprogram-neon.c
index 8b7f178..9b6a48d 100644
--- a/orc/orcprogram-neon.c
+++ b/orc/orcprogram-neon.c
@@ -20,7 +20,7 @@
 int neon_exec_ptr = ARM_R0;
 int neon_tmp_reg = ARM_A2;
 
-void neon_emit_loop (OrcCompiler *compiler);
+void orc_neon_emit_loop (OrcCompiler *compiler);
 
 void orc_compiler_neon_register_rules (OrcTarget *target);
 
@@ -29,11 +29,11 @@ void orc_compiler_neon_assemble (OrcCompiler *compiler);
 
 void orc_compiler_rewrite_vars (OrcCompiler *compiler);
 void orc_compiler_dump (OrcCompiler *compiler);
-void neon_save_accumulators (OrcCompiler *compiler);
+void orc_neon_save_accumulators (OrcCompiler *compiler);
 
 
 void
-neon_emit_prologue (OrcCompiler *compiler)
+orc_neon_emit_prologue (OrcCompiler *compiler)
 {
   unsigned int regs = 0;
   int i;
@@ -47,31 +47,31 @@ neon_emit_prologue (OrcCompiler *compiler)
       regs |= (1<<i);
     }
   }
-  if (regs) arm_emit_push (compiler, regs);
+  if (regs) orc_arm_emit_push (compiler, regs);
 
 }
 
 void
-neon_dump_insns (OrcCompiler *compiler)
+orc_neon_dump_insns (OrcCompiler *compiler)
 {
 
-  arm_emit_label (compiler, 0);
+  orc_arm_emit_label (compiler, 0);
 
-  arm_emit_add (compiler, ARM_A2, ARM_A3, ARM_A4);
-  arm_emit_sub (compiler, ARM_A2, ARM_A3, ARM_A4);
-  arm_emit_push (compiler, 0x06);
-  arm_emit_mov (compiler, ARM_A2, ARM_A3);
+  orc_arm_emit_add (compiler, ARM_A2, ARM_A3, ARM_A4);
+  orc_arm_emit_sub (compiler, ARM_A2, ARM_A3, ARM_A4);
+  orc_arm_emit_push (compiler, 0x06);
+  orc_arm_emit_mov (compiler, ARM_A2, ARM_A3);
 
-  arm_emit_branch (compiler, ARM_COND_LE, 0);
-  arm_emit_branch (compiler, ARM_COND_AL, 0);
+  orc_arm_emit_branch (compiler, ARM_COND_LE, 0);
+  orc_arm_emit_branch (compiler, ARM_COND_AL, 0);
 
-  arm_emit_load_imm (compiler, ARM_A3, 0xa500);
-  arm_loadw (compiler, ARM_A3, ARM_A4, 0xa5);
-  arm_emit_load_reg (compiler, ARM_A3, ARM_A4, 0x5a5);
+  orc_arm_emit_load_imm (compiler, ARM_A3, 0xa500);
+  orc_arm_loadw (compiler, ARM_A3, ARM_A4, 0xa5);
+  orc_arm_emit_load_reg (compiler, ARM_A3, ARM_A4, 0x5a5);
 }
 
 void
-neon_emit_epilogue (OrcCompiler *compiler)
+orc_neon_emit_epilogue (OrcCompiler *compiler)
 {
   int i;
   unsigned int regs = 0;
@@ -82,8 +82,8 @@ neon_emit_epilogue (OrcCompiler *compiler)
       regs |= (1<<i);
     }
   }
-  if (regs) arm_emit_pop (compiler, regs);
-  arm_emit_bx_lr (compiler);
+  if (regs) orc_arm_emit_pop (compiler, regs);
+  orc_arm_emit_bx_lr (compiler);
 
   //arm_dump_insns (compiler);
 }
@@ -158,7 +158,7 @@ orc_compiler_neon_init (OrcCompiler *compiler)
 }
 
 void
-neon_load_constants (OrcCompiler *compiler)
+orc_neon_load_constants (OrcCompiler *compiler)
 {
   int i;
   for(i=0;i<ORC_N_VARIABLES;i++){
@@ -167,13 +167,13 @@ neon_load_constants (OrcCompiler *compiler)
     switch (compiler->vars[i].vartype) {
       case ORC_VAR_TYPE_CONST:
         if (compiler->vars[i].size == 1) {
-          neon_emit_loadib (compiler, compiler->vars[i].alloc,
+          orc_neon_emit_loadib (compiler, compiler->vars[i].alloc,
               (int)compiler->vars[i].value);
         } else if (compiler->vars[i].size == 2) {
-          neon_emit_loadiw (compiler, compiler->vars[i].alloc,
+          orc_neon_emit_loadiw (compiler, compiler->vars[i].alloc,
               (int)compiler->vars[i].value);
         } else if (compiler->vars[i].size == 4) {
-          neon_emit_loadil (compiler, compiler->vars[i].alloc,
+          orc_neon_emit_loadil (compiler, compiler->vars[i].alloc,
               (int)compiler->vars[i].value);
         } else {
           ORC_PROGRAM_ERROR(compiler,"unimplemented");
@@ -181,23 +181,23 @@ neon_load_constants (OrcCompiler *compiler)
         break;
       case ORC_VAR_TYPE_PARAM:
         if (compiler->vars[i].size == 1) {
-          neon_emit_loadpb (compiler, compiler->vars[i].alloc, i);
+          orc_neon_emit_loadpb (compiler, compiler->vars[i].alloc, i);
         } else if (compiler->vars[i].size == 2) {
-          neon_emit_loadpw (compiler, compiler->vars[i].alloc, i);
+          orc_neon_emit_loadpw (compiler, compiler->vars[i].alloc, i);
         } else if (compiler->vars[i].size == 4) {
-          neon_emit_loadpl (compiler, compiler->vars[i].alloc, i);
+          orc_neon_emit_loadpl (compiler, compiler->vars[i].alloc, i);
         } else {
           ORC_PROGRAM_ERROR(compiler,"unimplemented");
         }
         break;
       case ORC_VAR_TYPE_SRC:
       case ORC_VAR_TYPE_DEST:
-        arm_emit_load_reg (compiler, 
+        orc_arm_emit_load_reg (compiler, 
             compiler->vars[i].ptr_register,
             neon_exec_ptr, ORC_STRUCT_OFFSET(OrcExecutor, arrays[i]));
         break;
       case ORC_VAR_TYPE_ACCUMULATOR:
-        neon_emit_loadil (compiler, compiler->vars[i].alloc, 0);
+        orc_neon_emit_loadil (compiler, compiler->vars[i].alloc, 0);
         break;
       case ORC_VAR_TYPE_TEMP:
         break;
@@ -209,7 +209,7 @@ neon_load_constants (OrcCompiler *compiler)
 }
 
 void
-neon_emit_load_src (OrcCompiler *compiler, OrcVariable *var)
+orc_neon_emit_load_src (OrcCompiler *compiler, OrcVariable *var)
 {
   int ptr_reg;
   int update;
@@ -231,13 +231,13 @@ neon_emit_load_src (OrcCompiler *compiler, OrcVariable *var)
   }
   switch (var->size) {
     case 1:
-      neon_loadb (compiler, var->alloc, ptr_reg, update, var->is_aligned);
+      orc_neon_loadb (compiler, var->alloc, ptr_reg, update, var->is_aligned);
       break;
     case 2:
-      neon_loadw (compiler, var->alloc, ptr_reg, update, var->is_aligned);
+      orc_neon_loadw (compiler, var->alloc, ptr_reg, update, var->is_aligned);
       break;
     case 4:
-      neon_loadl (compiler, var->alloc, ptr_reg, update, var->is_aligned);
+      orc_neon_loadl (compiler, var->alloc, ptr_reg, update, var->is_aligned);
       break;
     default:
       ORC_ERROR("bad size");
@@ -245,7 +245,7 @@ neon_emit_load_src (OrcCompiler *compiler, OrcVariable *var)
 }
 
 void
-neon_emit_store_dest (OrcCompiler *compiler, OrcVariable *var)
+orc_neon_emit_store_dest (OrcCompiler *compiler, OrcVariable *var)
 {
   int ptr_reg;
   if (var->ptr_register == 0) {
@@ -257,13 +257,13 @@ neon_emit_store_dest (OrcCompiler *compiler, OrcVariable *var)
   }
   switch (var->size) {
     case 1:
-      neon_storeb (compiler, ptr_reg, TRUE, var->alloc, var->is_aligned);
+      orc_neon_storeb (compiler, ptr_reg, TRUE, var->alloc, var->is_aligned);
       break;
     case 2:
-      neon_storew (compiler, ptr_reg, TRUE, var->alloc, var->is_aligned);
+      orc_neon_storew (compiler, ptr_reg, TRUE, var->alloc, var->is_aligned);
       break;
     case 4:
-      neon_storel (compiler, ptr_reg, TRUE, var->alloc, var->is_aligned);
+      orc_neon_storel (compiler, ptr_reg, TRUE, var->alloc, var->is_aligned);
       break;
     default:
       ORC_ERROR("bad size");
@@ -308,93 +308,93 @@ orc_compiler_neon_assemble (OrcCompiler *compiler)
 
   compiler->vars[align_var].is_aligned = FALSE;
 
-  neon_emit_prologue (compiler);
+  orc_neon_emit_prologue (compiler);
 
   if (compiler->loop_shift > 0) {
     int align_shift = 3;
 
-    arm_emit_load_imm (compiler, ARM_IP, 1<<align_shift);
+    orc_arm_emit_load_imm (compiler, ARM_IP, 1<<align_shift);
 
-    arm_emit_load_reg (compiler, ARM_A3, neon_exec_ptr,
+    orc_arm_emit_load_reg (compiler, ARM_A3, neon_exec_ptr,
         (int)ORC_STRUCT_OFFSET(OrcExecutor,n));
-    arm_emit_load_reg (compiler, ARM_A2, neon_exec_ptr,
+    orc_arm_emit_load_reg (compiler, ARM_A2, neon_exec_ptr,
         (int)ORC_STRUCT_OFFSET(OrcExecutor,arrays[align_var]));
-    arm_emit_sub (compiler, ARM_IP, ARM_IP, ARM_A2);
-    arm_emit_and_imm (compiler, ARM_IP, ARM_IP, (1<<align_shift)-1);
+    orc_arm_emit_sub (compiler, ARM_IP, ARM_IP, ARM_A2);
+    orc_arm_emit_and_imm (compiler, ARM_IP, ARM_IP, (1<<align_shift)-1);
     if (align_shift > 0) {
-      arm_emit_asr_imm (compiler, ARM_IP, ARM_IP, align_shift);
+      orc_arm_emit_asr_imm (compiler, ARM_IP, ARM_IP, align_shift);
     }
 
-    arm_emit_cmp (compiler, ARM_A3, ARM_IP);
-    arm_emit_branch (compiler, ARM_COND_LE, 6);
+    orc_arm_emit_cmp (compiler, ARM_A3, ARM_IP);
+    orc_arm_emit_branch (compiler, ARM_COND_LE, 6);
 
-    arm_emit_store_reg (compiler, ARM_IP, neon_exec_ptr,
+    orc_arm_emit_store_reg (compiler, ARM_IP, neon_exec_ptr,
         (int)ORC_STRUCT_OFFSET(OrcExecutor,counter1));
-    arm_emit_sub (compiler, ARM_A2, ARM_A3, ARM_IP);
+    orc_arm_emit_sub (compiler, ARM_A2, ARM_A3, ARM_IP);
 
-    arm_emit_asr_imm (compiler, ARM_A3, ARM_A2, compiler->loop_shift);
-    arm_emit_store_reg (compiler, ARM_A3, neon_exec_ptr,
+    orc_arm_emit_asr_imm (compiler, ARM_A3, ARM_A2, compiler->loop_shift);
+    orc_arm_emit_store_reg (compiler, ARM_A3, neon_exec_ptr,
         (int)ORC_STRUCT_OFFSET(OrcExecutor,counter2));
 
-    arm_emit_and_imm (compiler, ARM_A3, ARM_A2, (1<<compiler->loop_shift)-1);
-    arm_emit_store_reg (compiler, ARM_A3, neon_exec_ptr,
+    orc_arm_emit_and_imm (compiler, ARM_A3, ARM_A2, (1<<compiler->loop_shift)-1);
+    orc_arm_emit_store_reg (compiler, ARM_A3, neon_exec_ptr,
         (int)ORC_STRUCT_OFFSET(OrcExecutor,counter3));
 
-    arm_emit_branch (compiler, ARM_COND_AL, 7);
-    arm_emit_label (compiler, 6);
+    orc_arm_emit_branch (compiler, ARM_COND_AL, 7);
+    orc_arm_emit_label (compiler, 6);
 
-    arm_emit_store_reg (compiler, ARM_A3, neon_exec_ptr,
+    orc_arm_emit_store_reg (compiler, ARM_A3, neon_exec_ptr,
         (int)ORC_STRUCT_OFFSET(OrcExecutor,counter1));
 
-    arm_emit_load_imm (compiler, ARM_A3, 0);
-    arm_emit_store_reg (compiler, ARM_A3, neon_exec_ptr,
+    orc_arm_emit_load_imm (compiler, ARM_A3, 0);
+    orc_arm_emit_store_reg (compiler, ARM_A3, neon_exec_ptr,
         (int)ORC_STRUCT_OFFSET(OrcExecutor,counter2));
-    arm_emit_store_reg (compiler, ARM_A3, neon_exec_ptr,
+    orc_arm_emit_store_reg (compiler, ARM_A3, neon_exec_ptr,
         (int)ORC_STRUCT_OFFSET(OrcExecutor,counter3));
 
-    arm_emit_label (compiler, 7);
+    orc_arm_emit_label (compiler, 7);
   }
 
-  neon_load_constants (compiler);
+  orc_neon_load_constants (compiler);
 
   if (compiler->loop_shift > 0) {
     int save_loop_shift = compiler->loop_shift;
     compiler->loop_shift = 0;
 
-    arm_emit_load_reg (compiler, ARM_IP, neon_exec_ptr,
+    orc_arm_emit_load_reg (compiler, ARM_IP, neon_exec_ptr,
         (int)ORC_STRUCT_OFFSET(OrcExecutor,counter1));
 
-    arm_emit_cmp_imm (compiler, ARM_IP, 0);
-    arm_emit_branch (compiler, ARM_COND_EQ, 1);
+    orc_arm_emit_cmp_imm (compiler, ARM_IP, 0);
+    orc_arm_emit_branch (compiler, ARM_COND_EQ, 1);
 
-    arm_emit_label (compiler, 0);
-    neon_emit_loop (compiler);
-    arm_emit_sub_imm (compiler, ARM_IP, ARM_IP, 1);
-    arm_emit_cmp_imm (compiler, ARM_IP, 0);
-    arm_emit_branch (compiler, ARM_COND_NE, 0);
-    arm_emit_label (compiler, 1);
+    orc_arm_emit_label (compiler, 0);
+    orc_neon_emit_loop (compiler);
+    orc_arm_emit_sub_imm (compiler, ARM_IP, ARM_IP, 1);
+    orc_arm_emit_cmp_imm (compiler, ARM_IP, 0);
+    orc_arm_emit_branch (compiler, ARM_COND_NE, 0);
+    orc_arm_emit_label (compiler, 1);
 
     compiler->loop_shift = save_loop_shift;
     compiler->vars[align_var].is_aligned = TRUE;
   }
 
   if (compiler->loop_shift > 0) {
-    arm_emit_load_reg (compiler, ARM_IP, neon_exec_ptr,
+    orc_arm_emit_load_reg (compiler, ARM_IP, neon_exec_ptr,
         (int)ORC_STRUCT_OFFSET(OrcExecutor,counter2));
   } else {
-    arm_emit_load_reg (compiler, ARM_IP, neon_exec_ptr,
+    orc_arm_emit_load_reg (compiler, ARM_IP, neon_exec_ptr,
         (int)ORC_STRUCT_OFFSET(OrcExecutor,n));
   }
 
-  arm_emit_cmp_imm (compiler, ARM_IP, 0);
-  arm_emit_branch (compiler, ARM_COND_EQ, 3);
+  orc_arm_emit_cmp_imm (compiler, ARM_IP, 0);
+  orc_arm_emit_branch (compiler, ARM_COND_EQ, 3);
 
-  arm_emit_label (compiler, 2);
-  neon_emit_loop (compiler);
-  arm_emit_sub_imm (compiler, ARM_IP, ARM_IP, 1);
-  arm_emit_cmp_imm (compiler, ARM_IP, 0);
-  arm_emit_branch (compiler, ARM_COND_NE, 2);
-  arm_emit_label (compiler, 3);
+  orc_arm_emit_label (compiler, 2);
+  orc_neon_emit_loop (compiler);
+  orc_arm_emit_sub_imm (compiler, ARM_IP, ARM_IP, 1);
+  orc_arm_emit_cmp_imm (compiler, ARM_IP, 0);
+  orc_arm_emit_branch (compiler, ARM_COND_NE, 2);
+  orc_arm_emit_label (compiler, 3);
 
   if (compiler->loop_shift > 0) {
     int save_loop_shift = compiler->loop_shift;
@@ -402,31 +402,31 @@ orc_compiler_neon_assemble (OrcCompiler *compiler)
 
     compiler->vars[align_var].is_aligned = FALSE;
 
-    arm_emit_load_reg (compiler, ARM_IP, neon_exec_ptr,
+    orc_arm_emit_load_reg (compiler, ARM_IP, neon_exec_ptr,
         (int)ORC_STRUCT_OFFSET(OrcExecutor,counter3));
 
-    arm_emit_cmp_imm (compiler, ARM_IP, 0);
-    arm_emit_branch (compiler, ARM_COND_EQ, 5);
+    orc_arm_emit_cmp_imm (compiler, ARM_IP, 0);
+    orc_arm_emit_branch (compiler, ARM_COND_EQ, 5);
 
-    arm_emit_label (compiler, 4);
-    neon_emit_loop (compiler);
-    arm_emit_sub_imm (compiler, ARM_IP, ARM_IP, 1);
-    arm_emit_cmp_imm (compiler, ARM_IP, 0);
-    arm_emit_branch (compiler, ARM_COND_NE, 4);
-    arm_emit_label (compiler, 5);
+    orc_arm_emit_label (compiler, 4);
+    orc_neon_emit_loop (compiler);
+    orc_arm_emit_sub_imm (compiler, ARM_IP, ARM_IP, 1);
+    orc_arm_emit_cmp_imm (compiler, ARM_IP, 0);
+    orc_arm_emit_branch (compiler, ARM_COND_NE, 4);
+    orc_arm_emit_label (compiler, 5);
 
     compiler->loop_shift = save_loop_shift;
   }
 
-  neon_save_accumulators (compiler);
+  orc_neon_save_accumulators (compiler);
 
-  neon_emit_epilogue (compiler);
+  orc_neon_emit_epilogue (compiler);
 
-  arm_do_fixups (compiler);
+  orc_arm_do_fixups (compiler);
 }
 
 void
-neon_emit_loop (OrcCompiler *compiler)
+orc_neon_emit_loop (OrcCompiler *compiler)
 {
   int j;
   int k;
@@ -458,7 +458,7 @@ neon_emit_loop (OrcCompiler *compiler)
       switch (compiler->vars[insn->src_args[k]].vartype) {
         case ORC_VAR_TYPE_SRC:
         case ORC_VAR_TYPE_DEST:
-          neon_emit_load_src (compiler, &compiler->vars[insn->src_args[k]]);
+          orc_neon_emit_load_src (compiler, &compiler->vars[insn->src_args[k]]);
           break;
         case ORC_VAR_TYPE_CONST:
           break;
@@ -476,7 +476,7 @@ neon_emit_loop (OrcCompiler *compiler)
 #if 0
       if (compiler->vars[insn->dest_args[0]].alloc !=
           compiler->vars[insn->src_args[0]].alloc) {
-        neon_emit_mov (compiler, compiler->vars[insn->src_args[0]].alloc,
+        orc_neon_emit_mov (compiler, compiler->vars[insn->src_args[0]].alloc,
             compiler->vars[insn->dest_args[0]].alloc);
       }
 #endif
@@ -490,7 +490,7 @@ neon_emit_loop (OrcCompiler *compiler)
 
       switch (compiler->vars[insn->dest_args[k]].vartype) {
         case ORC_VAR_TYPE_DEST:
-          neon_emit_store_dest (compiler, &compiler->vars[insn->dest_args[k]]);
+          orc_neon_emit_store_dest (compiler, &compiler->vars[insn->dest_args[k]]);
           break;
         case ORC_VAR_TYPE_TEMP:
           break;
@@ -505,7 +505,7 @@ neon_emit_loop (OrcCompiler *compiler)
     if (compiler->vars[k].vartype == ORC_VAR_TYPE_SRC ||
         compiler->vars[k].vartype == ORC_VAR_TYPE_DEST) {
       if (compiler->vars[k].ptr_register) {
-        arm_emit_add_imm (compiler,
+        orc_arm_emit_add_imm (compiler,
             compiler->vars[k].ptr_register,
             compiler->vars[k].ptr_register,
             compiler->vars[k].size << compiler->loop_shift);
@@ -521,7 +521,7 @@ neon_emit_loop (OrcCompiler *compiler)
 }
 
 void
-neon_save_accumulators (OrcCompiler *compiler)
+orc_neon_save_accumulators (OrcCompiler *compiler)
 {
   int i;
   int src;
@@ -535,57 +535,57 @@ neon_save_accumulators (OrcCompiler *compiler)
       case ORC_VAR_TYPE_ACCUMULATOR:
         src = compiler->vars[i].alloc;
 
-        arm_emit_load_imm (compiler, compiler->gp_tmpreg,
+        orc_arm_emit_load_imm (compiler, compiler->gp_tmpreg,
             ORC_STRUCT_OFFSET(OrcExecutor, accumulators[i-ORC_VAR_A1]));
         switch (var->size) {
           case 2:
             ORC_ASM_CODE(compiler,"  vpaddl.u16 %s, %s\n",
-                neon_reg_name (src),
-                neon_reg_name (src));
-            code = 0xf3b40080;
-            code |= (src&0xf) << 16;
+                orc_neon_reg_name (src),
+                orc_neon_reg_name (src));
+            code = 0xf3b40280;
             code |= (src&0xf) << 12;
             code |= ((src>>4)&0x1) << 22;
-            arm_emit (compiler, code);
+            code |= (src&0xf) << 0;
+            orc_arm_emit (compiler, code);
 
             ORC_ASM_CODE(compiler,"  vpaddl.u32 %s, %s\n",
-                neon_reg_name (src),
-                neon_reg_name (src));
-            code = 0xf3b40080;
-            code |= (src&0xf) << 16;
+                orc_neon_reg_name (src),
+                orc_neon_reg_name (src));
+            code = 0xf3b80280;
             code |= (src&0xf) << 12;
             code |= ((src>>4)&0x1) << 22;
-            arm_emit (compiler, code);
+            code |= (src&0xf) << 0;
+            orc_arm_emit (compiler, code);
 
             ORC_ASM_CODE(compiler,"  vst1.16 %s[%d], [%s], %s\n",
-                neon_reg_name (src), 0,
-                arm_reg_name (compiler->gp_tmpreg),
-                arm_reg_name (compiler->exec_reg));
+                orc_neon_reg_name (src), 0,
+                orc_arm_reg_name (compiler->gp_tmpreg),
+                orc_arm_reg_name (compiler->exec_reg));
             code = 0xf4800400;
             code |= (compiler->gp_tmpreg&0xf) << 16;
             code |= (src&0xf) << 12;
             code |= ((src>>4)&0x1) << 22;
-            arm_emit (compiler, code);
+            orc_arm_emit (compiler, code);
             break;
           case 4:
             ORC_ASM_CODE(compiler,"  vpaddl.u32 %s, %s\n",
-                neon_reg_name (src),
-                neon_reg_name (src));
-            code = 0xf3b40080;
-            code |= (src&0xf) << 16;
+                orc_neon_reg_name (src),
+                orc_neon_reg_name (src));
+            code = 0xf3b80280;
             code |= (src&0xf) << 12;
             code |= ((src>>4)&0x1) << 22;
-            arm_emit (compiler, code);
+            code |= (src&0xf) << 0;
+            orc_arm_emit (compiler, code);
 
             ORC_ASM_CODE(compiler,"  vst1.32 %s[%d], [%s], %s\n",
-                neon_reg_name (src), 0,
-                arm_reg_name (compiler->gp_tmpreg),
-                arm_reg_name (compiler->exec_reg));
+                orc_neon_reg_name (src), 0,
+                orc_arm_reg_name (compiler->gp_tmpreg),
+                orc_arm_reg_name (compiler->exec_reg));
             code = 0xf4800800;
             code |= (compiler->gp_tmpreg&0xf) << 16;
             code |= (src&0xf) << 12;
             code |= ((src>>4)&0x1) << 22;
-            arm_emit (compiler, code);
+            orc_arm_emit (compiler, code);
             break;
           default:
             ORC_ERROR("bad size");
diff --git a/orc/orcrules-arm.c b/orc/orcrules-arm.c
index 1544188..e0c51eb 100644
--- a/orc/orcrules-arm.c
+++ b/orc/orcrules-arm.c
@@ -14,7 +14,7 @@
 
 
 void
-arm_loadw (OrcCompiler *compiler, int dest, int src1, int offset)
+orc_arm_loadw (OrcCompiler *compiler, int dest, int src1, int offset)
 {
   uint32_t code;
 
@@ -25,13 +25,13 @@ arm_loadw (OrcCompiler *compiler, int dest, int src1, int offset)
   code |= offset&0x0f;
 
   ORC_ASM_CODE(compiler,"  ldrh %s, [%s, #%d]\n",
-      arm_reg_name (dest),
-      arm_reg_name (src1), offset);
-  arm_emit (compiler, code);
+      orc_arm_reg_name (dest),
+      orc_arm_reg_name (src1), offset);
+  orc_arm_emit (compiler, code);
 }
 
 void
-arm_storew (OrcCompiler *compiler, int dest, int offset, int src1)
+orc_arm_storew (OrcCompiler *compiler, int dest, int offset, int src1)
 {
   uint32_t code;
 
@@ -42,13 +42,13 @@ arm_storew (OrcCompiler *compiler, int dest, int offset, int src1)
   code |= offset&0x0f;
 
   ORC_ASM_CODE(compiler,"  strh %s, [%s, #%d]\n",
-      arm_reg_name (src1),
-      arm_reg_name (dest), offset);
-  arm_emit (compiler, code);
+      orc_arm_reg_name (src1),
+      orc_arm_reg_name (dest), offset);
+  orc_arm_emit (compiler, code);
 }
 
 static void
-arm_rule_addw (OrcCompiler *p, void *user, OrcInstruction *insn)
+orc_arm_rule_addw (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
   uint32_t code;
 
@@ -58,14 +58,14 @@ arm_rule_addw (OrcCompiler *p, void *user, OrcInstruction *insn)
   code |= (p->vars[insn->src_args[1]].alloc&0xf) << 0;
 
   ORC_ASM_CODE(p,"  add %s, %s, %s\n",
-      arm_reg_name (p->vars[insn->dest_args[0]].alloc),
-      arm_reg_name (p->vars[insn->src_args[0]].alloc),
-      arm_reg_name (p->vars[insn->src_args[1]].alloc));
-  arm_emit (p, code);
+      orc_arm_reg_name (p->vars[insn->dest_args[0]].alloc),
+      orc_arm_reg_name (p->vars[insn->src_args[0]].alloc),
+      orc_arm_reg_name (p->vars[insn->src_args[1]].alloc));
+  orc_arm_emit (p, code);
 }
 
 static void
-arm_rule_subw (OrcCompiler *p, void *user, OrcInstruction *insn)
+orc_arm_rule_subw (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
   uint32_t code;
 
@@ -75,14 +75,14 @@ arm_rule_subw (OrcCompiler *p, void *user, OrcInstruction *insn)
   code |= (p->vars[insn->src_args[1]].alloc&0xf) << 0;
 
   ORC_ASM_CODE(p,"  sub %s, %s, %s\n",
-      arm_reg_name (p->vars[insn->dest_args[0]].alloc),
-      arm_reg_name (p->vars[insn->src_args[0]].alloc),
-      arm_reg_name (p->vars[insn->src_args[1]].alloc));
-  arm_emit (p, code);
+      orc_arm_reg_name (p->vars[insn->dest_args[0]].alloc),
+      orc_arm_reg_name (p->vars[insn->src_args[0]].alloc),
+      orc_arm_reg_name (p->vars[insn->src_args[1]].alloc));
+  orc_arm_emit (p, code);
 }
 
 static void
-arm_rule_mullw (OrcCompiler *p, void *user, OrcInstruction *insn)
+orc_arm_rule_mullw (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
   uint32_t code;
 
@@ -92,14 +92,14 @@ arm_rule_mullw (OrcCompiler *p, void *user, OrcInstruction *insn)
   code |= (p->vars[insn->src_args[1]].alloc&0xf) << 8;
 
   ORC_ASM_CODE(p,"  mul %s, %s, %s\n",
-      arm_reg_name (p->vars[insn->dest_args[0]].alloc),
-      arm_reg_name (p->vars[insn->src_args[0]].alloc),
-      arm_reg_name (p->vars[insn->src_args[1]].alloc));
-  arm_emit (p, code);
+      orc_arm_reg_name (p->vars[insn->dest_args[0]].alloc),
+      orc_arm_reg_name (p->vars[insn->src_args[0]].alloc),
+      orc_arm_reg_name (p->vars[insn->src_args[1]].alloc));
+  orc_arm_emit (p, code);
 }
 
 static void
-arm_rule_shrsw (OrcCompiler *p, void *user, OrcInstruction *insn)
+orc_arm_rule_shrsw (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
   uint32_t code;
 
@@ -109,16 +109,16 @@ arm_rule_shrsw (OrcCompiler *p, void *user, OrcInstruction *insn)
   code |= (p->vars[insn->src_args[1]].alloc&0xf) << 8;
 
   ORC_ASM_CODE(p,"  asr %s, %s, %s\n",
-      arm_reg_name (p->vars[insn->dest_args[0]].alloc),
-      arm_reg_name (p->vars[insn->src_args[0]].alloc),
-      arm_reg_name (p->vars[insn->src_args[1]].alloc));
-  arm_emit (p, code);
+      orc_arm_reg_name (p->vars[insn->dest_args[0]].alloc),
+      orc_arm_reg_name (p->vars[insn->src_args[0]].alloc),
+      orc_arm_reg_name (p->vars[insn->src_args[1]].alloc));
+  orc_arm_emit (p, code);
 }
 
 
 #if 0
 void
-arm_emit_loadiw (OrcCompiler *p, int reg, int value)
+orc_arm_emit_loadiw (OrcCompiler *p, int reg, int value)
 {
   if (value == 0) {
     ORC_ASM_CODE(compiler,"  pxor %%%s, %%%s\n", x86_get_regname_sse(reg),
@@ -172,7 +172,7 @@ arm_emit_loadiw (OrcCompiler *p, int reg, int value)
 }
 
 void
-arm_emit_loadw (OrcCompiler *p, int reg, int offset, int reg1)
+orc_arm_emit_loadw (OrcCompiler *p, int reg, int offset, int reg1)
 {
   ORC_ASM_CODE(compiler,"  movd %d(%%%s), %%%s\n", offset, x86_get_regname_ptr(reg1),
       x86_get_regname_sse(reg));
@@ -199,7 +199,7 @@ arm_emit_loadw (OrcCompiler *p, int reg, int offset, int reg1)
 }
 
 static void
-arm_rule_copyx (OrcCompiler *p, void *user, OrcInstruction *insn)
+orc_arm_rule_copyx (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
   ORC_ASM_CODE(compiler,"  movdqa %%%s, %%%s\n",
       x86_get_regname_sse(p->vars[insn->src_args[0]].alloc),
@@ -215,7 +215,7 @@ arm_rule_copyx (OrcCompiler *p, void *user, OrcInstruction *insn)
 }
 
 static void
-arm_emit_66_rex_0f (OrcCompiler *p, OrcInstruction *insn, int code,
+orc_arm_emit_66_rex_0f (OrcCompiler *p, OrcInstruction *insn, int code,
     const char *insn_name)
 {
   ORC_ASM_CODE(compiler,"  %s %%%s, %%%s\n", insn_name,
@@ -236,36 +236,36 @@ arm_emit_66_rex_0f (OrcCompiler *p, OrcInstruction *insn, int code,
 
 #if 0
 static void
-arm_rule_addw (OrcCompiler *p, void *user, OrcInstruction *insn)
+orc_arm_rule_addw (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
-  arm_emit_66_rex_0f (p, insn, 0xfd, "paddw");
+  orc_arm_emit_66_rex_0f (p, insn, 0xfd, "paddw");
 }
 
 static void
-arm_rule_subw (OrcCompiler *p, void *user, OrcInstruction *insn)
+orc_arm_rule_subw (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
-  arm_emit_66_rex_0f (p, insn, 0xf9, "psubw");
+  orc_arm_emit_66_rex_0f (p, insn, 0xf9, "psubw");
 }
 
 static void
-arm_rule_mullw (OrcCompiler *p, void *user, OrcInstruction *insn)
+orc_arm_rule_mullw (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
-  arm_emit_66_rex_0f (p, insn, 0xd5, "pmullw");
+  orc_arm_emit_66_rex_0f (p, insn, 0xd5, "pmullw");
 }
 #endif
 
 #define UNARY(opcode,insn_name,code) \
 static void \
-arm_rule_ ## opcode (OrcCompiler *p, void *user, OrcInstruction *insn) \
+orc_arm_rule_ ## opcode (OrcCompiler *p, void *user, OrcInstruction *insn) \
 { \
-  arm_emit_66_rex_0f (p, insn, code, insn_name); \
+  orc_arm_emit_66_rex_0f (p, insn, code, insn_name); \
 }
 
 #define BINARY(opcode,insn_name,code) \
 static void \
-arm_rule_ ## opcode (OrcCompiler *p, void *user, OrcInstruction *insn) \
+orc_arm_rule_ ## opcode (OrcCompiler *p, void *user, OrcInstruction *insn) \
 { \
-  arm_emit_66_rex_0f (p, insn, code, insn_name); \
+  orc_arm_emit_66_rex_0f (p, insn, code, insn_name); \
 }
 
 
@@ -340,7 +340,7 @@ BINARY(xorl,"pxor",0xef)
 
 
 static void
-arm_rule_shlw (OrcCompiler *p, void *user, OrcInstruction *insn)
+orc_arm_rule_shlw (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
   if (p->vars[insn->src_args[1]].vartype == ORC_VAR_TYPE_CONST) {
     ORC_ASM_CODE(compiler,"  psllw $%d, %%%s\n",
@@ -382,7 +382,7 @@ arm_rule_shlw (OrcCompiler *p, void *user, OrcInstruction *insn)
 }
 
 static void
-arm_rule_shrsw (OrcCompiler *p, void *user, OrcInstruction *insn)
+orc_arm_rule_shrsw (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
   if (p->vars[insn->src_args[1]].vartype == ORC_VAR_TYPE_CONST) {
     ORC_ASM_CODE(compiler,"  psraw $%d, %%%s\n",
@@ -424,7 +424,7 @@ arm_rule_shrsw (OrcCompiler *p, void *user, OrcInstruction *insn)
 }
 
 static void
-arm_rule_convsbw (OrcCompiler *p, void *user, OrcInstruction *insn)
+orc_arm_rule_convsbw (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
   ORC_ASM_CODE(compiler,"  punpcklbw %%%s, %%%s\n",
       x86_get_regname_sse(p->vars[insn->src_args[0]].alloc),
@@ -447,7 +447,7 @@ arm_rule_convsbw (OrcCompiler *p, void *user, OrcInstruction *insn)
 }
 
 static void
-arm_rule_convubw (OrcCompiler *p, void *user, OrcInstruction *insn)
+orc_arm_rule_convubw (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
   /* FIXME should do this by unpacking with a zero reg */
 
@@ -473,7 +473,7 @@ arm_rule_convubw (OrcCompiler *p, void *user, OrcInstruction *insn)
 }
 
 static void
-arm_rule_convsuswb (OrcCompiler *p, void *user, OrcInstruction *insn)
+orc_arm_rule_convsuswb (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
   ORC_ASM_CODE(compiler,"  packuswb %%%s, %%%s\n",
       x86_get_regname_sse(p->vars[insn->src_args[0]].alloc),
@@ -581,9 +581,9 @@ orc_compiler_arm_register_rules (OrcTarget *target)
   orc_rule_register (rule_set, "convubw", arm_rule_convubw, NULL);
   orc_rule_register (rule_set, "convsuswb", arm_rule_convsuswb, NULL);
 #endif
-  orc_rule_register (rule_set, "addw", arm_rule_addw, NULL);
-  orc_rule_register (rule_set, "subw", arm_rule_subw, NULL);
-  orc_rule_register (rule_set, "mullw", arm_rule_mullw, NULL);
-  orc_rule_register (rule_set, "shrsw", arm_rule_shrsw, NULL);
+  orc_rule_register (rule_set, "addw", orc_arm_rule_addw, NULL);
+  orc_rule_register (rule_set, "subw", orc_arm_rule_subw, NULL);
+  orc_rule_register (rule_set, "mullw", orc_arm_rule_mullw, NULL);
+  orc_rule_register (rule_set, "shrsw", orc_arm_rule_shrsw, NULL);
 }
 
diff --git a/orc/orcrules-neon.c b/orc/orcrules-neon.c
index 1b4b564..cc88d39 100644
--- a/orc/orcrules-neon.c
+++ b/orc/orcrules-neon.c
@@ -17,7 +17,7 @@
 extern int neon_exec_ptr;
 extern int neon_tmp_reg;
 
-const char *neon_reg_name (int reg)
+const char *orc_neon_reg_name (int reg)
 {
   static const char *vec_regs[] = {
     "d0", "d1", "d2", "d3",
@@ -37,7 +37,7 @@ const char *neon_reg_name (int reg)
   return vec_regs[reg&0x1f];
 }
 
-const char *neon_reg_name_quad (int reg)
+const char *orc_neon_reg_name_quad (int reg)
 {
   static const char *vec_regs[] = {
     "q0", "ERROR", "q1", "ERROR",
@@ -58,13 +58,13 @@ const char *neon_reg_name_quad (int reg)
 }
 
 void
-neon_emit_mov (OrcCompiler *compiler, int src, int dest)
+orc_neon_emit_mov (OrcCompiler *compiler, int src, int dest)
 {
   uint32_t code;
 
   ORC_ASM_CODE(compiler,"  vmov %s, %s\n",
-      neon_reg_name (dest),
-      neon_reg_name (src));
+      orc_neon_reg_name (dest),
+      orc_neon_reg_name (src));
   code = 0xf2200110;
   code |= (dest&0xf) << 16;
   code |= ((dest>>4)&0x1) << 7;
@@ -72,31 +72,31 @@ neon_emit_mov (OrcCompiler *compiler, int src, int dest)
   code |= ((src>>4)&0x1) << 22;
   code |= (src&0xf) << 0;
   code |= ((src>>4)&0x1) << 5;
-  arm_emit (compiler, code);
+  orc_arm_emit (compiler, code);
 }
 
 void
-neon_loadb (OrcCompiler *compiler, int dest, int src1, int update, int is_aligned)
+orc_neon_loadb (OrcCompiler *compiler, int dest, int src1, int update, int is_aligned)
 {
   uint32_t code;
   int i;
 
   if (is_aligned && compiler->loop_shift == 3) {
     ORC_ASM_CODE(compiler,"  vld1.64 %s, [%s]%s\n",
-        neon_reg_name (dest),
-        arm_reg_name (src1),
+        orc_neon_reg_name (dest),
+        orc_arm_reg_name (src1),
         update ? "!" : "");
     code = 0xf42007cd;
     code |= (src1&0xf) << 16;
     code |= (dest&0xf) << 12;
     code |= ((dest>>4)&0x1) << 22;
     code |= (!update) << 1;
-    arm_emit (compiler, code);
+    orc_arm_emit (compiler, code);
   } else {
     for(i=0;i<(1<<compiler->loop_shift);i++){
       ORC_ASM_CODE(compiler,"  vld1.8 %s[%d], [%s]%s\n",
-          neon_reg_name (dest), i,
-          arm_reg_name (src1),
+          orc_neon_reg_name (dest), i,
+          orc_arm_reg_name (src1),
           update ? "!" : "");
       code = 0xf4a0000d;
       code |= (src1&0xf) << 16;
@@ -104,33 +104,33 @@ neon_loadb (OrcCompiler *compiler, int dest, int src1, int update, int is_aligne
       code |= ((dest>>4)&0x1) << 22;
       code |= i << 5;
       code |= (!update) << 1;
-      arm_emit (compiler, code);
+      orc_arm_emit (compiler, code);
     }
   }
 }
 
 void
-neon_loadw (OrcCompiler *compiler, int dest, int src1, int update, int is_aligned)
+orc_neon_loadw (OrcCompiler *compiler, int dest, int src1, int update, int is_aligned)
 {
   uint32_t code;
   int i;
 
   if (is_aligned && compiler->loop_shift == 2) {
     ORC_ASM_CODE(compiler,"  vld1.64 %s, [%s]%s\n",
-        neon_reg_name (dest),
-        arm_reg_name (src1),
+        orc_neon_reg_name (dest),
+        orc_arm_reg_name (src1),
         update ? "!" : "");
     code = 0xf42007cd;
     code |= (src1&0xf) << 16;
     code |= (dest&0xf) << 12;
     code |= ((dest>>4)&0x1) << 22;
     code |= (!update) << 1;
-    arm_emit (compiler, code);
+    orc_arm_emit (compiler, code);
   } else {
     for(i=0;i<(1<<compiler->loop_shift);i++){
       ORC_ASM_CODE(compiler,"  vld1.16 %s[%d], [%s]%s\n",
-          neon_reg_name (dest), i,
-          arm_reg_name (src1),
+          orc_neon_reg_name (dest), i,
+          orc_arm_reg_name (src1),
           update ? "!" : "");
       code = 0xf4a0040d;
       code |= (src1&0xf) << 16;
@@ -138,33 +138,33 @@ neon_loadw (OrcCompiler *compiler, int dest, int src1, int update, int is_aligne
       code |= ((dest>>4)&0x1) << 22;
       code |= i << 6;
       code |= (!update) << 1;
-      arm_emit (compiler, code);
+      orc_arm_emit (compiler, code);
     }
   }
 }
 
 void
-neon_loadl (OrcCompiler *compiler, int dest, int src1, int update, int is_aligned)
+orc_neon_loadl (OrcCompiler *compiler, int dest, int src1, int update, int is_aligned)
 {
   uint32_t code;
   int i;
 
   if (is_aligned && compiler->loop_shift == 1) {
     ORC_ASM_CODE(compiler,"  vld1.64 %s, [%s]%s\n",
-        neon_reg_name (dest),
-        arm_reg_name (src1),
+        orc_neon_reg_name (dest),
+        orc_arm_reg_name (src1),
         update ? "!" : "");
     code = 0xf42007cd;
     code |= (src1&0xf) << 16;
     code |= (dest&0xf) << 12;
     code |= ((dest>>4)&0x1) << 22;
     code |= (!update) << 1;
-    arm_emit (compiler, code);
+    orc_arm_emit (compiler, code);
   } else {
     for(i=0;i<(1<<compiler->loop_shift);i++){
       ORC_ASM_CODE(compiler,"  vld1.32 %s[%d], [%s]%s\n",
-          neon_reg_name (dest), i,
-          arm_reg_name (src1),
+          orc_neon_reg_name (dest), i,
+          orc_arm_reg_name (src1),
           update ? "!" : "");
       code = 0xf4a0080d;
       code |= (src1&0xf) << 16;
@@ -172,49 +172,49 @@ neon_loadl (OrcCompiler *compiler, int dest, int src1, int update, int is_aligne
       code |= ((dest>>4)&0x1) << 22;
       code |= i<<7;
       code |= (!update) << 1;
-      arm_emit (compiler, code);
+      orc_arm_emit (compiler, code);
     }
   }
 }
 
 void
-neon_emit_neg (OrcCompiler *compiler, int dest)
+orc_neon_emit_neg (OrcCompiler *compiler, int dest)
 {
   uint32_t code;
 
   ORC_ASM_CODE(compiler,"  vneg.s8 %s, %s\n",
-      neon_reg_name (dest),
-      neon_reg_name (dest));
+      orc_neon_reg_name (dest),
+      orc_neon_reg_name (dest));
   code = 0xf3b10380;
   code |= (dest&0xf) << 12;
   code |= ((dest>>4)&0x1) << 22;
   code |= (dest&0xf) << 0;
   code |= ((dest>>4)&0x1) << 5;
-  arm_emit (compiler, code);
+  orc_arm_emit (compiler, code);
 }
 
 void
-neon_storeb (OrcCompiler *compiler, int dest, int update, int src1, int is_aligned)
+orc_neon_storeb (OrcCompiler *compiler, int dest, int update, int src1, int is_aligned)
 {
   uint32_t code;
   int i;
 
   if (is_aligned && compiler->loop_shift == 3) {
     ORC_ASM_CODE(compiler,"  vst1.64 %s, [%s]%s\n",
-        neon_reg_name (src1),
-        arm_reg_name (dest),
+        orc_neon_reg_name (src1),
+        orc_arm_reg_name (dest),
         update ? "!" : "");
     code = 0xf40007cd;
     code |= (dest&0xf) << 16;
     code |= (src1&0xf) << 12;
     code |= ((src1>>4)&0x1) << 22;
     code |= (!update) << 1;
-    arm_emit (compiler, code);
+    orc_arm_emit (compiler, code);
   } else {
     for(i=0;i<(1<<compiler->loop_shift);i++){
       ORC_ASM_CODE(compiler,"  vst1.8 %s[%d], [%s]%s\n",
-          neon_reg_name (src1), i,
-          arm_reg_name (dest),
+          orc_neon_reg_name (src1), i,
+          orc_arm_reg_name (dest),
           update ? "!" : "");
       code = 0xf480000d;
       code |= (dest&0xf) << 16;
@@ -222,33 +222,33 @@ neon_storeb (OrcCompiler *compiler, int dest, int update, int src1, int is_align
       code |= ((src1>>4)&0x1) << 22;
       code |= i<<5;
       code |= (!update) << 1;
-      arm_emit (compiler, code);
+      orc_arm_emit (compiler, code);
     }
   }
 }
 
 void
-neon_storew (OrcCompiler *compiler, int dest, int update, int src1, int is_aligned)
+orc_neon_storew (OrcCompiler *compiler, int dest, int update, int src1, int is_aligned)
 {
   uint32_t code;
   int i;
 
   if (is_aligned && compiler->loop_shift == 2) {
     ORC_ASM_CODE(compiler,"  vst1.64 %s, [%s]%s\n",
-        neon_reg_name (src1),
-        arm_reg_name (dest),
+        orc_neon_reg_name (src1),
+        orc_arm_reg_name (dest),
         update ? "!" : "");
     code = 0xf40007cd;
     code |= (dest&0xf) << 16;
     code |= (src1&0xf) << 12;
     code |= ((src1>>4)&0x1) << 22;
     code |= (!update) << 1;
-    arm_emit (compiler, code);
+    orc_arm_emit (compiler, code);
   } else {
     for(i=0;i<(1<<compiler->loop_shift);i++){
       ORC_ASM_CODE(compiler,"  vst1.16 %s[%d], [%s]%s\n",
-          neon_reg_name (src1), i,
-          arm_reg_name (dest),
+          orc_neon_reg_name (src1), i,
+          orc_arm_reg_name (dest),
           update ? "!" : "");
       code = 0xf480040d;
       code |= (dest&0xf) << 16;
@@ -256,33 +256,33 @@ neon_storew (OrcCompiler *compiler, int dest, int update, int src1, int is_align
       code |= ((src1>>4)&0x1) << 22;
       code |= i<<6;
       code |= (!update) << 1;
-      arm_emit (compiler, code);
+      orc_arm_emit (compiler, code);
     }
   }
 }
 
 void
-neon_storel (OrcCompiler *compiler, int dest, int update, int src1, int is_aligned)
+orc_neon_storel (OrcCompiler *compiler, int dest, int update, int src1, int is_aligned)
 {
   uint32_t code;
   int i;
 
   if (is_aligned && compiler->loop_shift == 2) {
     ORC_ASM_CODE(compiler,"  vst1.64 %s, [%s]%s\n",
-        neon_reg_name (src1),
-        arm_reg_name (dest),
+        orc_neon_reg_name (src1),
+        orc_arm_reg_name (dest),
         update ? "!" : "");
     code = 0xf40007cd;
     code |= (dest&0xf) << 16;
     code |= (src1&0xf) << 12;
     code |= ((src1>>4)&0x1) << 22;
     code |= (!update) << 1;
-    arm_emit (compiler, code);
+    orc_arm_emit (compiler, code);
   } else {
     for(i=0;i<(1<<compiler->loop_shift);i++){
       ORC_ASM_CODE(compiler,"  vst1.32 %s[%d], [%s]%s\n",
-          neon_reg_name (src1), i,
-          arm_reg_name (dest),
+          orc_neon_reg_name (src1), i,
+          orc_arm_reg_name (dest),
           update ? "!" : "");
       code = 0xf480080d;
       code |= (dest&0xf) << 16;
@@ -290,267 +290,267 @@ neon_storel (OrcCompiler *compiler, int dest, int update, int src1, int is_align
       code |= ((src1>>4)&0x1) << 22;
       code |= i<<7;
       code |= (!update) << 1;
-      arm_emit (compiler, code);
+      orc_arm_emit (compiler, code);
     }
   }
 }
 
 void
-neon_emit_loadib (OrcCompiler *compiler, int reg, int value)
+orc_neon_emit_loadib (OrcCompiler *compiler, int reg, int value)
 {
   uint32_t code;
 
   if (value == 0) {
     ORC_ASM_CODE(compiler,"  veor %s, %s, %s\n",
-        neon_reg_name (reg), neon_reg_name (reg), neon_reg_name (reg));
+        orc_neon_reg_name (reg), orc_neon_reg_name (reg), orc_neon_reg_name (reg));
     code = 0xf3000110;
     code |= (reg&0xf) << 16;
     code |= (reg&0xf) << 12;
     code |= (reg&0xf) << 0;
-    arm_emit (compiler, code);
+    orc_arm_emit (compiler, code);
   } else {
     ORC_ASM_CODE(compiler,"  vmov.i8 %s, #%d\n",
-        neon_reg_name (reg), value);
+        orc_neon_reg_name (reg), value);
     code = 0xf2800e10;
     code |= (reg&0xf) << 12;
-    code |= ((reg>>4)&0x1) << 7;
+    code |= ((reg>>4)&0x1) << 22;
     code |= (value&0xf) << 0;
-    arm_emit (compiler, code);
+    orc_arm_emit (compiler, code);
   }
 }
 
 void
-neon_emit_loadiw (OrcCompiler *compiler, int reg, int value)
+orc_neon_emit_loadiw (OrcCompiler *compiler, int reg, int value)
 {
   uint32_t code;
 
   if (value == 0) {
     ORC_ASM_CODE(compiler,"  veor %s, %s, %s\n",
-        neon_reg_name (reg), neon_reg_name (reg), neon_reg_name (reg));
+        orc_neon_reg_name (reg), orc_neon_reg_name (reg), orc_neon_reg_name (reg));
     code = 0xf3000110;
     code |= (reg&0xf) << 16;
     code |= (reg&0xf) << 12;
     code |= (reg&0xf) << 0;
-    arm_emit (compiler, code);
+    orc_arm_emit (compiler, code);
   } else {
     ORC_ASM_CODE(compiler,"  vmov.i16 %s, #%d\n",
-        neon_reg_name (reg), value);
+        orc_neon_reg_name (reg), value);
     code = 0xf2800810;
     code |= (reg&0xf) << 12;
-    code |= ((reg>>4)&0x1) << 7;
+    code |= ((reg>>4)&0x1) << 22;
     code |= (value&0xf) << 0;
-    arm_emit (compiler, code);
+    orc_arm_emit (compiler, code);
   }
 }
 
 void
-neon_emit_loadil (OrcCompiler *compiler, int reg, int value)
+orc_neon_emit_loadil (OrcCompiler *compiler, int reg, int value)
 {
   uint32_t code;
 
   if (value == 0) {
     ORC_ASM_CODE(compiler,"  veor %s, %s, %s\n",
-        neon_reg_name (reg), neon_reg_name (reg), neon_reg_name (reg));
+        orc_neon_reg_name (reg), orc_neon_reg_name (reg), orc_neon_reg_name (reg));
     code = 0xf3000110;
     code |= (reg&0xf) << 16;
     code |= (reg&0xf) << 12;
     code |= (reg&0xf) << 0;
-    arm_emit (compiler, code);
+    orc_arm_emit (compiler, code);
   } else {
     ORC_ASM_CODE(compiler,"  vmov.i32 %s, #%d\n",
-        neon_reg_name (reg), value);
+        orc_neon_reg_name (reg), value);
     code = 0xf2800010;
     code |= (reg&0xf) << 12;
-    code |= ((reg>>4)&0x1) << 7;
+    code |= ((reg>>4)&0x1) << 22;
     code |= (value&0xf) << 0;
-    arm_emit (compiler, code);
+    orc_arm_emit (compiler, code);
   }
 }
 
 void
-neon_emit_loadpb (OrcCompiler *compiler, int dest, int param)
+orc_neon_emit_loadpb (OrcCompiler *compiler, int dest, int param)
 {
   uint32_t code;
 
-  arm_emit_add_imm (compiler, neon_tmp_reg,
+  orc_arm_emit_add_imm (compiler, neon_tmp_reg,
       neon_exec_ptr, ORC_STRUCT_OFFSET(OrcExecutor, params[param]));
 
   ORC_ASM_CODE(compiler,"  vld1.8 %s[], [%s]\n",
-      neon_reg_name (dest), arm_reg_name (neon_tmp_reg));
+      orc_neon_reg_name (dest), orc_arm_reg_name (neon_tmp_reg));
   code = 0xf4a00c0f;
   code |= (neon_tmp_reg&0xf) << 16;
   code |= (dest&0xf) << 12;
   code |= ((dest>>4)&0x1) << 22;
-  arm_emit (compiler, code);
+  orc_arm_emit (compiler, code);
 }
 
 void
-neon_emit_loadpw (OrcCompiler *compiler, int dest, int param)
+orc_neon_emit_loadpw (OrcCompiler *compiler, int dest, int param)
 {
   uint32_t code;
 
-  arm_emit_add_imm (compiler, neon_tmp_reg,
+  orc_arm_emit_add_imm (compiler, neon_tmp_reg,
       neon_exec_ptr, ORC_STRUCT_OFFSET(OrcExecutor, params[param]));
 
   ORC_ASM_CODE(compiler,"  vld1.16 %s[], [%s]\n",
-      neon_reg_name (dest), arm_reg_name (neon_tmp_reg));
+      orc_neon_reg_name (dest), orc_arm_reg_name (neon_tmp_reg));
   code = 0xf4a00c4f;
   code |= (neon_tmp_reg&0xf) << 16;
   code |= (dest&0xf) << 12;
   code |= ((dest>>4)&0x1) << 22;
-  arm_emit (compiler, code);
+  orc_arm_emit (compiler, code);
 }
 
 void
-neon_emit_loadpl (OrcCompiler *compiler, int dest, int param)
+orc_neon_emit_loadpl (OrcCompiler *compiler, int dest, int param)
 {
   uint32_t code;
 
-  arm_emit_add_imm (compiler, neon_tmp_reg,
+  orc_arm_emit_add_imm (compiler, neon_tmp_reg,
       neon_exec_ptr, ORC_STRUCT_OFFSET(OrcExecutor, params[param]));
 
   ORC_ASM_CODE(compiler,"  vld1.32 %s[], [%s]\n",
-      neon_reg_name (dest), arm_reg_name (neon_tmp_reg));
+      orc_neon_reg_name (dest), orc_arm_reg_name (neon_tmp_reg));
   code = 0xf4a00c8f;
   code |= (neon_tmp_reg&0xf) << 16;
   code |= (dest&0xf) << 12;
   code |= ((dest>>4)&0x1) << 22;
-  arm_emit (compiler, code);
+  orc_arm_emit (compiler, code);
 }
 
 #define UNARY(opcode,insn_name,code) \
 static void \
-neon_rule_ ## opcode (OrcCompiler *p, void *user, OrcInstruction *insn) \
+orc_neon_rule_ ## opcode (OrcCompiler *p, void *user, OrcInstruction *insn) \
 { \
   uint32_t x = code; \
   ORC_ASM_CODE(p,"  " insn_name " %s, %s\n", \
-      neon_reg_name (p->vars[insn->dest_args[0]].alloc), \
-      neon_reg_name (p->vars[insn->src_args[0]].alloc)); \
+      orc_neon_reg_name (p->vars[insn->dest_args[0]].alloc), \
+      orc_neon_reg_name (p->vars[insn->src_args[0]].alloc)); \
   x |= (p->vars[insn->dest_args[0]].alloc&0xf)<<12; \
   x |= ((p->vars[insn->dest_args[0]].alloc>>4)&0x1)<<22; \
   x |= (p->vars[insn->src_args[0]].alloc&0xf)<<0; \
   x |= ((p->vars[insn->src_args[0]].alloc>>4)&0x1)<<5; \
-  arm_emit (p, x); \
+  orc_arm_emit (p, x); \
 }
 
 #define UNARY_LONG(opcode,insn_name,code) \
 static void \
-neon_rule_ ## opcode (OrcCompiler *p, void *user, OrcInstruction *insn) \
+orc_neon_rule_ ## opcode (OrcCompiler *p, void *user, OrcInstruction *insn) \
 { \
   uint32_t x = code; \
   ORC_ASM_CODE(p,"  " insn_name " %s, %s\n", \
-      neon_reg_name_quad (p->vars[insn->dest_args[0]].alloc), \
-      neon_reg_name (p->vars[insn->src_args[0]].alloc)); \
+      orc_neon_reg_name_quad (p->vars[insn->dest_args[0]].alloc), \
+      orc_neon_reg_name (p->vars[insn->src_args[0]].alloc)); \
   x |= (p->vars[insn->dest_args[0]].alloc&0xf)<<12; \
   x |= ((p->vars[insn->dest_args[0]].alloc>>4)&0x1)<<22; \
   x |= (p->vars[insn->src_args[0]].alloc&0xf)<<0; \
   x |= ((p->vars[insn->src_args[0]].alloc>>4)&0x1)<<5; \
-  arm_emit (p, x); \
+  orc_arm_emit (p, x); \
 }
 
 #define UNARY_NARROW(opcode,insn_name,code) \
 static void \
-neon_rule_ ## opcode (OrcCompiler *p, void *user, OrcInstruction *insn) \
+orc_neon_rule_ ## opcode (OrcCompiler *p, void *user, OrcInstruction *insn) \
 { \
   uint32_t x = code; \
   ORC_ASM_CODE(p,"  " insn_name " %s, %s\n", \
-      neon_reg_name (p->vars[insn->dest_args[0]].alloc), \
-      neon_reg_name_quad (p->vars[insn->src_args[0]].alloc)); \
+      orc_neon_reg_name (p->vars[insn->dest_args[0]].alloc), \
+      orc_neon_reg_name_quad (p->vars[insn->src_args[0]].alloc)); \
   x |= (p->vars[insn->dest_args[0]].alloc&0xf)<<12; \
   x |= ((p->vars[insn->dest_args[0]].alloc>>4)&0x1)<<22; \
   x |= (p->vars[insn->src_args[0]].alloc&0xf)<<0; \
   x |= ((p->vars[insn->src_args[0]].alloc>>4)&0x1)<<5; \
-  arm_emit (p, x); \
+  orc_arm_emit (p, x); \
 }
 
 #define BINARY(opcode,insn_name,code) \
 static void \
-neon_rule_ ## opcode (OrcCompiler *p, void *user, OrcInstruction *insn) \
+orc_neon_rule_ ## opcode (OrcCompiler *p, void *user, OrcInstruction *insn) \
 { \
   uint32_t x = code; \
   ORC_ASM_CODE(p,"  " insn_name " %s, %s, %s\n", \
-      neon_reg_name (p->vars[insn->dest_args[0]].alloc), \
-      neon_reg_name (p->vars[insn->src_args[0]].alloc), \
-      neon_reg_name (p->vars[insn->src_args[1]].alloc)); \
+      orc_neon_reg_name (p->vars[insn->dest_args[0]].alloc), \
+      orc_neon_reg_name (p->vars[insn->src_args[0]].alloc), \
+      orc_neon_reg_name (p->vars[insn->src_args[1]].alloc)); \
   x |= (p->vars[insn->dest_args[0]].alloc&0xf)<<16; \
   x |= ((p->vars[insn->dest_args[0]].alloc>>4)&0x1)<<7; \
   x |= (p->vars[insn->src_args[0]].alloc&0xf)<<12; \
   x |= ((p->vars[insn->src_args[0]].alloc>>4)&0x1)<<22; \
   x |= (p->vars[insn->src_args[1]].alloc&0xf)<<0; \
   x |= ((p->vars[insn->src_args[1]].alloc>>4)&0x1)<<5; \
-  arm_emit (p, x); \
+  orc_arm_emit (p, x); \
 }
 
 #define BINARY_LONG(opcode,insn_name,code) \
 static void \
-neon_rule_ ## opcode (OrcCompiler *p, void *user, OrcInstruction *insn) \
+orc_neon_rule_ ## opcode (OrcCompiler *p, void *user, OrcInstruction *insn) \
 { \
   uint32_t x = code; \
   ORC_ASM_CODE(p,"  " insn_name " %s, %s, %s\n", \
-      neon_reg_name_quad (p->vars[insn->dest_args[0]].alloc), \
-      neon_reg_name (p->vars[insn->src_args[0]].alloc), \
-      neon_reg_name (p->vars[insn->src_args[1]].alloc)); \
+      orc_neon_reg_name_quad (p->vars[insn->dest_args[0]].alloc), \
+      orc_neon_reg_name (p->vars[insn->src_args[0]].alloc), \
+      orc_neon_reg_name (p->vars[insn->src_args[1]].alloc)); \
   x |= (p->vars[insn->dest_args[0]].alloc&0xf)<<16; \
   x |= ((p->vars[insn->dest_args[0]].alloc>>4)&0x1)<<7; \
   x |= (p->vars[insn->src_args[0]].alloc&0xf)<<12; \
   x |= ((p->vars[insn->src_args[0]].alloc>>4)&0x1)<<22; \
   x |= (p->vars[insn->src_args[1]].alloc&0xf)<<0; \
   x |= ((p->vars[insn->src_args[1]].alloc>>4)&0x1)<<5; \
-  arm_emit (p, x); \
+  orc_arm_emit (p, x); \
 }
 
 #define BINARY_NARROW(opcode,insn_name,code) \
 static void \
-neon_rule_ ## opcode (OrcCompiler *p, void *user, OrcInstruction *insn) \
+orc_neon_rule_ ## opcode (OrcCompiler *p, void *user, OrcInstruction *insn) \
 { \
   uint32_t x = code; \
   ORC_ASM_CODE(p,"  " insn_name " %s, %s, %s\n", \
-      neon_reg_name (p->vars[insn->dest_args[0]].alloc), \
-      neon_reg_name_quad (p->vars[insn->src_args[0]].alloc), \
-      neon_reg_name_quad (p->vars[insn->src_args[1]].alloc)); \
+      orc_neon_reg_name (p->vars[insn->dest_args[0]].alloc), \
+      orc_neon_reg_name_quad (p->vars[insn->src_args[0]].alloc), \
+      orc_neon_reg_name_quad (p->vars[insn->src_args[1]].alloc)); \
   x |= (p->vars[insn->dest_args[0]].alloc&0xf)<<16; \
   x |= ((p->vars[insn->dest_args[0]].alloc>>4)&0x1)<<7; \
   x |= (p->vars[insn->src_args[0]].alloc&0xf)<<12; \
   x |= ((p->vars[insn->src_args[0]].alloc>>4)&0x1)<<22; \
   x |= (p->vars[insn->src_args[1]].alloc&0xf)<<0; \
   x |= ((p->vars[insn->src_args[1]].alloc>>4)&0x1)<<5; \
-  arm_emit (p, x); \
+  orc_arm_emit (p, x); \
 }
 
 #define MOVE(opcode,insn_name,code) \
 static void \
-neon_rule_ ## opcode (OrcCompiler *p, void *user, OrcInstruction *insn) \
+orc_neon_rule_ ## opcode (OrcCompiler *p, void *user, OrcInstruction *insn) \
 { \
   uint32_t x = code; \
   ORC_ASM_CODE(p,"  " insn_name " %s, %s\n", \
-      neon_reg_name (p->vars[insn->dest_args[0]].alloc), \
-      neon_reg_name (p->vars[insn->src_args[0]].alloc)); \
+      orc_neon_reg_name (p->vars[insn->dest_args[0]].alloc), \
+      orc_neon_reg_name (p->vars[insn->src_args[0]].alloc)); \
   x |= (p->vars[insn->dest_args[0]].alloc&0xf)<<16; \
   x |= ((p->vars[insn->dest_args[0]].alloc>>4)&0x1)<<7; \
   x |= (p->vars[insn->src_args[0]].alloc&0xf)<<12; \
   x |= ((p->vars[insn->src_args[0]].alloc>>4)&0x1)<<22; \
   x |= (p->vars[insn->src_args[0]].alloc&0xf)<<0; \
   x |= ((p->vars[insn->src_args[0]].alloc>>4)&0x1)<<5; \
-  arm_emit (p, x); \
+  orc_arm_emit (p, x); \
 }
 
 #if 0
 #define LSHIFT(opcode,insn_name,code) \
 static void \
-neon_rule_ ## opcode (OrcCompiler *p, void *user, OrcInstruction *insn) \
+orc_neon_rule_ ## opcode (OrcCompiler *p, void *user, OrcInstruction *insn) \
 { \
   uint32_t x = code; \
   if (p->vars[insn->src_args[1]].vartype == ORC_VAR_TYPE_CONST) { \
     ORC_ASM_CODE(p,"  " insn_name " %s, %s, #%d\n", \
-        neon_reg_name (p->vars[insn->dest_args[0]].alloc), \
-        neon_reg_name (p->vars[insn->src_args[0]].alloc), \
+        orc_neon_reg_name (p->vars[insn->dest_args[0]].alloc), \
+        orc_neon_reg_name (p->vars[insn->src_args[0]].alloc), \
         p->vars[insn->src_args[1]].value); \
     x |= (p->vars[insn->dest_args[0]].alloc&0xf)<<12; \
     x |= ((p->vars[insn->dest_args[0]].alloc>>4)&0x1)<<22; \
     x |= (p->vars[insn->src_args[0]].alloc&0xf)<<0; \
     x |= ((p->vars[insn->src_args[0]].alloc>>4)&0x1)<<5; \
     x |= p->vars[insn->src_args[1]].value << 16; \
-    arm_emit (p, x); \
+    orc_arm_emit (p, x); \
   } else { \
     ORC_PROGRAM_ERROR(p,"shift rule only works with constants"); \
   } \
@@ -558,32 +558,32 @@ neon_rule_ ## opcode (OrcCompiler *p, void *user, OrcInstruction *insn) \
 
 #define RSHIFT(opcode,insn_name,code,n) \
 static void \
-neon_rule_ ## opcode (OrcCompiler *p, void *user, OrcInstruction *insn) \
+orc_neon_rule_ ## opcode (OrcCompiler *p, void *user, OrcInstruction *insn) \
 { \
   uint32_t x = code; \
   if (p->vars[insn->src_args[1]].vartype == ORC_VAR_TYPE_CONST) { \
     ORC_ASM_CODE(p,"  " insn_name " %s, %s, #%d\n", \
-        neon_reg_name (p->vars[insn->dest_args[0]].alloc), \
-        neon_reg_name (p->vars[insn->src_args[0]].alloc), \
+        orc_neon_reg_name (p->vars[insn->dest_args[0]].alloc), \
+        orc_neon_reg_name (p->vars[insn->src_args[0]].alloc), \
         p->vars[insn->src_args[1]].value); \
     x |= (p->vars[insn->dest_args[0]].alloc&0xf)<<12; \
     x |= ((p->vars[insn->dest_args[0]].alloc>>4)&0x1)<<22; \
     x |= (p->vars[insn->src_args[0]].alloc&0xf)<<0; \
     x |= ((p->vars[insn->src_args[0]].alloc>>4)&0x1)<<5; \
     x |= ((n - p->vars[insn->src_args[1]].value)&(n-1))<<16; \
-    arm_emit (p, x); \
+    orc_arm_emit (p, x); \
   } else if (p->vars[insn->src_args[1]].vartype == ORC_VAR_TYPE_PARAM) { \
     ORC_ASM_CODE(p,"  " insn_name " %s, %s, %s\n", \
-        neon_reg_name (p->vars[insn->dest_args[0]].alloc), \
-        neon_reg_name (p->vars[insn->src_args[0]].alloc), \
-        neon_reg_name (p->vars[insn->src_args[1]].alloc)); \
+        orc_neon_reg_name (p->vars[insn->dest_args[0]].alloc), \
+        orc_neon_reg_name (p->vars[insn->src_args[0]].alloc), \
+        orc_neon_reg_name (p->vars[insn->src_args[1]].alloc)); \
     x |= (p->vars[insn->dest_args[0]].alloc&0xf)<<12; \
     x |= ((p->vars[insn->dest_args[0]].alloc>>4)&0x1)<<22; \
     x |= (p->vars[insn->src_args[0]].alloc&0xf)<<0; \
     x |= ((p->vars[insn->src_args[0]].alloc>>4)&0x1)<<5; \
     x |= (p->vars[insn->src_args[1]].alloc)<<16; \
     x |= ((p->vars[insn->src_args[1]].alloc>>4))<<7; \
-    arm_emit (p, x); \
+    orc_arm_emit (p, x); \
   } else { \
     ORC_PROGRAM_ERROR(p,"shift rule only works with constants and params"); \
   } \
@@ -620,7 +620,7 @@ ShiftInfo regshift_info[] = {
 };
 
 static void
-neon_rule_shift (OrcCompiler *p, void *user, OrcInstruction *insn)
+orc_neon_rule_shift (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
   int type = (int)user;
   uint32_t code;
@@ -630,8 +630,8 @@ neon_rule_shift (OrcCompiler *p, void *user, OrcInstruction *insn)
     code = immshift_info[type].code;
     ORC_ASM_CODE(p,"  %s %s, %s, #%d\n",
         immshift_info[type].name,
-        neon_reg_name (p->vars[insn->dest_args[0]].alloc),
-        neon_reg_name (p->vars[insn->src_args[0]].alloc),
+        orc_neon_reg_name (p->vars[insn->dest_args[0]].alloc),
+        orc_neon_reg_name (p->vars[insn->src_args[0]].alloc),
         p->vars[insn->src_args[1]].value);
     code |= (p->vars[insn->dest_args[0]].alloc&0xf)<<12;
     code |= ((p->vars[insn->dest_args[0]].alloc>>4)&0x1)<<22;
@@ -641,27 +641,27 @@ neon_rule_shift (OrcCompiler *p, void *user, OrcInstruction *insn)
       shift = immshift_info[type].bits - shift;
     }
     code |= shift<<16;
-    arm_emit (p, code);
+    orc_arm_emit (p, code);
   } else if (p->vars[insn->src_args[1]].vartype == ORC_VAR_TYPE_PARAM) {
-    neon_emit_loadpb (p, p->tmpreg, insn->src_args[1]);
+    orc_neon_emit_loadpb (p, p->tmpreg, insn->src_args[1]);
 
     if (regshift_info[type].negate) {
-      neon_emit_neg (p, p->tmpreg);
+      orc_neon_emit_neg (p, p->tmpreg);
     }
 
     code = regshift_info[type].code;
     ORC_ASM_CODE(p,"  %s %s, %s, %s\n",
         regshift_info[type].name,
-        neon_reg_name (p->vars[insn->dest_args[0]].alloc),
-        neon_reg_name (p->vars[insn->src_args[0]].alloc),
-        neon_reg_name (p->tmpreg));
+        orc_neon_reg_name (p->vars[insn->dest_args[0]].alloc),
+        orc_neon_reg_name (p->vars[insn->src_args[0]].alloc),
+        orc_neon_reg_name (p->tmpreg));
     code |= (p->vars[insn->dest_args[0]].alloc&0xf)<<12;
     code |= ((p->vars[insn->dest_args[0]].alloc>>4)&0x1)<<22;
     code |= (p->vars[insn->src_args[0]].alloc&0xf)<<0;
     code |= ((p->vars[insn->src_args[0]].alloc>>4)&0x1)<<5;
     code |= (p->tmpreg&0xf)<<16;
     code |= ((p->tmpreg>>4)&0x1)<<7;
-    arm_emit (p, code);
+    orc_arm_emit (p, code);
   } else {
     ORC_PROGRAM_ERROR(p,"shift rule only works with constants and params");
   }
@@ -669,68 +669,68 @@ neon_rule_shift (OrcCompiler *p, void *user, OrcInstruction *insn)
 
 #if 0
 static void
-neon_rule_shrsw (OrcCompiler *p, void *user, OrcInstruction *insn)
+orc_neon_rule_shrsw (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
   uint32_t code;
   if (p->vars[insn->src_args[1]].vartype == ORC_VAR_TYPE_CONST) {
     code = 0xf2900010;
     ORC_ASM_CODE(p,"  vshr.s16 %s, %s, #%d\n",
-        neon_reg_name (p->vars[insn->dest_args[0]].alloc),
-        neon_reg_name (p->vars[insn->src_args[0]].alloc),
+        orc_neon_reg_name (p->vars[insn->dest_args[0]].alloc),
+        orc_neon_reg_name (p->vars[insn->src_args[0]].alloc),
         p->vars[insn->src_args[1]].value);
     code |= (p->vars[insn->dest_args[0]].alloc&0xf)<<12;
     code |= ((p->vars[insn->dest_args[0]].alloc>>4)&0x1)<<22;
     code |= (p->vars[insn->src_args[0]].alloc&0xf)<<0;
     code |= ((p->vars[insn->src_args[0]].alloc>>4)&0x1)<<5;
     code |= ((16 - p->vars[insn->src_args[1]].value)&0xf)<<16;
-    arm_emit (p, code);
+    orc_arm_emit (p, code);
   } else if (p->vars[insn->src_args[1]].vartype == ORC_VAR_TYPE_PARAM) {
     code = 0xf2100400;
     ORC_ASM_CODE(p,"  vshl.s16 %s, %s, %s\n",
-        neon_reg_name (p->vars[insn->dest_args[0]].alloc),
-        neon_reg_name (p->vars[insn->src_args[0]].alloc),
-        neon_reg_name (p->vars[insn->src_args[1]].alloc));
+        orc_neon_reg_name (p->vars[insn->dest_args[0]].alloc),
+        orc_neon_reg_name (p->vars[insn->src_args[0]].alloc),
+        orc_neon_reg_name (p->vars[insn->src_args[1]].alloc));
     code |= (p->vars[insn->dest_args[0]].alloc&0xf)<<12;
     code |= ((p->vars[insn->dest_args[0]].alloc>>4)&0x1)<<22;
     code |= (p->vars[insn->src_args[0]].alloc&0xf)<<0;
     code |= ((p->vars[insn->src_args[0]].alloc>>4)&0x1)<<5;
     code |= (p->vars[insn->src_args[1]].alloc&0xf)<<16;
     code |= ((p->vars[insn->src_args[1]].alloc>>4)&0x1)<<7;
-    arm_emit (p, code);
+    orc_arm_emit (p, code);
   } else {
     ORC_PROGRAM_ERROR(p,"shift rule only works with constants and params");
   }
 }
 
 static void
-neon_rule_shrsl (OrcCompiler *p, void *user, OrcInstruction *insn)
+orc_neon_rule_shrsl (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
   uint32_t code;
   if (p->vars[insn->src_args[1]].vartype == ORC_VAR_TYPE_CONST) {
     code = 0xf2900010;
     ORC_ASM_CODE(p,"  vshr.s32 %s, %s, #%d\n",
-        neon_reg_name (p->vars[insn->dest_args[0]].alloc),
-        neon_reg_name (p->vars[insn->src_args[0]].alloc),
+        orc_neon_reg_name (p->vars[insn->dest_args[0]].alloc),
+        orc_neon_reg_name (p->vars[insn->src_args[0]].alloc),
         p->vars[insn->src_args[1]].value);
     code |= (p->vars[insn->dest_args[0]].alloc&0xf)<<12;
     code |= ((p->vars[insn->dest_args[0]].alloc>>4)&0x1)<<22;
     code |= (p->vars[insn->src_args[0]].alloc&0xf)<<0;
     code |= ((p->vars[insn->src_args[0]].alloc>>4)&0x1)<<5;
     code |= ((16 - p->vars[insn->src_args[1]].value)&0xf)<<16;
-    arm_emit (p, code);
+    orc_arm_emit (p, code);
   } else if (p->vars[insn->src_args[1]].vartype == ORC_VAR_TYPE_PARAM) {
     code = 0xf2100400;
     ORC_ASM_CODE(p,"  vshl.s32 %s, %s, %s\n",
-        neon_reg_name (p->vars[insn->dest_args[0]].alloc),
-        neon_reg_name (p->vars[insn->src_args[0]].alloc),
-        neon_reg_name (p->vars[insn->src_args[1]].alloc));
+        orc_neon_reg_name (p->vars[insn->dest_args[0]].alloc),
+        orc_neon_reg_name (p->vars[insn->src_args[0]].alloc),
+        orc_neon_reg_name (p->vars[insn->src_args[1]].alloc));
     code |= (p->vars[insn->dest_args[0]].alloc&0xf)<<12;
     code |= ((p->vars[insn->dest_args[0]].alloc>>4)&0x1)<<22;
     code |= (p->vars[insn->src_args[0]].alloc&0xf)<<0;
     code |= ((p->vars[insn->src_args[0]].alloc>>4)&0x1)<<5;
     code |= (p->vars[insn->src_args[1]].alloc&0xf)<<16;
     code |= ((p->vars[insn->src_args[1]].alloc>>4)&0x1)<<7;
-    arm_emit (p, code);
+    orc_arm_emit (p, code);
   } else {
     ORC_PROGRAM_ERROR(p,"shift rule only works with constants and params");
   }
@@ -739,21 +739,21 @@ neon_rule_shrsl (OrcCompiler *p, void *user, OrcInstruction *insn)
 
 
 static void
-neon_rule_andn (OrcCompiler *p, void *user, OrcInstruction *insn)
+orc_neon_rule_andn (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
   uint32_t x = 0xf2100110;
   /* this is special because the operand order is reversed */
   ORC_ASM_CODE(p,"  vbic %s, %s, %s\n",
-      neon_reg_name (p->vars[insn->dest_args[0]].alloc),
-      neon_reg_name (p->vars[insn->src_args[1]].alloc),
-      neon_reg_name (p->vars[insn->src_args[0]].alloc));
+      orc_neon_reg_name (p->vars[insn->dest_args[0]].alloc),
+      orc_neon_reg_name (p->vars[insn->src_args[1]].alloc),
+      orc_neon_reg_name (p->vars[insn->src_args[0]].alloc));
   x |= (p->vars[insn->dest_args[0]].alloc&0xf)<<12;
   x |= ((p->vars[insn->dest_args[0]].alloc>>4)&0x1)<<22;
   x |= (p->vars[insn->src_args[1]].alloc&0xf)<<16;
   x |= ((p->vars[insn->src_args[1]].alloc>>4)&0x1)<<7;
   x |= (p->vars[insn->src_args[0]].alloc&0xf)<<0;
   x |= ((p->vars[insn->src_args[0]].alloc>>4)&0x1)<<5;
-  arm_emit (p, x);
+  orc_arm_emit (p, x);
 }
 
 
@@ -860,128 +860,128 @@ UNARY(mergebw,"vzip.8",0xf3b20180)
 UNARY(mergewl,"vzip.16",0xf3b60180)
 
 static void
-neon_emit_binary (OrcCompiler *p, const char *name, unsigned int code,
+orc_neon_emit_binary (OrcCompiler *p, const char *name, unsigned int code,
     int dest, int src1, int src2)
 {
   ORC_ASM_CODE(p,"  %s %s, %s, %s\n", name,
-      neon_reg_name (dest), neon_reg_name (src1), neon_reg_name (src2));
+      orc_neon_reg_name (dest), orc_neon_reg_name (src1), orc_neon_reg_name (src2));
   code |= (dest&0xf)<<16;
   code |= ((dest>>4)&0x1)<<7;
   code |= (src1&0xf)<<12;
   code |= ((src1>>4)&0x1)<<22;
   code |= (src2&0xf)<<0;
   code |= ((src2>>4)&0x1)<<5;
-  arm_emit (p, code);
+  orc_arm_emit (p, code);
 
 }
 
 static void
-neon_rule_accw (OrcCompiler *p, void *user, OrcInstruction *insn)
+orc_neon_rule_accw (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
-  neon_emit_binary (p, "vadd.i16", 0xf2100800,
+  orc_neon_emit_binary (p, "vadd.i16", 0xf2100800,
       p->vars[insn->dest_args[0]].alloc,
       p->vars[insn->dest_args[0]].alloc,
       p->vars[insn->src_args[0]].alloc);
 }
 
 static void
-neon_rule_accl (OrcCompiler *p, void *user, OrcInstruction *insn)
+orc_neon_rule_accl (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
-  neon_emit_binary (p, "vadd.i32", 0xf2200800,
+  orc_neon_emit_binary (p, "vadd.i32", 0xf2200800,
       p->vars[insn->dest_args[0]].alloc,
       p->vars[insn->dest_args[0]].alloc,
       p->vars[insn->src_args[0]].alloc);
 }
 
 static void
-neon_rule_select1wb (OrcCompiler *p, void *user, OrcInstruction *insn)
+orc_neon_rule_select1wb (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
   uint32_t x;
   
   x = 0xf3b00100;
   ORC_ASM_CODE(p,"  vrev16.i8 %s, %s\n",
-      neon_reg_name (p->vars[insn->dest_args[0]].alloc),
-      neon_reg_name (p->vars[insn->src_args[0]].alloc));
+      orc_neon_reg_name (p->vars[insn->dest_args[0]].alloc),
+      orc_neon_reg_name (p->vars[insn->src_args[0]].alloc));
   x |= (p->vars[insn->dest_args[0]].alloc&0xf)<<12;
   x |= ((p->vars[insn->dest_args[0]].alloc>>4)&0x1)<<22;
   //x |= (p->vars[insn->src_args[0]].alloc&0xf)<<16;
   //x |= ((p->vars[insn->src_args[0]].alloc>>4)&0x1)<<7;
   x |= (p->vars[insn->src_args[0]].alloc&0xf)<<0;
   x |= ((p->vars[insn->src_args[0]].alloc>>4)&0x1)<<5;
-  arm_emit (p, x);
+  orc_arm_emit (p, x);
 
   x = 0xf3b20200;
   ORC_ASM_CODE(p,"  vmovn.i16 %s, %s\n",
-      neon_reg_name (p->vars[insn->dest_args[0]].alloc),
-      neon_reg_name_quad (p->vars[insn->src_args[0]].alloc));
+      orc_neon_reg_name (p->vars[insn->dest_args[0]].alloc),
+      orc_neon_reg_name_quad (p->vars[insn->src_args[0]].alloc));
   x |= (p->vars[insn->dest_args[0]].alloc&0xf)<<12;
   x |= ((p->vars[insn->dest_args[0]].alloc>>4)&0x1)<<22;
   //x |= (p->vars[insn->src_args[0]].alloc&0xf)<<16;
   //x |= ((p->vars[insn->src_args[0]].alloc>>4)&0x1)<<7;
   x |= (p->vars[insn->src_args[0]].alloc&0xf)<<0;
   x |= ((p->vars[insn->src_args[0]].alloc>>4)&0x1)<<5;
-  arm_emit (p, x);
+  orc_arm_emit (p, x);
 }
 
 static void
-neon_rule_select1lw (OrcCompiler *p, void *user, OrcInstruction *insn)
+orc_neon_rule_select1lw (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
   uint32_t x;
   
   x = 0xf3b40080;
   ORC_ASM_CODE(p,"  vrev32.i16 %s, %s\n",
-      neon_reg_name (p->vars[insn->dest_args[0]].alloc),
-      neon_reg_name (p->vars[insn->src_args[0]].alloc));
+      orc_neon_reg_name (p->vars[insn->dest_args[0]].alloc),
+      orc_neon_reg_name (p->vars[insn->src_args[0]].alloc));
   x |= (p->vars[insn->dest_args[0]].alloc&0xf)<<12;
   x |= ((p->vars[insn->dest_args[0]].alloc>>4)&0x1)<<22;
   //x |= (p->vars[insn->src_args[1]].alloc&0xf)<<16;
   //x |= ((p->vars[insn->src_args[1]].alloc>>4)&0x1)<<7;
   x |= (p->vars[insn->src_args[0]].alloc&0xf)<<0;
   x |= ((p->vars[insn->src_args[0]].alloc>>4)&0x1)<<5;
-  arm_emit (p, x);
+  orc_arm_emit (p, x);
 
   x = 0xf3b60200;
   ORC_ASM_CODE(p,"  vmovn.i32 %s, %s\n",
-      neon_reg_name (p->vars[insn->dest_args[0]].alloc),
-      neon_reg_name_quad (p->vars[insn->src_args[0]].alloc));
+      orc_neon_reg_name (p->vars[insn->dest_args[0]].alloc),
+      orc_neon_reg_name_quad (p->vars[insn->src_args[0]].alloc));
   x |= (p->vars[insn->dest_args[0]].alloc&0xf)<<12;
   x |= ((p->vars[insn->dest_args[0]].alloc>>4)&0x1)<<22;
   //x |= (p->vars[insn->src_args[0]].alloc&0xf)<<16;
   //x |= ((p->vars[insn->src_args[0]].alloc>>4)&0x1)<<7;
   x |= (p->vars[insn->src_args[0]].alloc&0xf)<<0;
   x |= ((p->vars[insn->src_args[0]].alloc>>4)&0x1)<<5;
-  arm_emit (p, x);
+  orc_arm_emit (p, x);
 }
 
 static void
-neon_rule_accsadubl (OrcCompiler *p, void *user, OrcInstruction *insn)
+orc_neon_rule_accsadubl (OrcCompiler *p, void *user, OrcInstruction *insn)
 {
   uint32_t x;
   
-  x = 0xf3840700;
+  x = 0xf3800700;
   ORC_ASM_CODE(p,"  vabdl.u8 %s, %s, %s\n",
-      neon_reg_name_quad (p->tmpreg),
-      neon_reg_name (p->vars[insn->src_args[0]].alloc),
-      neon_reg_name (p->vars[insn->src_args[1]].alloc));
+      orc_neon_reg_name_quad (p->tmpreg),
+      orc_neon_reg_name (p->vars[insn->src_args[0]].alloc),
+      orc_neon_reg_name (p->vars[insn->src_args[1]].alloc));
   x |= (p->tmpreg&0xf)<<12;
   x |= ((p->tmpreg>>4)&0x1)<<22;
   x |= (p->vars[insn->src_args[0]].alloc&0xf)<<16;
   x |= ((p->vars[insn->src_args[0]].alloc>>4)&0x1)<<7;
   x |= (p->vars[insn->src_args[1]].alloc&0xf)<<0;
   x |= ((p->vars[insn->src_args[1]].alloc>>4)&0x1)<<5;
-  arm_emit (p, x);
+  orc_arm_emit (p, x);
 
   x = 0xf3b40680;
   ORC_ASM_CODE(p,"  vpadal.u16 %s, %s\n",
-      neon_reg_name (p->vars[insn->dest_args[0]].alloc),
-      neon_reg_name (p->tmpreg));
+      orc_neon_reg_name (p->vars[insn->dest_args[0]].alloc),
+      orc_neon_reg_name (p->tmpreg));
   x |= (p->vars[insn->dest_args[0]].alloc&0xf)<<12;
   x |= ((p->vars[insn->dest_args[0]].alloc>>4)&0x1)<<22;
   //x |= (p->vars[insn->src_args[0]].alloc&0xf)<<16;
   //x |= ((p->vars[insn->src_args[0]].alloc>>4)&0x1)<<7;
   x |= (p->tmpreg&0xf)<<0;
   x |= ((p->tmpreg>>4)&0x1)<<5;
-  arm_emit (p, x);
+  orc_arm_emit (p, x);
 }
 
 void
@@ -992,7 +992,7 @@ orc_compiler_neon_register_rules (OrcTarget *target)
   rule_set = orc_rule_set_new (orc_opcode_set_get("sys"), target, 0);
 
 #define REG(x) \
-    orc_rule_register (rule_set, #x , neon_rule_ ## x, NULL)
+    orc_rule_register (rule_set, #x , orc_neon_rule_ ## x, NULL)
 
   REG(absb);
   REG(addb);
@@ -1099,18 +1099,18 @@ orc_compiler_neon_register_rules (OrcTarget *target)
   REG(mergebw);
   REG(mergewl);
 
-  orc_rule_register (rule_set, "shlb", neon_rule_shift, (void *)0);
-  orc_rule_register (rule_set, "shrsb", neon_rule_shift, (void *)1);
-  orc_rule_register (rule_set, "shrub", neon_rule_shift, (void *)2);
-  orc_rule_register (rule_set, "shlw", neon_rule_shift, (void *)3);
-  orc_rule_register (rule_set, "shrsw", neon_rule_shift, (void *)4);
-  orc_rule_register (rule_set, "shruw", neon_rule_shift, (void *)5);
-  orc_rule_register (rule_set, "shll", neon_rule_shift, (void *)6);
-  orc_rule_register (rule_set, "shrsl", neon_rule_shift, (void *)7);
-  orc_rule_register (rule_set, "shrul", neon_rule_shift, (void *)8);
-
-  orc_rule_register (rule_set, "andnb", neon_rule_andn, NULL);
-  orc_rule_register (rule_set, "andnw", neon_rule_andn, NULL);
-  orc_rule_register (rule_set, "andnl", neon_rule_andn, NULL);
+  orc_rule_register (rule_set, "shlb", orc_neon_rule_shift, (void *)0);
+  orc_rule_register (rule_set, "shrsb", orc_neon_rule_shift, (void *)1);
+  orc_rule_register (rule_set, "shrub", orc_neon_rule_shift, (void *)2);
+  orc_rule_register (rule_set, "shlw", orc_neon_rule_shift, (void *)3);
+  orc_rule_register (rule_set, "shrsw", orc_neon_rule_shift, (void *)4);
+  orc_rule_register (rule_set, "shruw", orc_neon_rule_shift, (void *)5);
+  orc_rule_register (rule_set, "shll", orc_neon_rule_shift, (void *)6);
+  orc_rule_register (rule_set, "shrsl", orc_neon_rule_shift, (void *)7);
+  orc_rule_register (rule_set, "shrul", orc_neon_rule_shift, (void *)8);
+
+  orc_rule_register (rule_set, "andnb", orc_neon_rule_andn, NULL);
+  orc_rule_register (rule_set, "andnw", orc_neon_rule_andn, NULL);
+  orc_rule_register (rule_set, "andnl", orc_neon_rule_andn, NULL);
 }
 
-- 
2.7.4