const char *
-arm_reg_name (int reg)
+orc_arm_reg_name (int reg)
{
#if 0
static const char *gp_regs[] = {
}
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;
}
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;
}
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;
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);
}
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;
}
void
-arm_do_fixups (OrcCompiler *compiler)
+orc_arm_do_fixups (OrcCompiler *compiler)
{
int i;
for(i=0;i<compiler->n_fixups;i++){
}
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",
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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[] = {
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);
}
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
#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
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);
void orc_compiler_dump (OrcCompiler *compiler);
void
-arm_emit_prologue (OrcCompiler *compiler)
+orc_arm_emit_prologue (OrcCompiler *compiler)
{
unsigned int regs = 0;
int i;
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;
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);
}
}
void
-arm_load_constants (OrcCompiler *compiler)
+orc_arm_load_constants (OrcCompiler *compiler)
{
int i;
for(i=0;i<ORC_N_VARIABLES;i++){
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;
}
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) {
//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;
}
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) {
//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;
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;
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;
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);
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;
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);
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);
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;
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;
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);
}
}
void
-neon_load_constants (OrcCompiler *compiler)
+orc_neon_load_constants (OrcCompiler *compiler)
{
int i;
for(i=0;i<ORC_N_VARIABLES;i++){
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");
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;
}
void
-neon_emit_load_src (OrcCompiler *compiler, OrcVariable *var)
+orc_neon_emit_load_src (OrcCompiler *compiler, OrcVariable *var)
{
int ptr_reg;
int update;
}
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");
}
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) {
}
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");
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;
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;
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;
#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
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;
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);
}
void
-neon_save_accumulators (OrcCompiler *compiler)
+orc_neon_save_accumulators (OrcCompiler *compiler)
{
int i;
int src;
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");
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;
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;
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;
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;
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;
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;
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),
}
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));
}
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),
}
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,
#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); \
}
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",
}
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",
}
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),
}
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 */
}
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),
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);
}
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",
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",
}
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;
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;
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;
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;
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;
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;
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;
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"); \
} \
#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"); \
} \
};
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;
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;
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");
}
#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");
}
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);
}
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
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);
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);
}