}
}
+ printf("%s", orc_program_get_asm_code (p));
+
orc_executor_free (ex);
orc_program_free (p);
}
}
void
-arm_emit (OrcProgram *program, uint32_t insn)
+arm_emit (OrcCompiler *compiler, uint32_t insn)
{
- ORC_WRITE_UINT32_LE (program->codeptr, insn);
- program->codeptr+=4;
+ ORC_WRITE_UINT32_LE (compiler->codeptr, insn);
+ compiler->codeptr+=4;
}
void
-arm_emit_bx_lr (OrcProgram *program)
+arm_emit_bx_lr (OrcCompiler *compiler)
{
- ORC_ASM_CODE(program," bx lr\n");
- arm_emit (program, 0xe12fff1e);
+ ORC_ASM_CODE(compiler," bx lr\n");
+ arm_emit (compiler, 0xe12fff1e);
}
void
-arm_emit_push (OrcProgram *program, int regs)
+arm_emit_push (OrcCompiler *compiler, int regs)
{
int i;
int x = 0;
- ORC_ASM_CODE(program," push {");
+ ORC_ASM_CODE(compiler," push {");
for(i=0;i<16;i++){
if (regs & (1<<i)) {
x |= (1<<i);
- ORC_ASM_CODE(program,"r%d", i);
+ ORC_ASM_CODE(compiler,"r%d", i);
if (x != regs) {
- ORC_ASM_CODE(program,", ");
+ ORC_ASM_CODE(compiler,", ");
}
}
}
- ORC_ASM_CODE(program,"}\n");
+ ORC_ASM_CODE(compiler,"}\n");
- arm_emit (program, 0xe92d0000 | regs);
+ arm_emit (compiler, 0xe92d0000 | regs);
}
void
-arm_emit_pop (OrcProgram *program, int regs)
+arm_emit_pop (OrcCompiler *compiler, int regs)
{
int i;
int x = 0;
- ORC_ASM_CODE(program," pop {");
+ ORC_ASM_CODE(compiler," pop {");
for(i=0;i<16;i++){
if (regs & (1<<i)) {
x |= (1<<i);
- ORC_ASM_CODE(program,"r%d", i);
+ ORC_ASM_CODE(compiler,"r%d", i);
if (x != regs) {
- ORC_ASM_CODE(program,", ");
+ ORC_ASM_CODE(compiler,", ");
}
}
}
- ORC_ASM_CODE(program,"}\n");
+ ORC_ASM_CODE(compiler,"}\n");
- arm_emit (program, 0xe8bd0000 | regs);
+ arm_emit (compiler, 0xe8bd0000 | regs);
}
void
-arm_emit_mov (OrcProgram *program, int dest, int src)
+arm_emit_mov (OrcCompiler *compiler, int dest, int src)
{
uint32_t code;
code |= (src&0xf) << 0;
code |= (dest&0xf) << 12;
- ORC_ASM_CODE(program," mov %s, %s\n", arm_reg_name (dest), arm_reg_name (src));
+ ORC_ASM_CODE(compiler," mov %s, %s\n", arm_reg_name (dest), arm_reg_name (src));
- arm_emit (program, code);
+ arm_emit (compiler, code);
}
void
-arm_emit_label (OrcProgram *program, int label)
+arm_emit_label (OrcCompiler *compiler, int label)
{
- ORC_ASM_CODE(program,".L%d:\n", label);
+ ORC_ASM_CODE(compiler,".L%d:\n", label);
- program->labels[label] = program->codeptr;
+ compiler->labels[label] = compiler->codeptr;
}
void
-arm_add_fixup (OrcProgram *program, int label, int type)
+arm_add_fixup (OrcCompiler *compiler, int label, int type)
{
- program->fixups[program->n_fixups].ptr = program->codeptr;
- program->fixups[program->n_fixups].label = label;
- program->fixups[program->n_fixups].type = type;
- program->n_fixups++;
+ compiler->fixups[compiler->n_fixups].ptr = compiler->codeptr;
+ compiler->fixups[compiler->n_fixups].label = label;
+ compiler->fixups[compiler->n_fixups].type = type;
+ compiler->n_fixups++;
}
void
-arm_do_fixups (OrcProgram *program)
+arm_do_fixups (OrcCompiler *compiler)
{
int i;
- for(i=0;i<program->n_fixups;i++){
- unsigned char *label = program->labels[program->fixups[i].label];
- unsigned char *ptr = program->fixups[i].ptr;
+ for(i=0;i<compiler->n_fixups;i++){
+ unsigned char *label = compiler->labels[compiler->fixups[i].label];
+ unsigned char *ptr = compiler->fixups[i].ptr;
uint32_t code;
int diff;
}
void
-arm_emit_branch (OrcProgram *program, int cond, int label)
+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 (program, label, 0);
- arm_emit (program, code);
+ arm_add_fixup (compiler, label, 0);
+ arm_emit (compiler, code);
- ORC_ASM_CODE(program," b%s .L%d\n", cond_names[cond], label);
+ ORC_ASM_CODE(compiler," b%s .L%d\n", cond_names[cond], label);
}
void
-arm_emit_loadimm (OrcProgram *program, int dest, int imm)
+arm_emit_loadimm (OrcCompiler *compiler, int dest, int imm)
{
uint32_t code;
int shift2;
code |= (((16-shift2)&0xf) << 8);
code |= (imm&0xff);
- ORC_ASM_CODE(program," mov %s, #0x%08x\n", arm_reg_name (dest), imm << (shift2*2));
- arm_emit (program, code);
+ ORC_ASM_CODE(compiler," mov %s, #0x%08x\n", arm_reg_name (dest), imm << (shift2*2));
+ arm_emit (compiler, code);
}
void
-arm_emit_add (OrcProgram *program, int dest, int src1, int src2)
+arm_emit_add (OrcCompiler *compiler, int dest, int src1, int src2)
{
uint32_t code;
code |= (dest&0xf) << 12;
code |= (src2&0xf) << 0;
- ORC_ASM_CODE(program," add %s, %s, %s\n",
+ ORC_ASM_CODE(compiler," add %s, %s, %s\n",
arm_reg_name (dest),
arm_reg_name (src1),
arm_reg_name (src2));
- arm_emit (program, code);
+ arm_emit (compiler, code);
}
void
-arm_emit_sub (OrcProgram *program, int dest, int src1, int src2)
+arm_emit_sub (OrcCompiler *compiler, int dest, int src1, int src2)
{
uint32_t code;
code |= (dest&0xf) << 12;
code |= (src2&0xf) << 0;
- ORC_ASM_CODE(program," sub %s, %s, %s\n",
+ ORC_ASM_CODE(compiler," sub %s, %s, %s\n",
arm_reg_name (dest),
arm_reg_name (src1),
arm_reg_name (src2));
- arm_emit (program, code);
+ arm_emit (compiler, code);
}
void
-arm_emit_sub_imm (OrcProgram *program, int dest, int src1, int value)
+arm_emit_sub_imm (OrcCompiler *compiler, int dest, int src1, int value)
{
uint32_t code;
code |= (dest&0xf) << 12;
code |= (value) << 0;
- ORC_ASM_CODE(program," subs %s, %s, #%d\n",
+ ORC_ASM_CODE(compiler," subs %s, %s, #%d\n",
arm_reg_name (dest),
arm_reg_name (src1),
value);
- arm_emit (program, code);
+ arm_emit (compiler, code);
}
void
-arm_emit_cmp_imm (OrcProgram *program, int src1, int value)
+arm_emit_cmp_imm (OrcCompiler *compiler, int src1, int value)
{
uint32_t code;
code |= (src1&0xf) << 16;
code |= (value) << 0;
- ORC_ASM_CODE(program," cmp %s, #%d\n",
+ ORC_ASM_CODE(compiler," cmp %s, #%d\n",
arm_reg_name (src1),
value);
- arm_emit (program, code);
+ arm_emit (compiler, code);
}
void
-arm_emit_load_reg (OrcProgram *program, int dest, int src1, int offset)
+arm_emit_load_reg (OrcCompiler *compiler, int dest, int src1, int offset)
{
uint32_t code;
code |= (dest&0xf) << 12;
code |= offset&0xfff;
- ORC_ASM_CODE(program," ldr %s, [%s, #%d]\n",
+ ORC_ASM_CODE(compiler," ldr %s, [%s, #%d]\n",
arm_reg_name (dest),
arm_reg_name (src1), offset);
- arm_emit (program, code);
+ arm_emit (compiler, code);
}
void
-arm_emit_dp_reg (OrcProgram *program, int cond, int opcode, int dest,
+arm_emit_dp_reg (OrcCompiler *compiler, int cond, int opcode, int dest,
int src1, int src2)
{
static const char *dp_insn_names[] = {
code |= (src2&0xf) << 0;
if (shift_expn[opcode]) {
- ORC_ASM_CODE(program," %s%s %s, %s\n",
+ ORC_ASM_CODE(compiler," %s%s %s, %s\n",
dp_insn_names[opcode],
update ? "s" : "",
arm_reg_name (src1),
arm_reg_name (src2));
} else {
- ORC_ASM_CODE(program," %s%s %s, %s, %s\n",
+ 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));
}
- arm_emit (program, code);
+ arm_emit (compiler, code);
}
ARM_COND_AL,
};
-void arm_emit (OrcProgram *program, uint32_t insn);
-void arm_emit_bx_lr (OrcProgram *program);
+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_loadimm (OrcProgram *program, int dest, int imm);
+void arm_emit_loadimm (OrcCompiler *compiler, int dest, int imm);
-void arm_emit_add (OrcProgram *program, int dest, int src1, int src2);
-void arm_emit_sub (OrcProgram *program, int dest, int src1, int src2);
-void arm_emit_sub_imm (OrcProgram *program, int dest, int src1, int value);
-void arm_emit_cmp_imm (OrcProgram *program, int src1, int value);
+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_sub_imm (OrcCompiler *compiler, int dest, int src1, int value);
+void arm_emit_cmp_imm (OrcCompiler *compiler, int src1, int value);
-void arm_emit_label (OrcProgram *program, int label);
-void arm_emit_push (OrcProgram *program, int regs);
-void arm_emit_pop (OrcProgram *program, int regs);
-void arm_emit_mov (OrcProgram *program, int dest, int src);
-void arm_emit_branch (OrcProgram *program, int cond, int label);
+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 (OrcProgram *program, int cond, int opcode, int dest,
+void arm_emit_dp_reg (OrcCompiler *compiler, int cond, int opcode, int dest,
int src1, int src2);
-void arm_loadw (OrcProgram *program, int dest, int src1, int offset);
-void arm_storew (OrcProgram *program, int dest, int offset, int src1);
+void arm_loadw (OrcCompiler *compiler, int dest, int src1, int offset);
+void arm_storew (OrcCompiler *compiler, int dest, int offset, int src1);
-void arm_emit_load_reg (OrcProgram *program, int dest, int src1, int offset);
+void arm_emit_load_reg (OrcCompiler *compiler, int dest, int src1, int offset);
-void arm_do_fixups (OrcProgram *program);
+void arm_do_fixups (OrcCompiler *compiler);
#endif
--- /dev/null
+UNARY_SB(absb, "ORC_ABS(%s)")
+BINARY_SB(addb, "%s + %s")
+BINARY_SB(addssb, "ORC_CLAMP_SB(%s + %s)")
+BINARY_UB(addusb, "ORC_CLAMP_UB(%s + %s)")
+BINARY_SB(andb, "%s & %s")
+BINARY_SB(andnb, "%s & (~%s)")
+BINARY_SB(avgsb, "(%s + %s + 1)>>1")
+BINARY_UB(avgub, "(%s + %s + 1)>>1")
+BINARY_SB(cmpeqb, "(%s == %s) ? (~0) : 0")
+BINARY_SB(cmpgtsb, "(%s > %s) ? (~0) : 0")
+UNARY_SB(copyb, "%s")
+BINARY_SB(maxsb, "ORC_MAX(%s, %s)")
+BINARY_UB(maxub, "ORC_MAX(%s, %s)")
+BINARY_SB(minsb, "ORC_MIN(%s, %s)")
+BINARY_UB(minub, "ORC_MIN(%s, %s)")
+BINARY_SB(mullb, "(%s * %s) & 0xff")
+BINARY_SB(mulhsb, "(%s * %s) >> 8")
+BINARY_UB(mulhub, "(%s * %s) >> 8")
+BINARY_SB(orb, "%s | %s")
+BINARY_SB(shlb, "%s << %s")
+BINARY_SB(shrsb, "%s >> %s")
+BINARY_UB(shrub, "((uint8_t)%s) >> %s")
+UNARY_SB(signb, "ORC_CLAMP(%s,-1,1)")
+BINARY_SB(subb, "%s - %s")
+BINARY_SB(subssb, "ORC_CLAMP_SB(%s - %s)")
+BINARY_UB(subusb, "ORC_CLAMP_UB((uint8_t)%s - (uint8_t)%s)")
+BINARY_SB(xorb, "%s ^ %s")
+
+UNARY_SW(absw, "ORC_ABS(%s)")
+BINARY_SW(addw, "%s + %s")
+BINARY_SW(addssw, "ORC_CLAMP_SW(%s + %s)")
+BINARY_UW(addusw, "ORC_CLAMP_UW(%s + %s)")
+BINARY_SW(andw, "%s & %s")
+BINARY_SW(andnw, "%s & (~%s)")
+BINARY_SW(avgsw, "(%s + %s + 1)>>1")
+BINARY_UW(avguw, "(%s + %s + 1)>>1")
+BINARY_SW(cmpeqw, "(%s == %s) ? (~0) : 0")
+BINARY_SW(cmpgtsw, "(%s > %s) ? (~0) : 0")
+UNARY_SW(copyw, "%s")
+BINARY_SW(maxsw, "ORC_MAX(%s, %s)")
+BINARY_UW(maxuw, "ORC_MAX(%s, %s)")
+BINARY_SW(minsw, "ORC_MIN(%s, %s)")
+BINARY_UW(minuw, "ORC_MIN(%s, %s)")
+BINARY_SW(mullw, "(%s * %s) & 0xffff")
+BINARY_SW(mulhsw, "(%s * %s) >> 16")
+BINARY_UW(mulhuw, "(%s * %s) >> 16")
+BINARY_SW(orw, "%s | %s")
+BINARY_SW(shlw, "%s << %s")
+BINARY_SW(shrsw, "%s >> %s")
+BINARY_UW(shruw, "%s >> %s")
+UNARY_SW(signw, "ORC_CLAMP(%s,-1,1)")
+BINARY_SW(subw, "%s - %s")
+BINARY_SW(subssw, "ORC_CLAMP_SW(%s - %s)")
+BINARY_UW(subusw, "ORC_CLAMP_UW(%s - %s)")
+BINARY_SW(xorw, "%s ^ %s")
+
+UNARY_SL(absl, "ORC_ABS(%s)")
+BINARY_SL(addl, "%s + %s")
+BINARY_SL(addssl, "ORC_CLAMP_SL((int64_t)%s + (int64_t)%s)")
+BINARY_UL(addusl, "ORC_CLAMP_UL((uint64_t)%s + (uint64_t)%s)")
+BINARY_SL(andl, "%s & %s")
+BINARY_SL(andnl, "%s & (~%s)")
+BINARY_SL(avgsl, "(%s + %s + 1)>>1")
+BINARY_UL(avgul, "(%s + %s + 1)>>1")
+BINARY_SL(cmpeql, "(%s == %s) ? (~0) : 0")
+BINARY_SL(cmpgtsl, "(%s > %s) ? (~0) : 0")
+UNARY_SL(copyl, "%s")
+BINARY_SL(maxsl, "ORC_MAX(%s, %s)")
+BINARY_UL(maxul, "ORC_MAX(%s, %s)")
+BINARY_SL(minsl, "ORC_MIN(%s, %s)")
+BINARY_UL(minul, "ORC_MIN(%s, %s)")
+BINARY_SL(mulll, "(%s * %s) & 0xffffffff")
+BINARY_SL(mulhsl, "((int64_t)%s * (int64_t)%s) >> 32")
+BINARY_UL(mulhul, "((uint64_t)%s * (uint64_t)%s) >> 32")
+BINARY_SL(orl, "%s | %s")
+BINARY_SL(shll, "%s << %s")
+BINARY_SL(shrsl, "%s >> %s")
+BINARY_UL(shrul, "%s >> %s")
+UNARY_SL(signl, "ORC_CLAMP(%s,-1,1)")
+BINARY_SL(subl, "%s - %s")
+BINARY_SL(subssl, "ORC_CLAMP_SL((int64_t)%s - (int64_t)%s)")
+BINARY_UL(subusl, "ORC_CLAMP_UL((uint64_t)%s - (uint64_t)%s)")
+BINARY_SL(xorl, "%s ^ %s")
+
+BINARY_BW(convsbw, "%s")
+BINARY_BW(convubw, "(uint8_t)%s")
+BINARY_WL(convswl, "%s")
+BINARY_WL(convuwl, "(uint16_t)%s")
+BINARY_WB(convwb, "%s")
+BINARY_WB(convssswb, "ORC_CLAMP_SB(%s)")
+BINARY_WB(convsuswb, "ORC_CLAMP_UB(%s)")
+BINARY_WB(convusswb, "ORC_CLAMP_SB(%s)")
+BINARY_WB(convuuswb, "ORC_CLAMP_UB(%s)")
+BINARY_LW(convlw, "%s")
+BINARY_LW(convssslw, "ORC_CLAMP_SW(%s)")
+BINARY_LW(convsuslw, "ORC_CLAMP_UW(%s)")
+BINARY_LW(convusslw, "ORC_CLAMP_SW(%s)")
+BINARY_LW(convuuslw, "ORC_CLAMP_UW(%s)")
+
+BINARY_BW(mulsbw, "%s * %s")
+BINARY_BW(mulubw, "%s * %s")
+BINARY_WL(mulswl, "%s * %s")
+BINARY_WL(muluwl, "%s * %s")
+
#ifdef HAVE_CODEMEM_MMAP
void
-orc_program_allocate_codemem (OrcProgram *program)
+orc_compiler_allocate_codemem (OrcCompiler *compiler)
{
char filename[32] = "/tmp/orcexecXXXXXX";
int fd;
if (fd == -1) {
/* FIXME oh crap */
ORC_ERROR ("failed to create temp file");
- program->error = TRUE;
+ compiler->error = TRUE;
return;
}
unlink (filename);
n = ftruncate (fd, SIZE);
- program->code = mmap (NULL, SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
- if (program->code == MAP_FAILED) {
- /* FIXME oh crap */
- ORC_ERROR ("failed to create write map");
- program->error = TRUE;
+ compiler->program->code = mmap (NULL, SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
+ if (compiler->program->code == MAP_FAILED) {
+ ORC_PROGRAM_ERROR(compiler, "failed to create write map");
return;
}
- program->code_exec = mmap (NULL, SIZE, PROT_READ|PROT_EXEC, MAP_SHARED, fd, 0);
- if (program->code_exec == MAP_FAILED) {
- /* FIXME oh crap */
- ORC_ERROR ("failed to create exec map");
- program->error = TRUE;
+ compiler->program->code_exec = mmap (NULL, SIZE, PROT_READ|PROT_EXEC, MAP_SHARED, fd, 0);
+ if (compiler->program->code_exec == MAP_FAILED) {
+ ORC_PROGRAM_ERROR(compiler, "failed to create exec map");
return;
}
close (fd);
- program->code_size = SIZE;
- program->codeptr = program->code;
+ compiler->program->code_size = SIZE;
+ compiler->codeptr = compiler->program->code;
}
#endif
#ifdef HAVE_CODEMEM_MALLOC
void
-orc_program_allocate_codemem (OrcProgram *program)
+orc_compiler_allocate_codemem (OrcCompiler *compiler)
{
/* Now you know why Windows has viruses */
- program->code = malloc(SIZE);
- program->code_exec = program->code;
- program->code_size = SIZE;
- program->codeptr = program->code;
+ compiler->program->code = malloc(SIZE);
+ compiler->program->code_exec = compiler->code;
+ compiler->program->code_size = SIZE;
+ compiler->codeptr = compiler->program->code;
}
#endif
#include <orc/orcprogram.h>
#include <orc/orcdebug.h>
-void orc_program_assign_rules (OrcProgram *program);
-void orc_program_global_reg_alloc (OrcProgram *program);
-void orc_program_rewrite_vars (OrcProgram *program);
-void orc_program_rewrite_vars2 (OrcProgram *program);
-void orc_program_do_regs (OrcProgram *program);
+void orc_compiler_assign_rules (OrcCompiler *compiler);
+void orc_compiler_global_reg_alloc (OrcCompiler *compiler);
+void orc_compiler_rewrite_vars (OrcCompiler *compiler);
+void orc_compiler_rewrite_vars2 (OrcCompiler *compiler);
+void orc_compiler_do_regs (OrcCompiler *compiler);
+int orc_compiler_dup_temporary (OrcCompiler *compiler, int var, int j);
#if defined(HAVE_I386)
int _orc_default_target = ORC_TARGET_SSE;
int
-orc_program_allocate_register (OrcProgram *program, int data_reg)
+orc_compiler_allocate_register (OrcCompiler *compiler, int data_reg)
{
int i;
int offset;
if (data_reg) {
- if (program->target == ORC_TARGET_ARM ||
- program->target == ORC_TARGET_C) {
+ if (compiler->target == ORC_TARGET_ARM ||
+ compiler->target == ORC_TARGET_C) {
offset = ORC_GP_REG_BASE;
} else {
offset = ORC_VEC_REG_BASE;
}
for(i=offset;i<offset+32;i++){
- if (program->valid_regs[i] &&
- !program->save_regs[i] &&
- program->alloc_regs[i] == 0) {
- program->alloc_regs[i]++;
- program->used_regs[i] = 1;
+ if (compiler->valid_regs[i] &&
+ !compiler->save_regs[i] &&
+ compiler->alloc_regs[i] == 0) {
+ compiler->alloc_regs[i]++;
+ compiler->used_regs[i] = 1;
return i;
}
}
for(i=offset;i<offset+32;i++){
- if (program->valid_regs[i] &&
- program->alloc_regs[i] == 0) {
- program->alloc_regs[i]++;
- program->used_regs[i] = 1;
+ if (compiler->valid_regs[i] &&
+ compiler->alloc_regs[i] == 0) {
+ compiler->alloc_regs[i]++;
+ compiler->used_regs[i] = 1;
return i;
}
}
orc_bool
orc_program_compile_for_target (OrcProgram *program, int target)
{
+ OrcCompiler *compiler;
int i;
- program->target = target;
+ compiler = malloc (sizeof(OrcCompiler));
+ memset (compiler, 0, sizeof(OrcCompiler));
+
+ compiler->program = program;
+ compiler->target = target;
+
+ memcpy (compiler->insns, program->insns,
+ program->n_insns * sizeof(OrcInstruction));
+ compiler->n_insns = program->n_insns;
+
+ memcpy (compiler->vars, program->vars,
+ program->n_vars * sizeof(OrcVariable));
+ compiler->n_vars = program->n_vars;
for(i=0;i<32;i++) {
- program->valid_regs[i] = 1;
+ compiler->valid_regs[i] = 1;
}
- switch (program->target) {
+ switch (compiler->target) {
case ORC_TARGET_C:
- orc_program_c_init (program);
+ orc_compiler_c_init (compiler);
break;
case ORC_TARGET_ALTIVEC:
- orc_program_powerpc_init (program);
+ orc_compiler_powerpc_init (compiler);
break;
case ORC_TARGET_SSE:
- orc_program_sse_init (program);
+ orc_compiler_sse_init (compiler);
break;
case ORC_TARGET_MMX:
- orc_program_mmx_init (program);
+ orc_compiler_mmx_init (compiler);
break;
case ORC_TARGET_ARM:
- orc_program_arm_init (program);
+ orc_compiler_arm_init (compiler);
break;
default:
break;
}
- orc_program_assign_rules (program);
- if (program->error) goto error;
+ orc_compiler_assign_rules (compiler);
+ if (compiler->error) goto error;
- orc_program_rewrite_vars (program);
- if (program->error) goto error;
+ orc_compiler_rewrite_vars (compiler);
+ if (compiler->error) goto error;
- if (program->target != ORC_TARGET_C) {
- orc_program_global_reg_alloc (program);
+ if (compiler->target != ORC_TARGET_C) {
+ orc_compiler_global_reg_alloc (compiler);
- orc_program_do_regs (program);
+ orc_compiler_do_regs (compiler);
}
- orc_program_rewrite_vars2 (program);
- if (program->error) goto error;
+ orc_compiler_rewrite_vars2 (compiler);
+ if (compiler->error) goto error;
- if (program->target != ORC_TARGET_C) {
- orc_program_allocate_codemem (program);
+ if (compiler->target != ORC_TARGET_C) {
+ orc_compiler_allocate_codemem (compiler);
}
- switch (program->target) {
+ switch (compiler->target) {
case ORC_TARGET_C:
- orc_program_assemble_c (program);
+ orc_compiler_assemble_c (compiler);
break;
case ORC_TARGET_ALTIVEC:
- orc_program_assemble_powerpc (program);
+ orc_compiler_assemble_powerpc (compiler);
break;
case ORC_TARGET_MMX:
- orc_program_mmx_assemble (program);
+ orc_compiler_mmx_assemble (compiler);
break;
case ORC_TARGET_SSE:
- orc_program_sse_assemble (program);
+ orc_compiler_sse_assemble (compiler);
break;
case ORC_TARGET_ARM:
- orc_program_arm_assemble (program);
+ orc_compiler_arm_assemble (compiler);
break;
default:
break;
}
- if (program->error) goto error;
+ if (compiler->error) goto error;
+
+ program->asm_code = compiler->asm_code;
return TRUE;
error:
}
void
-orc_program_assign_rules (OrcProgram *program)
+orc_compiler_assign_rules (OrcCompiler *compiler)
{
int i;
- for(i=0;i<program->n_insns;i++) {
- OrcInstruction *insn = program->insns + i;
+ for(i=0;i<compiler->n_insns;i++) {
+ OrcInstruction *insn = compiler->insns + i;
- insn->rule = insn->opcode->rules + program->target;
+ insn->rule = insn->opcode->rules + compiler->target;
if (insn->rule == NULL || insn->rule->emit == NULL) {
- ORC_PROGRAM_ERROR(program, "No rule for: %s", insn->opcode->name);
+ ORC_PROGRAM_ERROR(compiler, "No rule for: %s", insn->opcode->name);
}
}
}
void
-orc_program_rewrite_vars (OrcProgram *program)
+orc_compiler_rewrite_vars (OrcCompiler *compiler)
{
int j;
int k;
int var;
int actual_var;
- for(j=0;j<program->n_insns;j++){
- insn = program->insns + j;
+ for(j=0;j<compiler->n_insns;j++){
+ insn = compiler->insns + j;
opcode = insn->opcode;
/* set up args */
for(k=opcode->n_dest;k<opcode->n_src + opcode->n_dest;k++){
var = insn->args[k];
- if (program->vars[var].vartype == ORC_VAR_TYPE_DEST) {
- ORC_PROGRAM_ERROR(program, "using dest var as source");
+ if (compiler->vars[var].vartype == ORC_VAR_TYPE_DEST) {
+ ORC_PROGRAM_ERROR(compiler, "using dest var as source");
}
actual_var = var;
- if (program->vars[var].replaced) {
- actual_var = program->vars[var].replacement;
+ if (compiler->vars[var].replaced) {
+ actual_var = compiler->vars[var].replacement;
insn->args[k] = actual_var;
}
- if (!program->vars[var].used) {
- if (program->vars[var].vartype == ORC_VAR_TYPE_TEMP) {
- ORC_PROGRAM_ERROR(program, "using uninitialized temp var");
+ if (!compiler->vars[var].used) {
+ if (compiler->vars[var].vartype == ORC_VAR_TYPE_TEMP) {
+ ORC_PROGRAM_ERROR(compiler, "using uninitialized temp var");
}
- program->vars[var].used = TRUE;
- program->vars[var].first_use = j;
+ compiler->vars[var].used = TRUE;
+ compiler->vars[var].first_use = j;
}
- program->vars[actual_var].last_use = j;
+ compiler->vars[actual_var].last_use = j;
}
for(k=0;k<opcode->n_dest;k++){
var = insn->args[k];
- if (program->vars[var].vartype == ORC_VAR_TYPE_SRC) {
- ORC_PROGRAM_ERROR(program,"using src var as dest");
+ if (compiler->vars[var].vartype == ORC_VAR_TYPE_SRC) {
+ ORC_PROGRAM_ERROR(compiler,"using src var as dest");
}
- if (program->vars[var].vartype == ORC_VAR_TYPE_CONST) {
- ORC_PROGRAM_ERROR(program,"using const var as dest");
+ if (compiler->vars[var].vartype == ORC_VAR_TYPE_CONST) {
+ ORC_PROGRAM_ERROR(compiler,"using const var as dest");
}
- if (program->vars[var].vartype == ORC_VAR_TYPE_PARAM) {
- ORC_PROGRAM_ERROR(program,"using param var as dest");
+ if (compiler->vars[var].vartype == ORC_VAR_TYPE_PARAM) {
+ ORC_PROGRAM_ERROR(compiler,"using param var as dest");
}
actual_var = var;
- if (program->vars[var].replaced) {
- actual_var = program->vars[var].replacement;
+ if (compiler->vars[var].replaced) {
+ actual_var = compiler->vars[var].replacement;
insn->args[k] = actual_var;
}
- if (!program->vars[var].used) {
- program->vars[actual_var].used = TRUE;
- program->vars[actual_var].first_use = j;
+ if (!compiler->vars[var].used) {
+ compiler->vars[actual_var].used = TRUE;
+ compiler->vars[actual_var].first_use = j;
} else {
- if (program->vars[var].vartype == ORC_VAR_TYPE_DEST) {
- ORC_PROGRAM_ERROR(program,"writing dest more than once");
+ if (compiler->vars[var].vartype == ORC_VAR_TYPE_DEST) {
+ ORC_PROGRAM_ERROR(compiler,"writing dest more than once");
}
- if (program->vars[var].vartype == ORC_VAR_TYPE_TEMP) {
- actual_var = orc_program_dup_temporary (program, var, j);
- program->vars[var].replaced = TRUE;
- program->vars[var].replacement = actual_var;
+ if (compiler->vars[var].vartype == ORC_VAR_TYPE_TEMP) {
+ actual_var = orc_compiler_dup_temporary (compiler, var, j);
+ compiler->vars[var].replaced = TRUE;
+ compiler->vars[var].replacement = actual_var;
insn->args[k] = actual_var;
- program->vars[actual_var].used = TRUE;
- program->vars[actual_var].first_use = j;
+ compiler->vars[actual_var].used = TRUE;
+ compiler->vars[actual_var].first_use = j;
}
}
- program->vars[actual_var].last_use = j;
+ compiler->vars[actual_var].last_use = j;
}
}
}
void
-orc_program_global_reg_alloc (OrcProgram *program)
+orc_compiler_global_reg_alloc (OrcCompiler *compiler)
{
int i;
OrcVariable *var;
- for(i=0;i<program->n_vars;i++){
- var = program->vars + i;
+ for(i=0;i<compiler->n_vars;i++){
+ var = compiler->vars + i;
switch (var->vartype) {
case ORC_VAR_TYPE_CONST:
var->first_use = -1;
var->last_use = -1;
- var->alloc = orc_program_allocate_register (program, TRUE);
+ var->alloc = orc_compiler_allocate_register (compiler, TRUE);
break;
case ORC_VAR_TYPE_PARAM:
var->first_use = -1;
var->last_use = -1;
- var->alloc = orc_program_allocate_register (program, TRUE);
+ var->alloc = orc_compiler_allocate_register (compiler, TRUE);
break;
case ORC_VAR_TYPE_SRC:
case ORC_VAR_TYPE_DEST:
- var->ptr_register = orc_program_allocate_register (program, FALSE);
+ var->ptr_register = orc_compiler_allocate_register (compiler, FALSE);
break;
default:
break;
}
void
-orc_program_do_regs (OrcProgram *program)
+orc_compiler_do_regs (OrcCompiler *compiler)
{
int i;
int k;
OrcInstruction *insn;
OrcOpcode *opcode;
- for(i=0;i<program->n_insns;i++){
- insn = program->insns + i;
+ for(i=0;i<compiler->n_insns;i++){
+ insn = compiler->insns + i;
opcode = insn->opcode;
for(k=opcode->n_dest;k<opcode->n_src + opcode->n_dest;k++){
}
void
-orc_program_rewrite_vars2 (OrcProgram *program)
+orc_compiler_rewrite_vars2 (OrcCompiler *compiler)
{
int i;
int j;
int k;
- for(j=0;j<program->n_insns;j++){
+ for(j=0;j<compiler->n_insns;j++){
#if 1
/* must be true to chain src1 to dest:
* - rule must handle it
* - src1 must be last_use
*/
if (1) {
- int src1 = program->insns[j].args[1];
- int dest = program->insns[j].args[0];
- if (program->vars[src1].last_use == j) {
- if (program->vars[src1].first_use == j) {
- k = orc_program_allocate_register (program, TRUE);
- program->vars[src1].alloc = k;
+ int src1 = compiler->insns[j].args[1];
+ int dest = compiler->insns[j].args[0];
+ if (compiler->vars[src1].last_use == j) {
+ if (compiler->vars[src1].first_use == j) {
+ k = orc_compiler_allocate_register (compiler, TRUE);
+ compiler->vars[src1].alloc = k;
}
- program->alloc_regs[program->vars[src1].alloc]++;
- program->vars[dest].alloc = program->vars[src1].alloc;
+ compiler->alloc_regs[compiler->vars[src1].alloc]++;
+ compiler->vars[dest].alloc = compiler->vars[src1].alloc;
}
}
#endif
if (0) {
/* immediate operand, don't load */
- int src2 = program->insns[j].args[2];
- program->vars[src2].alloc = 1;
+ int src2 = compiler->insns[j].args[2];
+ compiler->vars[src2].alloc = 1;
} else {
- int src2 = program->insns[j].args[2];
- if (program->vars[src2].alloc == 1) {
- program->vars[src2].alloc = 0;
+ int src2 = compiler->insns[j].args[2];
+ if (compiler->vars[src2].alloc == 1) {
+ compiler->vars[src2].alloc = 0;
}
}
- for(i=0;i<program->n_vars;i++){
- if (program->vars[i].first_use == j) {
- if (program->vars[i].alloc) continue;
- k = orc_program_allocate_register (program, TRUE);
- program->vars[i].alloc = k;
+ for(i=0;i<compiler->n_vars;i++){
+ if (compiler->vars[i].first_use == j) {
+ if (compiler->vars[i].alloc) continue;
+ k = orc_compiler_allocate_register (compiler, TRUE);
+ compiler->vars[i].alloc = k;
}
}
- for(i=0;i<program->n_vars;i++){
- if (program->vars[i].last_use == j) {
- program->alloc_regs[program->vars[i].alloc]--;
+ for(i=0;i<compiler->n_vars;i++){
+ if (compiler->vars[i].last_use == j) {
+ compiler->alloc_regs[compiler->vars[i].alloc]--;
}
}
}
}
+int
+orc_compiler_dup_temporary (OrcCompiler *compiler, int var, int j)
+{
+ int i = compiler->n_vars;
+
+ compiler->vars[i].vartype = ORC_VAR_TYPE_TEMP;
+ compiler->vars[i].size = compiler->vars[var].size;
+ compiler->vars[i].name = malloc (strlen(compiler->vars[var].name) + 10);
+ sprintf(compiler->vars[i].name, "%s.dup%d", compiler->vars[var].name, j);
+ compiler->n_vars++;
+
+ return i;
+}
+
+#if 0
void
-orc_program_dump_code (OrcProgram *program)
+orc_compiler_dump_code (OrcCompiler *compiler)
{
FILE *file;
int n;
file = fopen("dump","w");
- n = fwrite (program->code, 1, program->codeptr - program->code, file);
+ n = fwrite (compiler->code, 1, compiler->codeptr - compiler->code, file);
fclose (file);
}
-const char *
-orc_program_get_asm_code (OrcProgram *program)
-{
- return program->asm_code;
-}
+#endif
void
-orc_program_dump_asm (OrcProgram *program)
+orc_compiler_dump_asm (OrcCompiler *compiler)
{
- printf("%s", program->asm_code);
+ printf("%s", compiler->asm_code);
}
void
-orc_program_append_code (OrcProgram *p, const char *fmt, ...)
+orc_compiler_append_code (OrcCompiler *p, const char *fmt, ...)
{
char tmp[100];
va_list varargs;
int arm_exec_ptr = ARM_V1;
-void arm_emit_loop (OrcProgram *program);
+void arm_emit_loop (OrcCompiler *compiler);
-void orc_program_arm_register_rules (void);
+void orc_compiler_arm_register_rules (void);
-void orc_program_rewrite_vars (OrcProgram *program);
-void orc_program_dump (OrcProgram *program);
+void orc_compiler_rewrite_vars (OrcCompiler *compiler);
+void orc_compiler_dump (OrcCompiler *compiler);
void
-arm_emit_prologue (OrcProgram *program)
+arm_emit_prologue (OrcCompiler *compiler)
{
unsigned int regs = 0;
int i;
- orc_program_append_code(program,".global %s\n", program->name);
- orc_program_append_code(program,"%s:\n", program->name);
+ orc_compiler_append_code(compiler,".global %s\n", compiler->program->name);
+ orc_compiler_append_code(compiler,"%s:\n", compiler->program->name);
for(i=0;i<16;i++){
- if (program->used_regs[ORC_GP_REG_BASE + i] &&
- program->save_regs[ORC_GP_REG_BASE + i]) {
+ if (compiler->used_regs[ORC_GP_REG_BASE + i] &&
+ compiler->save_regs[ORC_GP_REG_BASE + i]) {
regs |= (1<<i);
}
}
- if (regs) arm_emit_push (program, regs);
+ if (regs) arm_emit_push (compiler, regs);
#if 0
- arm_emit_mov_memoffset_reg (program, 4, 8, X86_ESP, X86_EBP);
- if (program->used_regs[X86_EDI]) {
- arm_emit_push (program, 4, X86_EDI);
+ arm_emit_mov_memoffset_reg (compiler, 4, 8, X86_ESP, X86_EBP);
+ if (compiler->used_regs[X86_EDI]) {
+ arm_emit_push (compiler, 4, X86_EDI);
}
- if (program->used_regs[X86_ESI]) {
- arm_emit_push (program, 4, X86_ESI);
+ if (compiler->used_regs[X86_ESI]) {
+ arm_emit_push (compiler, 4, X86_ESI);
}
- if (program->used_regs[X86_EBX]) {
- arm_emit_push (program, 4, X86_EBX);
+ if (compiler->used_regs[X86_EBX]) {
+ arm_emit_push (compiler, 4, X86_EBX);
}
#endif
}
void
-arm_dump_insns (OrcProgram *program)
+arm_dump_insns (OrcCompiler *compiler)
{
- arm_emit_label (program, 0);
+ arm_emit_label (compiler, 0);
- arm_emit_add (program, ARM_A2, ARM_A3, ARM_A4);
- arm_emit_sub (program, ARM_A2, ARM_A3, ARM_A4);
- arm_emit_push (program, 0x06);
- arm_emit_mov (program, ARM_A2, ARM_A3);
+ 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);
- arm_emit_branch (program, ARM_COND_LE, 0);
- arm_emit_branch (program, ARM_COND_AL, 0);
+ arm_emit_branch (compiler, ARM_COND_LE, 0);
+ arm_emit_branch (compiler, ARM_COND_AL, 0);
- arm_emit_loadimm (program, ARM_A3, 0xa500);
- arm_loadw (program, ARM_A3, ARM_A4, 0xa5);
- arm_emit_load_reg (program, ARM_A3, ARM_A4, 0x5a5);
+ arm_emit_loadimm (compiler, ARM_A3, 0xa500);
+ arm_loadw (compiler, ARM_A3, ARM_A4, 0xa5);
+ arm_emit_load_reg (compiler, ARM_A3, ARM_A4, 0x5a5);
}
void
-arm_emit_epilogue (OrcProgram *program)
+arm_emit_epilogue (OrcCompiler *compiler)
{
int i;
unsigned int regs = 0;
for(i=0;i<16;i++){
- if (program->used_regs[ORC_GP_REG_BASE + i] &&
- program->save_regs[ORC_GP_REG_BASE + i]) {
+ if (compiler->used_regs[ORC_GP_REG_BASE + i] &&
+ compiler->save_regs[ORC_GP_REG_BASE + i]) {
regs |= (1<<i);
}
}
- if (regs) arm_emit_pop (program, regs);
- arm_emit_bx_lr (program);
+ if (regs) arm_emit_pop (compiler, regs);
+ arm_emit_bx_lr (compiler);
- //arm_dump_insns (program);
+ //arm_dump_insns (compiler);
}
void
orc_arm_init (void)
{
- orc_program_arm_register_rules ();
+ orc_compiler_arm_register_rules ();
}
void
-orc_program_arm_init (OrcProgram *program)
+orc_compiler_arm_init (OrcCompiler *compiler)
{
int i;
for(i=ORC_GP_REG_BASE;i<ORC_GP_REG_BASE+16;i++){
- program->valid_regs[i] = 1;
+ compiler->valid_regs[i] = 1;
}
- program->valid_regs[ARM_V1] = 0;
- //program->valid_regs[ARM_SB] = 0;
- program->valid_regs[ARM_IP] = 0;
- program->valid_regs[ARM_SP] = 0;
- program->valid_regs[ARM_LR] = 0;
- program->valid_regs[ARM_PC] = 0;
+ compiler->valid_regs[ARM_V1] = 0;
+ //compiler->valid_regs[ARM_SB] = 0;
+ compiler->valid_regs[ARM_IP] = 0;
+ compiler->valid_regs[ARM_SP] = 0;
+ compiler->valid_regs[ARM_LR] = 0;
+ compiler->valid_regs[ARM_PC] = 0;
for(i=4;i<11;i++) {
- program->save_regs[ORC_GP_REG_BASE+i] = 1;
+ compiler->save_regs[ORC_GP_REG_BASE+i] = 1;
}
for(i=0;i<ORC_N_REGS;i++){
- program->alloc_regs[i] = 0;
- program->used_regs[i] = 0;
+ compiler->alloc_regs[i] = 0;
+ compiler->used_regs[i] = 0;
}
- program->loop_shift = 0;
+ compiler->loop_shift = 0;
}
void
-arm_load_constants (OrcProgram *program)
+arm_load_constants (OrcCompiler *compiler)
{
int i;
- for(i=0;i<program->n_vars;i++){
- switch (program->vars[i].vartype) {
+ for(i=0;i<compiler->n_vars;i++){
+ switch (compiler->vars[i].vartype) {
case ORC_VAR_TYPE_CONST:
- //arm_emit_loadiw (program, program->vars[i].alloc,
- // (int)program->vars[i].value);
+ //arm_emit_loadiw (compiler, compiler->vars[i].alloc,
+ // (int)compiler->vars[i].value);
break;
case ORC_VAR_TYPE_PARAM:
- //arm_emit_loadw (program, program->vars[i].alloc,
+ //arm_emit_loadw (compiler, compiler->vars[i].alloc,
// (int)ORC_STRUCT_OFFSET(OrcExecutor, params[i]), arm_exec_ptr);
break;
case ORC_VAR_TYPE_SRC:
case ORC_VAR_TYPE_DEST:
- arm_emit_load_reg (program,
- program->vars[i].ptr_register,
+ arm_emit_load_reg (compiler,
+ compiler->vars[i].ptr_register,
arm_exec_ptr, ORC_STRUCT_OFFSET(OrcExecutor, arrays[i]));
break;
default:
}
void
-arm_emit_load_src (OrcProgram *program, OrcVariable *var)
+arm_emit_load_src (OrcCompiler *compiler, OrcVariable *var)
{
int ptr_reg;
if (var->ptr_register == 0) {
int i;
- i = var - program->vars;
- //arm_emit_mov_memoffset_reg (program, arm_ptr_size,
+ i = var - compiler->vars;
+ //arm_emit_mov_memoffset_reg (compiler, arm_ptr_size,
// (int)ORC_STRUCT_OFFSET(OrcExecutor, arrays[i]),
// arm_exec_ptr, X86_ECX);
ptr_reg = ARM_PC;
} else {
ptr_reg = var->ptr_register;
}
- switch (var->size << program->loop_shift) {
+ switch (var->size << compiler->loop_shift) {
//case 1:
- //arm_emit_mov_memoffset_reg (program, 1, 0, ptr_reg, X86_ECX);
- //arm_emit_mov_reg_arm (program, X86_ECX, var->alloc);
+ //arm_emit_mov_memoffset_reg (compiler, 1, 0, ptr_reg, X86_ECX);
+ //arm_emit_mov_reg_arm (compiler, X86_ECX, var->alloc);
break;
case 2:
- arm_loadw (program, var->alloc, ptr_reg, 0);
- //arm_emit_mov_memoffset_reg (program, 2, 0, ptr_reg, X86_ECX);
- //arm_emit_mov_reg_arm (program, X86_ECX, var->alloc);
+ 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;
//case 4:
- //arm_emit_mov_memoffset_arm (program, 4, 0, ptr_reg, var->alloc);
+ //arm_emit_mov_memoffset_arm (compiler, 4, 0, ptr_reg, var->alloc);
break;
//case 8:
- //arm_emit_mov_memoffset_arm (program, 8, 0, ptr_reg, var->alloc);
+ //arm_emit_mov_memoffset_arm (compiler, 8, 0, ptr_reg, var->alloc);
break;
//case 16:
- //arm_emit_mov_memoffset_arm (program, 16, 0, ptr_reg, var->alloc);
+ //arm_emit_mov_memoffset_arm (compiler, 16, 0, ptr_reg, var->alloc);
break;
default:
- ORC_PROGRAM_ERROR(program, "bad size %d\n", var->size << program->loop_shift);
+ ORC_PROGRAM_ERROR(compiler, "bad size %d\n", var->size << compiler->loop_shift);
}
}
void
-arm_emit_store_dest (OrcProgram *program, OrcVariable *var)
+arm_emit_store_dest (OrcCompiler *compiler, OrcVariable *var)
{
int ptr_reg;
if (var->ptr_register == 0) {
- //arm_emit_mov_memoffset_reg (program, arm_ptr_size,
+ //arm_emit_mov_memoffset_reg (compiler, arm_ptr_size,
// var->ptr_offset, arm_exec_ptr, X86_ECX);
ptr_reg = ARM_PC;
} else {
ptr_reg = var->ptr_register;
}
- switch (var->size << program->loop_shift) {
+ switch (var->size << compiler->loop_shift) {
case 1:
- //arm_emit_mov_arm_reg (program, var->alloc, X86_ECX);
- //arm_emit_mov_reg_memoffset (program, 1, X86_ECX, 0, ptr_reg);
+ //arm_emit_mov_arm_reg (compiler, var->alloc, X86_ECX);
+ //arm_emit_mov_reg_memoffset (compiler, 1, X86_ECX, 0, ptr_reg);
break;
case 2:
- arm_storew (program, ptr_reg, 0, var->alloc);
- //arm_emit_mov_arm_reg (program, var->alloc, X86_ECX);
- //arm_emit_mov_reg_memoffset (program, 2, X86_ECX, 0, ptr_reg);
+ 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;
case 4:
- //arm_emit_mov_arm_memoffset (program, 4, var->alloc, 0, ptr_reg,
+ //arm_emit_mov_arm_memoffset (compiler, 4, var->alloc, 0, ptr_reg,
// var->is_aligned, var->is_uncached);
break;
case 8:
- //arm_emit_mov_arm_memoffset (program, 8, var->alloc, 0, ptr_reg,
+ //arm_emit_mov_arm_memoffset (compiler, 8, var->alloc, 0, ptr_reg,
// var->is_aligned, var->is_uncached);
break;
case 16:
- //arm_emit_mov_arm_memoffset (program, 16, var->alloc, 0, ptr_reg,
+ //arm_emit_mov_arm_memoffset (compiler, 16, var->alloc, 0, ptr_reg,
// var->is_aligned, var->is_uncached);
break;
default:
- ORC_PROGRAM_ERROR(program, "bad size %d\n", var->size << program->loop_shift);
+ ORC_PROGRAM_ERROR(compiler, "bad size %d\n", var->size << compiler->loop_shift);
}
}
void
-orc_program_arm_assemble (OrcProgram *program)
+orc_compiler_arm_assemble (OrcCompiler *compiler)
{
- int dest_var = orc_program_get_dest (program);
+ int dest_var = orc_compiler_get_dest (compiler);
- program->vars[dest_var].is_aligned = FALSE;
+ compiler->vars[dest_var].is_aligned = FALSE;
- arm_emit_prologue (program);
+ arm_emit_prologue (compiler);
- arm_emit_load_reg (program, ARM_IP, arm_exec_ptr,
+ arm_emit_load_reg (compiler, ARM_IP, arm_exec_ptr,
(int)ORC_STRUCT_OFFSET(OrcExecutor,n));
- arm_load_constants (program);
+ arm_load_constants (compiler);
- arm_emit_label (program, 1);
+ arm_emit_label (compiler, 1);
- arm_emit_cmp_imm (program, ARM_IP, 0);
- arm_emit_branch (program, ARM_COND_EQ, 3);
+ arm_emit_cmp_imm (compiler, ARM_IP, 0);
+ arm_emit_branch (compiler, ARM_COND_EQ, 3);
- arm_emit_label (program, 2);
- arm_emit_loop (program);
- arm_emit_sub_imm (program, ARM_IP, ARM_IP, 1);
- arm_emit_cmp_imm (program, ARM_IP, 0);
- arm_emit_branch (program, ARM_COND_NE, 2);
- arm_emit_label (program, 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);
- arm_emit_epilogue (program);
+ arm_emit_epilogue (compiler);
- arm_do_fixups (program);
+ arm_do_fixups (compiler);
}
void
-arm_emit_loop (OrcProgram *program)
+arm_emit_loop (OrcCompiler *compiler)
{
int j;
int k;
OrcVariable *args[10];
OrcRule *rule;
- for(j=0;j<program->n_insns;j++){
- insn = program->insns + j;
+ for(j=0;j<compiler->n_insns;j++){
+ insn = compiler->insns + j;
opcode = insn->opcode;
- orc_program_append_code(program,"# %d: %s", j, insn->opcode->name);
+ orc_compiler_append_code(compiler,"# %d: %s", j, insn->opcode->name);
/* set up args */
for(k=0;k<opcode->n_src + opcode->n_dest;k++){
- args[k] = program->vars + insn->args[k];
- orc_program_append_code(program," %d", args[k]->alloc);
+ args[k] = compiler->vars + insn->args[k];
+ orc_compiler_append_code(compiler," %d", args[k]->alloc);
if (args[k]->is_chained) {
- orc_program_append_code(program," (chained)");
+ orc_compiler_append_code(compiler," (chained)");
}
}
- orc_program_append_code(program,"\n");
+ orc_compiler_append_code(compiler,"\n");
for(k=opcode->n_dest;k<opcode->n_src + opcode->n_dest;k++){
switch (args[k]->vartype) {
case ORC_VAR_TYPE_SRC:
- arm_emit_load_src (program, args[k]);
+ arm_emit_load_src (compiler, args[k]);
break;
case ORC_VAR_TYPE_CONST:
break;
rule = insn->rule;
if (rule && rule->emit) {
if (args[0]->alloc != args[1]->alloc) {
- arm_emit_mov (program, args[1]->alloc, args[0]->alloc);
+ arm_emit_mov (compiler, args[1]->alloc, args[0]->alloc);
}
- rule->emit (program, rule->emit_user, insn);
+ rule->emit (compiler, rule->emit_user, insn);
} else {
- orc_program_append_code(program,"No rule for: %s\n", opcode->name);
+ orc_compiler_append_code(compiler,"No rule for: %s\n", opcode->name);
}
for(k=0;k<opcode->n_dest;k++){
switch (args[k]->vartype) {
case ORC_VAR_TYPE_DEST:
- arm_emit_store_dest (program, args[k]);
+ arm_emit_store_dest (compiler, args[k]);
break;
case ORC_VAR_TYPE_TEMP:
break;
}
}
- for(k=0;k<program->n_vars;k++){
- if (program->vars[k].vartype == ORC_VAR_TYPE_SRC ||
- program->vars[k].vartype == ORC_VAR_TYPE_DEST) {
- if (program->vars[k].ptr_register) {
- //arm_emit_add_imm_reg (program, arm_ptr_size,
- // program->vars[k].size << program->loop_shift,
- // program->vars[k].ptr_register);
+ for(k=0;k<compiler->n_vars;k++){
+ 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_reg (compiler, arm_ptr_size,
+ // compiler->vars[k].size << compiler->loop_shift,
+ // compiler->vars[k].ptr_register);
} else {
- //arm_emit_add_imm_memoffset (program, arm_ptr_size,
- // program->vars[k].size << program->loop_shift,
+ //arm_emit_add_imm_memoffset (compiler, arm_ptr_size,
+ // compiler->vars[k].size << compiler->loop_shift,
// (int)ORC_STRUCT_OFFSET(OrcExecutor, arrays[k]),
// arm_exec_ptr);
}
void orc_c_init (void);
void
-orc_program_c_init (OrcProgram *program)
+orc_compiler_c_init (OrcCompiler *compiler)
{
int i;
for(i=ORC_GP_REG_BASE;i<ORC_GP_REG_BASE+16;i++){
- program->valid_regs[i] = 1;
+ compiler->valid_regs[i] = 1;
}
- program->loop_shift = 0;
+ compiler->loop_shift = 0;
}
const char *
}
void
-orc_program_assemble_c (OrcProgram *program)
+orc_compiler_assemble_c (OrcCompiler *compiler)
{
int i;
int j;
OrcOpcode *opcode;
OrcRule *rule;
- ORC_ASM_CODE(program,"void\n");
- ORC_ASM_CODE(program,"%s (OrcExecutor *ex)\n", program->name);
- ORC_ASM_CODE(program,"{\n");
- ORC_ASM_CODE(program," int i;\n");
+ ORC_ASM_CODE(compiler,"void\n");
+ ORC_ASM_CODE(compiler,"%s (OrcExecutor *ex)\n", compiler->program->name);
+ ORC_ASM_CODE(compiler,"{\n");
+ ORC_ASM_CODE(compiler," int i;\n");
- for(i=0;i<program->n_vars;i++){
- OrcVariable *var = program->vars + i;
+ for(i=0;i<compiler->n_vars;i++){
+ OrcVariable *var = compiler->vars + i;
switch (var->vartype) {
case ORC_VAR_TYPE_CONST:
- ORC_ASM_CODE(program," %s var%d = %d;\n",
+ ORC_ASM_CODE(compiler," %s var%d = %d;\n",
c_get_type_name(var->size), i, var->value);
break;
case ORC_VAR_TYPE_TEMP:
- ORC_ASM_CODE(program," %s var%d;\n", c_get_type_name(var->size), i);
+ ORC_ASM_CODE(compiler," %s var%d;\n", c_get_type_name(var->size), i);
break;
case ORC_VAR_TYPE_SRC:
case ORC_VAR_TYPE_DEST:
- ORC_ASM_CODE(program," %s *var%d = ex->arrays[%d];\n",
+ ORC_ASM_CODE(compiler," %s *var%d = ex->arrays[%d];\n",
c_get_type_name (var->size), i, i);
break;
case ORC_VAR_TYPE_PARAM:
- ORC_ASM_CODE(program," %s var%d = ex->arrays[%d];\n",
+ ORC_ASM_CODE(compiler," %s var%d = ex->arrays[%d];\n",
c_get_type_name (var->size), i, i);
break;
default:
}
- ORC_ASM_CODE(program,"\n");
- ORC_ASM_CODE(program," for (i = 0; i < ex->n; i++) {\n");
+ ORC_ASM_CODE(compiler,"\n");
+ ORC_ASM_CODE(compiler," for (i = 0; i < ex->n; i++) {\n");
- for(j=0;j<program->n_insns;j++){
- insn = program->insns + j;
+ for(j=0;j<compiler->n_insns;j++){
+ insn = compiler->insns + j;
opcode = insn->opcode;
- ORC_ASM_CODE(program," /* %d: %s */\n", j, insn->opcode->name);
+ ORC_ASM_CODE(compiler," /* %d: %s */\n", j, insn->opcode->name);
rule = insn->rule;
if (rule) {
- rule->emit (program, rule->emit_user, insn);
+ rule->emit (compiler, rule->emit_user, insn);
} else {
- ORC_PROGRAM_ERROR(program,"No rule for: %s\n", opcode->name);
- program->error = TRUE;
+ ORC_PROGRAM_ERROR(compiler,"No rule for: %s\n", opcode->name);
+ compiler->error = TRUE;
}
}
- ORC_ASM_CODE(program," }\n");
- ORC_ASM_CODE(program,"}\n");
- ORC_ASM_CODE(program,"\n");
+ ORC_ASM_CODE(compiler," }\n");
+ ORC_ASM_CODE(compiler,"}\n");
+ ORC_ASM_CODE(compiler,"\n");
}
/* rules */
static void
-c_get_name (char *name, OrcProgram *p, int var)
+c_get_name (char *name, OrcCompiler *p, int var)
{
switch (p->vars[var].vartype) {
case ORC_VAR_TYPE_CONST:
#if 0
static void
-c_rule_copyw (OrcProgram *p, void *user, OrcInstruction *insn)
+c_rule_copyw (OrcCompiler *p, void *user, OrcInstruction *insn)
{
char dest[20], src1[20];
#define BINARY(name,op) \
static void \
-c_rule_ ## name (OrcProgram *p, void *user, OrcInstruction *insn) \
+c_rule_ ## name (OrcCompiler *p, void *user, OrcInstruction *insn) \
{ \
char dest[20], src1[20], src2[20]; \
\
#if 0
static void
-c_rule_addw (OrcProgram *p, void *user, OrcInstruction *insn)
+c_rule_addw (OrcCompiler *p, void *user, OrcInstruction *insn)
{
char dest[20], src1[20], src2[20];
}
static void
-c_rule_subw (OrcProgram *p, void *user, OrcInstruction *insn)
+c_rule_subw (OrcCompiler *p, void *user, OrcInstruction *insn)
{
char dest[20], src1[20], src2[20];
}
static void
-c_rule_mullw (OrcProgram *p, void *user, OrcInstruction *insn)
+c_rule_mullw (OrcCompiler *p, void *user, OrcInstruction *insn)
{
char dest[20], src1[20], src2[20];
}
static void
-c_rule_shlw (OrcProgram *p, void *user, OrcInstruction *insn)
+c_rule_shlw (OrcCompiler *p, void *user, OrcInstruction *insn)
{
char dest[20], src1[20], src2[20];
}
static void
-c_rule_shrsw (OrcProgram *p, void *user, OrcInstruction *insn)
+c_rule_shrsw (OrcCompiler *p, void *user, OrcInstruction *insn)
{
char dest[20], src1[20], src2[20];
#define SIZE 65536
-void mmx_emit_loop (OrcProgram *program);
+void mmx_emit_loop (OrcCompiler *compiler);
-void orc_program_mmx_register_rules (void);
+void orc_compiler_mmx_register_rules (void);
-void orc_program_rewrite_vars (OrcProgram *program);
-void orc_program_dump (OrcProgram *program);
+void orc_compiler_rewrite_vars (OrcCompiler *compiler);
+void orc_compiler_dump (OrcCompiler *compiler);
void
orc_mmx_init (void)
{
- orc_program_mmx_register_rules ();
+ orc_compiler_mmx_register_rules ();
}
void
-orc_program_mmx_init (OrcProgram *program)
+orc_compiler_mmx_init (OrcCompiler *compiler)
{
int i;
if (x86_64) {
for(i=ORC_GP_REG_BASE;i<ORC_GP_REG_BASE+16;i++){
- program->valid_regs[i] = 1;
+ compiler->valid_regs[i] = 1;
}
- program->valid_regs[X86_ECX] = 0;
- program->valid_regs[X86_EDI] = 0;
- program->valid_regs[X86_ESP] = 0;
+ compiler->valid_regs[X86_ECX] = 0;
+ compiler->valid_regs[X86_EDI] = 0;
+ compiler->valid_regs[X86_ESP] = 0;
for(i=X86_XMM0;i<X86_XMM0+16;i++){
- program->valid_regs[i] = 1;
+ compiler->valid_regs[i] = 1;
}
- program->save_regs[X86_EBX] = 1;
- program->save_regs[X86_EBP] = 1;
- program->save_regs[X86_R12] = 1;
- program->save_regs[X86_R13] = 1;
- program->save_regs[X86_R14] = 1;
- program->save_regs[X86_R15] = 1;
+ compiler->save_regs[X86_EBX] = 1;
+ compiler->save_regs[X86_EBP] = 1;
+ compiler->save_regs[X86_R12] = 1;
+ compiler->save_regs[X86_R13] = 1;
+ compiler->save_regs[X86_R14] = 1;
+ compiler->save_regs[X86_R15] = 1;
} else {
for(i=ORC_GP_REG_BASE;i<ORC_GP_REG_BASE+8;i++){
- program->valid_regs[i] = 1;
+ compiler->valid_regs[i] = 1;
}
- program->valid_regs[X86_ECX] = 0;
- program->valid_regs[X86_ESP] = 0;
- program->valid_regs[X86_EBP] = 0;
+ compiler->valid_regs[X86_ECX] = 0;
+ compiler->valid_regs[X86_ESP] = 0;
+ compiler->valid_regs[X86_EBP] = 0;
for(i=X86_XMM0;i<X86_XMM0+8;i++){
- program->valid_regs[i] = 1;
+ compiler->valid_regs[i] = 1;
}
- program->save_regs[X86_EBX] = 1;
- program->save_regs[X86_EDI] = 1;
- program->save_regs[X86_EBP] = 1;
+ compiler->save_regs[X86_EBX] = 1;
+ compiler->save_regs[X86_EDI] = 1;
+ compiler->save_regs[X86_EBP] = 1;
}
for(i=X86_MM0;i<X86_MM0+8;i++){
- program->valid_regs[i] = 1;
+ compiler->valid_regs[i] = 1;
}
for(i=0;i<128;i++){
- program->alloc_regs[i] = 0;
- program->used_regs[i] = 0;
+ compiler->alloc_regs[i] = 0;
+ compiler->used_regs[i] = 0;
}
- program->loop_shift = 2;
+ compiler->loop_shift = 2;
}
void
-mmx_load_constants (OrcProgram *program)
+mmx_load_constants (OrcCompiler *compiler)
{
int i;
- for(i=0;i<program->n_vars;i++){
- switch (program->vars[i].vartype) {
+ for(i=0;i<compiler->n_vars;i++){
+ switch (compiler->vars[i].vartype) {
case ORC_VAR_TYPE_CONST:
- mmx_emit_loadiw (program, program->vars[i].alloc,
- (int)program->vars[i].value);
+ mmx_emit_loadiw (compiler, compiler->vars[i].alloc,
+ (int)compiler->vars[i].value);
break;
case ORC_VAR_TYPE_SRC:
case ORC_VAR_TYPE_DEST:
- if (program->vars[i].ptr_register) {
- x86_emit_mov_memoffset_reg (program, x86_ptr_size,
+ if (compiler->vars[i].ptr_register) {
+ x86_emit_mov_memoffset_reg (compiler, x86_ptr_size,
(int)ORC_STRUCT_OFFSET(OrcExecutor, arrays[i]), x86_exec_ptr,
- program->vars[i].ptr_register);
+ compiler->vars[i].ptr_register);
} else {
- ORC_PROGRAM_ERROR(program, "unimplemented");
+ ORC_PROGRAM_ERROR(compiler, "unimplemented");
}
break;
default:
}
void
-mmx_emit_load_src (OrcProgram *program, OrcVariable *var)
+mmx_emit_load_src (OrcCompiler *compiler, OrcVariable *var)
{
int ptr_reg;
if (var->ptr_register == 0) {
- x86_emit_mov_memoffset_reg (program, x86_ptr_size,
+ x86_emit_mov_memoffset_reg (compiler, x86_ptr_size,
var->ptr_offset, x86_exec_ptr, X86_ECX);
ptr_reg = X86_ECX;
} else {
ptr_reg = var->ptr_register;
}
- switch (program->loop_shift) {
+ switch (compiler->loop_shift) {
case 0:
- x86_emit_mov_memoffset_reg (program, 2, 0, ptr_reg, X86_ECX);
- x86_emit_mov_reg_mmx (program, X86_ECX, var->alloc);
+ x86_emit_mov_memoffset_reg (compiler, 2, 0, ptr_reg, X86_ECX);
+ x86_emit_mov_reg_mmx (compiler, X86_ECX, var->alloc);
break;
case 1:
- x86_emit_mov_memoffset_mmx (program, 4, 0, ptr_reg, var->alloc);
+ x86_emit_mov_memoffset_mmx (compiler, 4, 0, ptr_reg, var->alloc);
break;
case 2:
- x86_emit_mov_memoffset_mmx (program, 8, 0, ptr_reg, var->alloc);
+ x86_emit_mov_memoffset_mmx (compiler, 8, 0, ptr_reg, var->alloc);
break;
default:
- ORC_PROGRAM_ERROR(program, "bad size");
+ ORC_PROGRAM_ERROR(compiler, "bad size");
}
}
void
-mmx_emit_store_dest (OrcProgram *program, OrcVariable *var)
+mmx_emit_store_dest (OrcCompiler *compiler, OrcVariable *var)
{
int ptr_reg;
if (var->ptr_register == 0) {
- x86_emit_mov_memoffset_reg (program, x86_ptr_size,
+ x86_emit_mov_memoffset_reg (compiler, x86_ptr_size,
var->ptr_offset, x86_exec_ptr, X86_ECX);
ptr_reg = X86_ECX;
} else {
ptr_reg = var->ptr_register;
}
- switch (program->loop_shift) {
+ switch (compiler->loop_shift) {
case 0:
/* FIXME we might be using ecx twice here */
if (ptr_reg == X86_ECX) {
- ORC_PROGRAM_ERROR(program, "unimplemented");
+ ORC_PROGRAM_ERROR(compiler, "unimplemented");
}
- x86_emit_mov_mmx_reg (program, var->alloc, X86_ECX);
- x86_emit_mov_reg_memoffset (program, 2, X86_ECX, 0, ptr_reg);
+ x86_emit_mov_mmx_reg (compiler, var->alloc, X86_ECX);
+ x86_emit_mov_reg_memoffset (compiler, 2, X86_ECX, 0, ptr_reg);
break;
case 1:
- x86_emit_mov_mmx_memoffset (program, 4, var->alloc, 0, ptr_reg);
+ x86_emit_mov_mmx_memoffset (compiler, 4, var->alloc, 0, ptr_reg);
break;
case 2:
- x86_emit_mov_mmx_memoffset (program, 8, var->alloc, 0, ptr_reg);
+ x86_emit_mov_mmx_memoffset (compiler, 8, var->alloc, 0, ptr_reg);
break;
default:
- ORC_PROGRAM_ERROR(program, "unimplemented");
+ ORC_PROGRAM_ERROR(compiler, "unimplemented");
}
}
void
-orc_program_mmx_assemble (OrcProgram *program)
+orc_compiler_mmx_assemble (OrcCompiler *compiler)
{
- x86_emit_prologue (program);
+ x86_emit_prologue (compiler);
- x86_emit_mov_memoffset_reg (program, 4, (int)ORC_STRUCT_OFFSET(OrcExecutor,n),
+ x86_emit_mov_memoffset_reg (compiler, 4, (int)ORC_STRUCT_OFFSET(OrcExecutor,n),
x86_exec_ptr, X86_ECX);
- x86_emit_sar_imm_reg (program, 4, program->loop_shift, X86_ECX);
- x86_emit_mov_reg_memoffset (program, 4, X86_ECX,
+ x86_emit_sar_imm_reg (compiler, 4, compiler->loop_shift, X86_ECX);
+ x86_emit_mov_reg_memoffset (compiler, 4, X86_ECX,
(int)ORC_STRUCT_OFFSET(OrcExecutor,counter2), x86_exec_ptr);
- x86_emit_mov_memoffset_reg (program, 4,
+ x86_emit_mov_memoffset_reg (compiler, 4,
(int)ORC_STRUCT_OFFSET(OrcExecutor,n), x86_exec_ptr, X86_ECX);
- x86_emit_and_imm_reg (program, 4, (1<<program->loop_shift)-1, X86_ECX);
- x86_emit_mov_reg_memoffset (program, 4, X86_ECX,
+ x86_emit_and_imm_reg (compiler, 4, (1<<compiler->loop_shift)-1, X86_ECX);
+ x86_emit_mov_reg_memoffset (compiler, 4, X86_ECX,
(int)ORC_STRUCT_OFFSET(OrcExecutor,counter1), x86_exec_ptr);
- mmx_load_constants (program);
+ mmx_load_constants (compiler);
- if (program->loop_shift > 0) {
+ if (compiler->loop_shift > 0) {
int save_loop_shift;
- x86_emit_cmp_imm_memoffset (program, 4, 0,
+ x86_emit_cmp_imm_memoffset (compiler, 4, 0,
(int)ORC_STRUCT_OFFSET(OrcExecutor,counter1), x86_exec_ptr);
- x86_emit_je (program, 1);
+ x86_emit_je (compiler, 1);
- save_loop_shift = program->loop_shift;
- program->loop_shift = 0;
+ save_loop_shift = compiler->loop_shift;
+ compiler->loop_shift = 0;
- x86_emit_label (program, 0);
- mmx_emit_loop (program);
- x86_emit_dec_memoffset (program, 4,
+ x86_emit_label (compiler, 0);
+ mmx_emit_loop (compiler);
+ x86_emit_dec_memoffset (compiler, 4,
(int)ORC_STRUCT_OFFSET(OrcExecutor,counter1),
x86_exec_ptr);
- x86_emit_jne (program, 0);
+ x86_emit_jne (compiler, 0);
- program->loop_shift = save_loop_shift;
+ compiler->loop_shift = save_loop_shift;
}
- x86_emit_label (program, 1);
+ x86_emit_label (compiler, 1);
- x86_emit_cmp_imm_memoffset (program, 4, 0,
+ x86_emit_cmp_imm_memoffset (compiler, 4, 0,
(int)ORC_STRUCT_OFFSET(OrcExecutor,counter2), x86_exec_ptr);
- x86_emit_je (program, 3);
+ x86_emit_je (compiler, 3);
- x86_emit_label (program, 2);
- mmx_emit_loop (program);
- x86_emit_dec_memoffset (program, 4,
+ x86_emit_label (compiler, 2);
+ mmx_emit_loop (compiler);
+ x86_emit_dec_memoffset (compiler, 4,
(int)ORC_STRUCT_OFFSET(OrcExecutor,counter2),
x86_exec_ptr);
- x86_emit_jne (program, 2);
- x86_emit_label (program, 3);
+ x86_emit_jne (compiler, 2);
+ x86_emit_label (compiler, 3);
- x86_emit_emms (program);
- x86_emit_epilogue (program);
+ x86_emit_emms (compiler);
+ x86_emit_epilogue (compiler);
- x86_do_fixups (program);
+ x86_do_fixups (compiler);
}
void
-mmx_emit_loop (OrcProgram *program)
+mmx_emit_loop (OrcCompiler *compiler)
{
int j;
int k;
OrcVariable *args[10];
OrcRule *rule;
- for(j=0;j<program->n_insns;j++){
- insn = program->insns + j;
+ for(j=0;j<compiler->n_insns;j++){
+ insn = compiler->insns + j;
opcode = insn->opcode;
- orc_program_append_code(program,"# %d: %s", j, insn->opcode->name);
+ orc_compiler_append_code(compiler,"# %d: %s", j, insn->opcode->name);
/* set up args */
for(k=0;k<opcode->n_src + opcode->n_dest;k++){
- args[k] = program->vars + insn->args[k];
- orc_program_append_code(program," %d", args[k]->alloc);
+ args[k] = compiler->vars + insn->args[k];
+ orc_compiler_append_code(compiler," %d", args[k]->alloc);
if (args[k]->is_chained) {
- orc_program_append_code(program," (chained)");
+ orc_compiler_append_code(compiler," (chained)");
}
}
- orc_program_append_code(program,"\n");
+ orc_compiler_append_code(compiler,"\n");
for(k=opcode->n_dest;k<opcode->n_src + opcode->n_dest;k++){
switch (args[k]->vartype) {
case ORC_VAR_TYPE_SRC:
- mmx_emit_load_src (program, args[k]);
+ mmx_emit_load_src (compiler, args[k]);
break;
case ORC_VAR_TYPE_CONST:
break;
rule = insn->rule;
if (rule) {
if (args[0]->alloc != args[1]->alloc) {
- x86_emit_mov_mmx_reg_reg (program, args[1]->alloc, args[0]->alloc);
+ x86_emit_mov_mmx_reg_reg (compiler, args[1]->alloc, args[0]->alloc);
}
- rule->emit (program, rule->emit_user, insn);
+ rule->emit (compiler, rule->emit_user, insn);
} else {
- orc_program_append_code(program,"No rule for: %s\n", opcode->name);
+ orc_compiler_append_code(compiler,"No rule for: %s\n", opcode->name);
}
for(k=0;k<opcode->n_dest;k++){
switch (args[k]->vartype) {
case ORC_VAR_TYPE_DEST:
- mmx_emit_store_dest (program, args[k]);
+ mmx_emit_store_dest (compiler, args[k]);
break;
case ORC_VAR_TYPE_TEMP:
break;
}
}
- for(k=0;k<program->n_vars;k++){
- if (program->vars[k].vartype == ORC_VAR_TYPE_SRC ||
- program->vars[k].vartype == ORC_VAR_TYPE_DEST) {
- if (program->vars[k].ptr_register) {
- x86_emit_add_imm_reg (program, x86_ptr_size,
- program->vars[k].size << program->loop_shift,
- program->vars[k].ptr_register);
+ for(k=0;k<compiler->n_vars;k++){
+ if (compiler->vars[k].vartype == ORC_VAR_TYPE_SRC ||
+ compiler->vars[k].vartype == ORC_VAR_TYPE_DEST) {
+ if (compiler->vars[k].ptr_register) {
+ x86_emit_add_imm_reg (compiler, x86_ptr_size,
+ compiler->vars[k].size << compiler->loop_shift,
+ compiler->vars[k].ptr_register);
} else {
- x86_emit_add_imm_memoffset (program, x86_ptr_size,
- program->vars[k].size << program->loop_shift,
+ x86_emit_add_imm_memoffset (compiler, x86_ptr_size,
+ compiler->vars[k].size << compiler->loop_shift,
(int)ORC_STRUCT_OFFSET(OrcExecutor, arrays[k]),
x86_exec_ptr);
}
#define SIZE 65536
-void powerpc_emit_addi (OrcProgram *program, int regd, int rega, int imm);
-void powerpc_emit_lwz (OrcProgram *program, int regd, int rega, int imm);
-void powerpc_emit_stwu (OrcProgram *program, int regs, int rega, int offset);
+void powerpc_emit_addi (OrcCompiler *compiler, int regd, int rega, int imm);
+void powerpc_emit_lwz (OrcCompiler *compiler, int regd, int rega, int imm);
+void powerpc_emit_stwu (OrcCompiler *compiler, int regs, int rega, int offset);
-void powerpc_emit_ret (OrcProgram *program);
-void powerpc_emit_beq (OrcProgram *program, int label);
-void powerpc_emit_bne (OrcProgram *program, int label);
-void powerpc_emit_label (OrcProgram *program, int label);
+void powerpc_emit_ret (OrcCompiler *compiler);
+void powerpc_emit_beq (OrcCompiler *compiler, int label);
+void powerpc_emit_bne (OrcCompiler *compiler, int label);
+void powerpc_emit_label (OrcCompiler *compiler, int label);
-void orc_program_powerpc_register_rules (void);
+void orc_compiler_powerpc_register_rules (void);
enum {
POWERPC_R0 = ORC_GP_REG_BASE,
}
void
-powerpc_emit(OrcProgram *program, unsigned int insn)
+powerpc_emit(OrcCompiler *compiler, unsigned int insn)
{
- *program->codeptr++ = (insn>>24);
- *program->codeptr++ = (insn>>16);
- *program->codeptr++ = (insn>>8);
- *program->codeptr++ = (insn>>0);
+ *compiler->codeptr++ = (insn>>24);
+ *compiler->codeptr++ = (insn>>16);
+ *compiler->codeptr++ = (insn>>8);
+ *compiler->codeptr++ = (insn>>0);
}
void
-powerpc_emit_prologue (OrcProgram *program)
+powerpc_emit_prologue (OrcCompiler *compiler)
{
int i;
- ORC_ASM_CODE (program, ".global test\n");
- ORC_ASM_CODE (program, "test:\n");
+ ORC_ASM_CODE (compiler, ".global test\n");
+ ORC_ASM_CODE (compiler, "test:\n");
- powerpc_emit_stwu (program, POWERPC_R1, POWERPC_R1, -16);
+ powerpc_emit_stwu (compiler, POWERPC_R1, POWERPC_R1, -16);
for(i=POWERPC_R13;i<=POWERPC_R31;i++){
- if (program->used_regs[i]) {
- //powerpc_emit_push (program, 4, i);
+ if (compiler->used_regs[i]) {
+ //powerpc_emit_push (compiler, 4, i);
}
}
}
void
-powerpc_emit_addi (OrcProgram *program, int regd, int rega, int imm)
+powerpc_emit_addi (OrcCompiler *compiler, int regd, int rega, int imm)
{
unsigned int insn;
- ORC_ASM_CODE(program," addi %s, %s, %d\n",
+ ORC_ASM_CODE(compiler," addi %s, %s, %d\n",
powerpc_get_regname(regd),
powerpc_get_regname(rega), imm);
insn = (14<<26) | (powerpc_regnum (regd)<<21) | (powerpc_regnum (rega)<<16);
insn |= imm&0xffff;
- powerpc_emit (program, insn);
+ powerpc_emit (compiler, insn);
}
void
-powerpc_emit_lwz (OrcProgram *program, int regd, int rega, int imm)
+powerpc_emit_lwz (OrcCompiler *compiler, int regd, int rega, int imm)
{
unsigned int insn;
- ORC_ASM_CODE(program," lwz %s, %d(%s)\n",
+ ORC_ASM_CODE(compiler," lwz %s, %d(%s)\n",
powerpc_get_regname(regd),
imm, powerpc_get_regname(rega));
insn = (32<<26) | (powerpc_regnum (regd)<<21) | (powerpc_regnum (rega)<<16);
insn |= imm&0xffff;
- powerpc_emit (program, insn);
+ powerpc_emit (compiler, insn);
}
void
-powerpc_emit_stwu (OrcProgram *program, int regs, int rega, int offset)
+powerpc_emit_stwu (OrcCompiler *compiler, int regs, int rega, int offset)
{
unsigned int insn;
- ORC_ASM_CODE(program," stwu %s, %d(%s)\n",
+ ORC_ASM_CODE(compiler," stwu %s, %d(%s)\n",
powerpc_get_regname(regs),
offset, powerpc_get_regname(rega));
insn = (37<<26) | (powerpc_regnum (regs)<<21) | (powerpc_regnum (rega)<<16);
insn |= offset&0xffff;
- powerpc_emit (program, insn);
+ powerpc_emit (compiler, insn);
}
void
-powerpc_emit_srawi (OrcProgram *program, int regd, int rega, int shift,
+powerpc_emit_srawi (OrcCompiler *compiler, int regd, int rega, int shift,
int record)
{
unsigned int insn;
- ORC_ASM_CODE(program," srawi%s %s, %s, %d\n", (record)?".":"",
+ ORC_ASM_CODE(compiler," srawi%s %s, %s, %d\n", (record)?".":"",
powerpc_get_regname(regd),
powerpc_get_regname(rega), shift);
insn = (31<<26) | (powerpc_regnum (regd)<<21) | (powerpc_regnum (rega)<<16);
insn |= (shift<<11) | (824<<1) | record;
- powerpc_emit (program, insn);
+ powerpc_emit (compiler, insn);
}
void
-powerpc_emit_655510 (OrcProgram *program, int major, int d, int a, int b,
+powerpc_emit_655510 (OrcCompiler *compiler, int major, int d, int a, int b,
int minor)
{
unsigned int insn;
insn = (major<<26) | (d<<21) | (a<<16);
insn |= (b<<11) | (minor<<0);
- powerpc_emit (program, insn);
+ powerpc_emit (compiler, insn);
}
void
-powerpc_emit_X (OrcProgram *program, int major, int d, int a, int b,
+powerpc_emit_X (OrcCompiler *compiler, int major, int d, int a, int b,
int minor)
{
unsigned int insn;
insn = (major<<26) | (d<<21) | (a<<16);
insn |= (b<<11) | (minor<<1) | (0<<0);
- powerpc_emit (program, insn);
+ powerpc_emit (compiler, insn);
}
void
-powerpc_emit_VA (OrcProgram *program, int major, int d, int a, int b,
+powerpc_emit_VA (OrcCompiler *compiler, int major, int d, int a, int b,
int c, int minor)
{
unsigned int insn;
insn = (major<<26) | (d<<21) | (a<<16);
insn |= (b<<11) | (c<<6) | (minor<<0);
- powerpc_emit (program, insn);
+ powerpc_emit (compiler, insn);
}
void
-powerpc_emit_VX (OrcProgram *program, int major, int d, int a, int b,
+powerpc_emit_VX (OrcCompiler *compiler, int major, int d, int a, int b,
int minor)
{
unsigned int insn;
insn = (major<<26) | (d<<21) | (a<<16);
insn |= (b<<11) | (minor<<0);
- powerpc_emit (program, insn);
+ powerpc_emit (compiler, insn);
}
void
-powerpc_emit_epilogue (OrcProgram *program)
+powerpc_emit_epilogue (OrcCompiler *compiler)
{
int i;
for(i=POWERPC_R31;i>=POWERPC_R31;i--){
- if (program->used_regs[i]) {
- //powerpc_emit_pop (program, 4, i);
+ if (compiler->used_regs[i]) {
+ //powerpc_emit_pop (compiler, 4, i);
}
}
- powerpc_emit_addi (program, POWERPC_R1, POWERPC_R1, 16);
- ORC_ASM_CODE(program," blr\n");
- powerpc_emit(program, 0x4e800020);
+ powerpc_emit_addi (compiler, POWERPC_R1, POWERPC_R1, 16);
+ ORC_ASM_CODE(compiler," blr\n");
+ powerpc_emit(compiler, 0x4e800020);
}
void
-powerpc_do_fixups (OrcProgram *program)
+powerpc_do_fixups (OrcCompiler *compiler)
{
int i;
unsigned int insn;
- for(i=0;i<program->n_fixups;i++){
- if (program->fixups[i].type == 0) {
- unsigned char *label = program->labels[program->fixups[i].label];
- unsigned char *ptr = program->fixups[i].ptr;
+ for(i=0;i<compiler->n_fixups;i++){
+ if (compiler->fixups[i].type == 0) {
+ unsigned char *label = compiler->labels[compiler->fixups[i].label];
+ unsigned char *ptr = compiler->fixups[i].ptr;
insn = *(unsigned int *)ptr;
*(unsigned int *)ptr = (insn&0xffff0000) | ((insn + (label-ptr))&0xffff);
}
void
-powerpc_flush (OrcProgram *program)
+powerpc_flush (OrcCompiler *compiler)
{
#ifdef HAVE_POWERPC
unsigned char *ptr;
int cache_line_size = 32;
int i;
- int size = program->codeptr - program->code;
+ int size = compiler->codeptr - compiler->code;
- ptr = program->code;
+ ptr = compiler->code;
for (i=0;i<size;i+=cache_line_size) {
__asm__ __volatile__ ("dcbst %0,%1" :: "r" (ptr), "r" (i));
}
__asm__ __volatile ("sync");
- ptr = program->code_exec;
+ ptr = compiler->code_exec;
for (i=0;i<size;i+=cache_line_size) {
__asm__ __volatile__ ("icbi %0,%1" :: "r" (ptr), "r" (i));
}
void
orc_powerpc_init (void)
{
- orc_program_powerpc_register_rules ();
+ orc_compiler_powerpc_register_rules ();
}
void
-orc_program_powerpc_init (OrcProgram *program)
+orc_compiler_powerpc_init (OrcCompiler *compiler)
{
int i;
for(i=0;i<32;i++){
- program->valid_regs[POWERPC_R0+i] = 1;
- program->valid_regs[POWERPC_V0+i] = 1;
+ compiler->valid_regs[POWERPC_R0+i] = 1;
+ compiler->valid_regs[POWERPC_V0+i] = 1;
}
- program->valid_regs[POWERPC_R0] = 0; /* used for temp space */
- program->valid_regs[POWERPC_R1] = 0; /* stack pointer */
- program->valid_regs[POWERPC_R2] = 0; /* TOC pointer */
- program->valid_regs[POWERPC_R3] = 0; /* pointer to OrcExecutor */
- program->valid_regs[POWERPC_R13] = 0; /* reserved */
- program->valid_regs[POWERPC_V0] = 0; /* used for temp space */
+ compiler->valid_regs[POWERPC_R0] = 0; /* used for temp space */
+ compiler->valid_regs[POWERPC_R1] = 0; /* stack pointer */
+ compiler->valid_regs[POWERPC_R2] = 0; /* TOC pointer */
+ compiler->valid_regs[POWERPC_R3] = 0; /* pointer to OrcExecutor */
+ compiler->valid_regs[POWERPC_R13] = 0; /* reserved */
+ compiler->valid_regs[POWERPC_V0] = 0; /* used for temp space */
for(i=14;i<32;i++){
- program->save_regs[POWERPC_R0 + i] = 1;
+ compiler->save_regs[POWERPC_R0 + i] = 1;
}
for(i=20;i<32;i++){
- program->save_regs[POWERPC_V0 + i] = 1;
+ compiler->save_regs[POWERPC_V0 + i] = 1;
}
- program->loop_shift = 2;
+ compiler->loop_shift = 2;
}
void
-powerpc_load_constants (OrcProgram *program)
+powerpc_load_constants (OrcCompiler *compiler)
{
int i;
- for(i=0;i<program->n_vars;i++){
- switch (program->vars[i].vartype) {
+ for(i=0;i<compiler->n_vars;i++){
+ switch (compiler->vars[i].vartype) {
case ORC_VAR_TYPE_CONST:
- ORC_ASM_CODE(program," vspltish %s, %d\n",
- powerpc_get_regname(program->vars[i].alloc),
- (int)program->vars[i].value);
- powerpc_emit_655510 (program, 4,
- powerpc_regnum(program->vars[i].alloc),
- (int)program->vars[i].value, 0, 844);
+ ORC_ASM_CODE(compiler," vspltish %s, %d\n",
+ powerpc_get_regname(compiler->vars[i].alloc),
+ (int)compiler->vars[i].value);
+ powerpc_emit_655510 (compiler, 4,
+ powerpc_regnum(compiler->vars[i].alloc),
+ (int)compiler->vars[i].value, 0, 844);
break;
case ORC_VAR_TYPE_SRC:
case ORC_VAR_TYPE_DEST:
- if (program->vars[i].ptr_register) {
- powerpc_emit_lwz (program,
- program->vars[i].ptr_register,
+ if (compiler->vars[i].ptr_register) {
+ powerpc_emit_lwz (compiler,
+ compiler->vars[i].ptr_register,
POWERPC_R3,
(int)ORC_STRUCT_OFFSET(OrcExecutor, arrays[i]));
} else {
/* FIXME */
- ORC_ASM_CODE(program,"ERROR");
+ ORC_ASM_CODE(compiler,"ERROR");
}
break;
default:
}
void
-powerpc_emit_load_src (OrcProgram *program, OrcVariable *var)
+powerpc_emit_load_src (OrcCompiler *compiler, OrcVariable *var)
{
int ptr_reg;
ptr_reg = var->ptr_register;
- switch (program->loop_shift) {
+ switch (compiler->loop_shift) {
case 0:
- ORC_ASM_CODE(program," lvehx %s, 0, %s\n",
+ ORC_ASM_CODE(compiler," lvehx %s, 0, %s\n",
powerpc_get_regname (var->alloc),
powerpc_get_regname (ptr_reg));
- powerpc_emit_X (program, 31, powerpc_regnum(var->alloc),
+ powerpc_emit_X (compiler, 31, powerpc_regnum(var->alloc),
0, powerpc_regnum(ptr_reg), 39);
- ORC_ASM_CODE(program," lvsl %s, 0, %s\n",
+ ORC_ASM_CODE(compiler," lvsl %s, 0, %s\n",
powerpc_get_regname (POWERPC_V0),
powerpc_get_regname (ptr_reg));
- powerpc_emit_X (program, 31, powerpc_regnum(POWERPC_V0),
+ powerpc_emit_X (compiler, 31, powerpc_regnum(POWERPC_V0),
0, powerpc_regnum(ptr_reg), 6);
- ORC_ASM_CODE(program," vperm %s, %s, %s, %s\n",
+ ORC_ASM_CODE(compiler," vperm %s, %s, %s, %s\n",
powerpc_get_regname (var->alloc),
powerpc_get_regname (var->alloc),
powerpc_get_regname (var->alloc),
powerpc_get_regname (POWERPC_V0));
- powerpc_emit_VA (program, 4,
+ powerpc_emit_VA (compiler, 4,
powerpc_regnum(var->alloc),
powerpc_regnum(var->alloc),
powerpc_regnum(var->alloc),
powerpc_regnum(POWERPC_V0), 43);
break;
default:
- ORC_ASM_CODE(program,"ERROR\n");
+ ORC_ASM_CODE(compiler,"ERROR\n");
}
}
void
-powerpc_emit_store_dest (OrcProgram *program, OrcVariable *var)
+powerpc_emit_store_dest (OrcCompiler *compiler, OrcVariable *var)
{
int ptr_reg;
ptr_reg = var->ptr_register;
- switch (program->loop_shift) {
+ switch (compiler->loop_shift) {
case 0:
- ORC_ASM_CODE(program," lvsr %s, 0, %s\n",
+ ORC_ASM_CODE(compiler," lvsr %s, 0, %s\n",
powerpc_get_regname (POWERPC_V0),
powerpc_get_regname (ptr_reg));
- powerpc_emit_X (program, 31, powerpc_regnum(POWERPC_V0),
+ powerpc_emit_X (compiler, 31, powerpc_regnum(POWERPC_V0),
0, powerpc_regnum(ptr_reg), 38);
- ORC_ASM_CODE(program," vperm %s, %s, %s, %s\n",
+ ORC_ASM_CODE(compiler," vperm %s, %s, %s, %s\n",
powerpc_get_regname (var->alloc),
powerpc_get_regname (var->alloc),
powerpc_get_regname (var->alloc),
powerpc_get_regname (POWERPC_V0));
- powerpc_emit_VA (program, 4,
+ powerpc_emit_VA (compiler, 4,
powerpc_regnum(var->alloc),
powerpc_regnum(var->alloc),
powerpc_regnum(var->alloc),
powerpc_regnum(POWERPC_V0), 43);
- ORC_ASM_CODE(program," stvehx %s, 0, %s\n",
+ ORC_ASM_CODE(compiler," stvehx %s, 0, %s\n",
powerpc_get_regname (var->alloc),
powerpc_get_regname (ptr_reg));
- powerpc_emit_X (program, 31,
+ powerpc_emit_X (compiler, 31,
powerpc_regnum(var->alloc),
0, powerpc_regnum(ptr_reg), 167);
break;
default:
- ORC_ASM_CODE(program,"ERROR\n");
+ ORC_ASM_CODE(compiler,"ERROR\n");
}
}
void
-orc_program_assemble_powerpc (OrcProgram *program)
+orc_compiler_assemble_powerpc (OrcCompiler *compiler)
{
int j;
int k;
OrcVariable *args[10];
OrcRule *rule;
- powerpc_emit_prologue (program);
+ powerpc_emit_prologue (compiler);
- powerpc_emit_lwz (program, POWERPC_R0, POWERPC_R3,
+ powerpc_emit_lwz (compiler, POWERPC_R0, POWERPC_R3,
(int)ORC_STRUCT_OFFSET(OrcExecutor, n));
- powerpc_emit_srawi (program, POWERPC_R0, POWERPC_R0,
- program->loop_shift, 1);
+ powerpc_emit_srawi (compiler, POWERPC_R0, POWERPC_R0,
+ compiler->loop_shift, 1);
- powerpc_emit_beq (program, 1);
+ powerpc_emit_beq (compiler, 1);
- powerpc_emit (program, 0x7c0903a6);
- ORC_ASM_CODE (program, " mtctr %s\n", powerpc_get_regname(POWERPC_R0));
+ powerpc_emit (compiler, 0x7c0903a6);
+ ORC_ASM_CODE (compiler, " mtctr %s\n", powerpc_get_regname(POWERPC_R0));
- powerpc_load_constants (program);
+ powerpc_load_constants (compiler);
- powerpc_emit_label (program, 0);
+ powerpc_emit_label (compiler, 0);
- for(j=0;j<program->n_insns;j++){
- insn = program->insns + j;
+ for(j=0;j<compiler->n_insns;j++){
+ insn = compiler->insns + j;
opcode = insn->opcode;
- ORC_ASM_CODE(program,"# %d: %s", j, insn->opcode->name);
+ ORC_ASM_CODE(compiler,"# %d: %s", j, insn->opcode->name);
/* set up args */
for(k=0;k<opcode->n_src + opcode->n_dest;k++){
- args[k] = program->vars + insn->args[k];
- ORC_ASM_CODE(program," %d", args[k]->alloc);
+ args[k] = compiler->vars + insn->args[k];
+ ORC_ASM_CODE(compiler," %d", args[k]->alloc);
if (args[k]->is_chained) {
- ORC_ASM_CODE(program," (chained)");
+ ORC_ASM_CODE(compiler," (chained)");
}
}
- ORC_ASM_CODE(program,"\n");
+ ORC_ASM_CODE(compiler,"\n");
for(k=opcode->n_dest;k<opcode->n_src + opcode->n_dest;k++){
switch (args[k]->vartype) {
case ORC_VAR_TYPE_SRC:
- powerpc_emit_load_src (program, args[k]);
+ powerpc_emit_load_src (compiler, args[k]);
break;
case ORC_VAR_TYPE_CONST:
break;
rule = insn->rule;
if (rule) {
- rule->emit (program, rule->emit_user, insn);
+ rule->emit (compiler, rule->emit_user, insn);
} else {
- ORC_ASM_CODE(program,"No rule for: %s\n", opcode->name);
+ ORC_ASM_CODE(compiler,"No rule for: %s\n", opcode->name);
}
for(k=0;k<opcode->n_dest;k++){
switch (args[k]->vartype) {
case ORC_VAR_TYPE_DEST:
- powerpc_emit_store_dest (program, args[k]);
+ powerpc_emit_store_dest (compiler, args[k]);
break;
case ORC_VAR_TYPE_TEMP:
break;
}
}
- for(k=0;k<program->n_vars;k++){
- if (program->vars[k].vartype == ORC_VAR_TYPE_SRC ||
- program->vars[k].vartype == ORC_VAR_TYPE_DEST) {
- if (program->vars[k].ptr_register) {
- powerpc_emit_addi (program,
- program->vars[k].ptr_register,
- program->vars[k].ptr_register,
- program->vars[k].size << program->loop_shift);
+ for(k=0;k<compiler->n_vars;k++){
+ if (compiler->vars[k].vartype == ORC_VAR_TYPE_SRC ||
+ compiler->vars[k].vartype == ORC_VAR_TYPE_DEST) {
+ if (compiler->vars[k].ptr_register) {
+ powerpc_emit_addi (compiler,
+ compiler->vars[k].ptr_register,
+ compiler->vars[k].ptr_register,
+ compiler->vars[k].size << compiler->loop_shift);
} else {
- ORC_ASM_CODE(program,"ERROR\n");
+ ORC_ASM_CODE(compiler,"ERROR\n");
}
}
}
- powerpc_emit_bne (program, 0);
- powerpc_emit_label (program, 1);
+ powerpc_emit_bne (compiler, 0);
+ powerpc_emit_label (compiler, 1);
- powerpc_emit_epilogue (program);
+ powerpc_emit_epilogue (compiler);
- powerpc_do_fixups (program);
+ powerpc_do_fixups (compiler);
- powerpc_flush (program);
+ powerpc_flush (compiler);
}
/* rules */
static void
-powerpc_rule_addw (OrcProgram *p, void *user, OrcInstruction *insn)
+powerpc_rule_addw (OrcCompiler *p, void *user, OrcInstruction *insn)
{
unsigned int x;
}
static void
-powerpc_rule_subw (OrcProgram *p, void *user, OrcInstruction *insn)
+powerpc_rule_subw (OrcCompiler *p, void *user, OrcInstruction *insn)
{
ORC_ASM_CODE(p," vsubuhm %s, %s, %s\n",
powerpc_get_regname(p->vars[insn->args[0]].alloc),
}
static void
-powerpc_rule_mullw (OrcProgram *p, void *user, OrcInstruction *insn)
+powerpc_rule_mullw (OrcCompiler *p, void *user, OrcInstruction *insn)
{
ORC_ASM_CODE(p," vxor %s, %s, %s\n",
powerpc_get_regname(POWERPC_V0),
}
static void
-powerpc_rule_shlw (OrcProgram *p, void *user, OrcInstruction *insn)
+powerpc_rule_shlw (OrcCompiler *p, void *user, OrcInstruction *insn)
{
ORC_ASM_CODE(p," vrlh %s, %s, %s\n",
powerpc_get_regname(p->vars[insn->args[0]].alloc),
}
static void
-powerpc_rule_shrsw (OrcProgram *p, void *user, OrcInstruction *insn)
+powerpc_rule_shrsw (OrcCompiler *p, void *user, OrcInstruction *insn)
{
unsigned int x;
void
-orc_program_powerpc_register_rules (void)
+orc_compiler_powerpc_register_rules (void)
{
orc_rule_register ("addw", ORC_TARGET_ALTIVEC, powerpc_rule_addw, NULL);
orc_rule_register ("subw", ORC_TARGET_ALTIVEC, powerpc_rule_subw, NULL);
/* code generation */
-void powerpc_emit_ret (OrcProgram *program)
+void powerpc_emit_ret (OrcCompiler *compiler)
{
- ORC_ASM_CODE(program," ret\n");
- //*program->codeptr++ = 0xc3;
+ ORC_ASM_CODE(compiler," ret\n");
+ //*compiler->codeptr++ = 0xc3;
}
void
-powerpc_add_fixup (OrcProgram *program, unsigned char *ptr, int label)
+powerpc_add_fixup (OrcCompiler *compiler, unsigned char *ptr, int label)
{
- program->fixups[program->n_fixups].ptr = ptr;
- program->fixups[program->n_fixups].label = label;
- program->fixups[program->n_fixups].type = 0;
- program->n_fixups++;
+ compiler->fixups[compiler->n_fixups].ptr = ptr;
+ compiler->fixups[compiler->n_fixups].label = label;
+ compiler->fixups[compiler->n_fixups].type = 0;
+ compiler->n_fixups++;
}
void
-powerpc_add_label (OrcProgram *program, unsigned char *ptr, int label)
+powerpc_add_label (OrcCompiler *compiler, unsigned char *ptr, int label)
{
- program->labels[label] = ptr;
+ compiler->labels[label] = ptr;
}
-void powerpc_emit_beq (OrcProgram *program, int label)
+void powerpc_emit_beq (OrcCompiler *compiler, int label)
{
- ORC_ASM_CODE(program," ble- .L%d\n", label);
+ ORC_ASM_CODE(compiler," ble- .L%d\n", label);
- powerpc_add_fixup (program, program->codeptr, label);
- powerpc_emit (program, 0x40810000);
+ powerpc_add_fixup (compiler, compiler->codeptr, label);
+ powerpc_emit (compiler, 0x40810000);
}
-void powerpc_emit_bne (OrcProgram *program, int label)
+void powerpc_emit_bne (OrcCompiler *compiler, int label)
{
- ORC_ASM_CODE(program," bdnz+ .L%d\n", label);
+ ORC_ASM_CODE(compiler," bdnz+ .L%d\n", label);
- powerpc_add_fixup (program, program->codeptr, label);
- powerpc_emit (program, 0x42000000);
+ powerpc_add_fixup (compiler, compiler->codeptr, label);
+ powerpc_emit (compiler, 0x42000000);
}
-void powerpc_emit_label (OrcProgram *program, int label)
+void powerpc_emit_label (OrcCompiler *compiler, int label)
{
- ORC_ASM_CODE(program,".L%d:\n", label);
+ ORC_ASM_CODE(compiler,".L%d:\n", label);
- powerpc_add_label (program, program->codeptr, label);
+ powerpc_add_label (compiler, compiler->codeptr, label);
}
#define SIZE 65536
-void sse_emit_loop (OrcProgram *program);
+void sse_emit_loop (OrcCompiler *compiler);
-void orc_program_sse_register_rules (void);
+void orc_compiler_sse_register_rules (void);
-void orc_program_rewrite_vars (OrcProgram *program);
-void orc_program_dump (OrcProgram *program);
+void orc_compiler_rewrite_vars (OrcCompiler *compiler);
+void orc_compiler_dump (OrcCompiler *compiler);
void
orc_sse_init (void)
{
- orc_program_sse_register_rules ();
+ orc_compiler_sse_register_rules ();
}
void
-orc_program_sse_init (OrcProgram *program)
+orc_compiler_sse_init (OrcCompiler *compiler)
{
int i;
if (x86_64) {
for(i=ORC_GP_REG_BASE;i<ORC_GP_REG_BASE+16;i++){
- program->valid_regs[i] = 1;
+ compiler->valid_regs[i] = 1;
}
- program->valid_regs[X86_ECX] = 0;
- program->valid_regs[X86_EDI] = 0;
- program->valid_regs[X86_ESP] = 0;
+ compiler->valid_regs[X86_ECX] = 0;
+ compiler->valid_regs[X86_EDI] = 0;
+ compiler->valid_regs[X86_ESP] = 0;
for(i=X86_XMM0;i<X86_XMM0+16;i++){
- program->valid_regs[i] = 1;
+ compiler->valid_regs[i] = 1;
}
- program->save_regs[X86_EBX] = 1;
- program->save_regs[X86_EBP] = 1;
- program->save_regs[X86_R12] = 1;
- program->save_regs[X86_R13] = 1;
- program->save_regs[X86_R14] = 1;
- program->save_regs[X86_R15] = 1;
+ compiler->save_regs[X86_EBX] = 1;
+ compiler->save_regs[X86_EBP] = 1;
+ compiler->save_regs[X86_R12] = 1;
+ compiler->save_regs[X86_R13] = 1;
+ compiler->save_regs[X86_R14] = 1;
+ compiler->save_regs[X86_R15] = 1;
} else {
for(i=ORC_GP_REG_BASE;i<ORC_GP_REG_BASE+8;i++){
- program->valid_regs[i] = 1;
+ compiler->valid_regs[i] = 1;
}
- program->valid_regs[X86_ECX] = 0;
- program->valid_regs[X86_ESP] = 0;
- program->valid_regs[X86_EBP] = 0;
+ compiler->valid_regs[X86_ECX] = 0;
+ compiler->valid_regs[X86_ESP] = 0;
+ compiler->valid_regs[X86_EBP] = 0;
for(i=X86_XMM0;i<X86_XMM0+8;i++){
- program->valid_regs[i] = 1;
+ compiler->valid_regs[i] = 1;
}
- program->save_regs[X86_EBX] = 1;
- program->save_regs[X86_EDI] = 1;
- program->save_regs[X86_EBP] = 1;
+ compiler->save_regs[X86_EBX] = 1;
+ compiler->save_regs[X86_EDI] = 1;
+ compiler->save_regs[X86_EBP] = 1;
}
for(i=X86_MM0;i<X86_MM0+8;i++){
- program->valid_regs[i] = 1;
+ compiler->valid_regs[i] = 1;
}
for(i=0;i<128;i++){
- program->alloc_regs[i] = 0;
- program->used_regs[i] = 0;
+ compiler->alloc_regs[i] = 0;
+ compiler->used_regs[i] = 0;
}
- program->loop_shift = 3;
+ compiler->loop_shift = 3;
}
void
-sse_load_constants (OrcProgram *program)
+sse_load_constants (OrcCompiler *compiler)
{
int i;
- for(i=0;i<program->n_vars;i++){
- switch (program->vars[i].vartype) {
+ for(i=0;i<compiler->n_vars;i++){
+ switch (compiler->vars[i].vartype) {
case ORC_VAR_TYPE_CONST:
- sse_emit_loadiw (program, program->vars[i].alloc,
- (int)program->vars[i].value);
+ sse_emit_loadiw (compiler, compiler->vars[i].alloc,
+ (int)compiler->vars[i].value);
break;
case ORC_VAR_TYPE_PARAM:
- sse_emit_loadw (program, program->vars[i].alloc,
+ sse_emit_loadw (compiler, compiler->vars[i].alloc,
(int)ORC_STRUCT_OFFSET(OrcExecutor, params[i]), x86_exec_ptr);
break;
case ORC_VAR_TYPE_SRC:
case ORC_VAR_TYPE_DEST:
- if (program->vars[i].ptr_register) {
- x86_emit_mov_memoffset_reg (program, x86_ptr_size,
+ if (compiler->vars[i].ptr_register) {
+ x86_emit_mov_memoffset_reg (compiler, x86_ptr_size,
(int)ORC_STRUCT_OFFSET(OrcExecutor, arrays[i]), x86_exec_ptr,
- program->vars[i].ptr_register);
+ compiler->vars[i].ptr_register);
} else {
- ORC_PROGRAM_ERROR(program,"unimplemented");
+ ORC_PROGRAM_ERROR(compiler,"unimplemented");
}
break;
default:
}
void
-sse_emit_load_src (OrcProgram *program, OrcVariable *var)
+sse_emit_load_src (OrcCompiler *compiler, OrcVariable *var)
{
int ptr_reg;
if (var->ptr_register == 0) {
int i;
- i = var - program->vars;
- x86_emit_mov_memoffset_reg (program, x86_ptr_size,
+ i = var - compiler->vars;
+ x86_emit_mov_memoffset_reg (compiler, x86_ptr_size,
(int)ORC_STRUCT_OFFSET(OrcExecutor, arrays[i]),
x86_exec_ptr, X86_ECX);
ptr_reg = X86_ECX;
} else {
ptr_reg = var->ptr_register;
}
- switch (var->size << program->loop_shift) {
+ switch (var->size << compiler->loop_shift) {
case 1:
- x86_emit_mov_memoffset_reg (program, 1, 0, ptr_reg, X86_ECX);
- x86_emit_mov_reg_sse (program, X86_ECX, var->alloc);
+ x86_emit_mov_memoffset_reg (compiler, 1, 0, ptr_reg, X86_ECX);
+ x86_emit_mov_reg_sse (compiler, X86_ECX, var->alloc);
break;
case 2:
- x86_emit_mov_memoffset_reg (program, 2, 0, ptr_reg, X86_ECX);
- x86_emit_mov_reg_sse (program, X86_ECX, var->alloc);
+ x86_emit_mov_memoffset_reg (compiler, 2, 0, ptr_reg, X86_ECX);
+ x86_emit_mov_reg_sse (compiler, X86_ECX, var->alloc);
break;
case 4:
- x86_emit_mov_memoffset_sse (program, 4, 0, ptr_reg, var->alloc);
+ x86_emit_mov_memoffset_sse (compiler, 4, 0, ptr_reg, var->alloc);
break;
case 8:
- x86_emit_mov_memoffset_sse (program, 8, 0, ptr_reg, var->alloc);
+ x86_emit_mov_memoffset_sse (compiler, 8, 0, ptr_reg, var->alloc);
break;
case 16:
- x86_emit_mov_memoffset_sse (program, 16, 0, ptr_reg, var->alloc);
+ x86_emit_mov_memoffset_sse (compiler, 16, 0, ptr_reg, var->alloc);
break;
default:
- ORC_PROGRAM_ERROR(program,"unimplemented");
+ ORC_PROGRAM_ERROR(compiler,"unimplemented");
break;
}
}
void
-sse_emit_store_dest (OrcProgram *program, OrcVariable *var)
+sse_emit_store_dest (OrcCompiler *compiler, OrcVariable *var)
{
int ptr_reg;
if (var->ptr_register == 0) {
- x86_emit_mov_memoffset_reg (program, x86_ptr_size,
+ x86_emit_mov_memoffset_reg (compiler, x86_ptr_size,
var->ptr_offset, x86_exec_ptr, X86_ECX);
ptr_reg = X86_ECX;
} else {
ptr_reg = var->ptr_register;
}
- switch (var->size << program->loop_shift) {
+ switch (var->size << compiler->loop_shift) {
case 1:
/* FIXME we might be using ecx twice here */
if (ptr_reg == X86_ECX) {
- ORC_PROGRAM_ERROR(program,"unimplemented");
+ ORC_PROGRAM_ERROR(compiler,"unimplemented");
}
- x86_emit_mov_sse_reg (program, var->alloc, X86_ECX);
- x86_emit_mov_reg_memoffset (program, 1, X86_ECX, 0, ptr_reg);
+ x86_emit_mov_sse_reg (compiler, var->alloc, X86_ECX);
+ x86_emit_mov_reg_memoffset (compiler, 1, X86_ECX, 0, ptr_reg);
break;
case 2:
/* FIXME we might be using ecx twice here */
if (ptr_reg == X86_ECX) {
- ORC_PROGRAM_ERROR(program,"unimplemented");
+ ORC_PROGRAM_ERROR(compiler,"unimplemented");
}
- x86_emit_mov_sse_reg (program, var->alloc, X86_ECX);
- x86_emit_mov_reg_memoffset (program, 2, X86_ECX, 0, ptr_reg);
+ x86_emit_mov_sse_reg (compiler, var->alloc, X86_ECX);
+ x86_emit_mov_reg_memoffset (compiler, 2, X86_ECX, 0, ptr_reg);
break;
case 4:
- x86_emit_mov_sse_memoffset (program, 4, var->alloc, 0, ptr_reg,
+ x86_emit_mov_sse_memoffset (compiler, 4, var->alloc, 0, ptr_reg,
var->is_aligned, var->is_uncached);
break;
case 8:
- x86_emit_mov_sse_memoffset (program, 8, var->alloc, 0, ptr_reg,
+ x86_emit_mov_sse_memoffset (compiler, 8, var->alloc, 0, ptr_reg,
var->is_aligned, var->is_uncached);
break;
case 16:
- x86_emit_mov_sse_memoffset (program, 16, var->alloc, 0, ptr_reg,
+ x86_emit_mov_sse_memoffset (compiler, 16, var->alloc, 0, ptr_reg,
var->is_aligned, var->is_uncached);
break;
default:
- ORC_PROGRAM_ERROR(program,"bad size");
+ ORC_PROGRAM_ERROR(compiler,"bad size");
break;
}
}
void
-orc_program_sse_assemble (OrcProgram *program)
+orc_compiler_sse_assemble (OrcCompiler *compiler)
{
- int dest_var = orc_program_get_dest (program);
+ int dest_var = orc_compiler_get_dest (compiler);
- program->vars[dest_var].is_aligned = FALSE;
+ compiler->vars[dest_var].is_aligned = FALSE;
- x86_emit_prologue (program);
+ x86_emit_prologue (compiler);
- if (program->loop_shift > 0) {
+ if (compiler->loop_shift > 0) {
- x86_emit_mov_imm_reg (program, 4, 16, X86_EAX);
- x86_emit_sub_memoffset_reg (program, 4,
+ x86_emit_mov_imm_reg (compiler, 4, 16, X86_EAX);
+ x86_emit_sub_memoffset_reg (compiler, 4,
(int)ORC_STRUCT_OFFSET(OrcExecutor, arrays[dest_var]),
x86_exec_ptr, X86_EAX);
- x86_emit_and_imm_reg (program, 4, 15, X86_EAX);
+ x86_emit_and_imm_reg (compiler, 4, 15, X86_EAX);
/* FIXME size shift */
- x86_emit_sar_imm_reg (program, 4, 1, X86_EAX);
+ x86_emit_sar_imm_reg (compiler, 4, 1, X86_EAX);
- x86_emit_cmp_reg_memoffset (program, 4, X86_EAX,
+ x86_emit_cmp_reg_memoffset (compiler, 4, X86_EAX,
(int)ORC_STRUCT_OFFSET(OrcExecutor,n), x86_exec_ptr);
- x86_emit_jle (program, 6);
+ x86_emit_jle (compiler, 6);
- x86_emit_mov_reg_memoffset (program, 4, X86_EAX,
+ x86_emit_mov_reg_memoffset (compiler, 4, X86_EAX,
(int)ORC_STRUCT_OFFSET(OrcExecutor,counter1), x86_exec_ptr);
- x86_emit_mov_memoffset_reg (program, 4,
+ x86_emit_mov_memoffset_reg (compiler, 4,
(int)ORC_STRUCT_OFFSET(OrcExecutor,n), x86_exec_ptr, X86_ECX);
- x86_emit_sub_reg_reg (program, 4, X86_EAX, X86_ECX);
+ x86_emit_sub_reg_reg (compiler, 4, X86_EAX, X86_ECX);
- x86_emit_mov_reg_reg (program, 4, X86_ECX, X86_EAX);
+ x86_emit_mov_reg_reg (compiler, 4, X86_ECX, X86_EAX);
- x86_emit_sar_imm_reg (program, 4, program->loop_shift, X86_ECX);
- x86_emit_mov_reg_memoffset (program, 4, X86_ECX,
+ x86_emit_sar_imm_reg (compiler, 4, compiler->loop_shift, X86_ECX);
+ x86_emit_mov_reg_memoffset (compiler, 4, X86_ECX,
(int)ORC_STRUCT_OFFSET(OrcExecutor,counter2), x86_exec_ptr);
- x86_emit_and_imm_reg (program, 4, (1<<program->loop_shift)-1, X86_EAX);
- x86_emit_mov_reg_memoffset (program, 4, X86_EAX,
+ x86_emit_and_imm_reg (compiler, 4, (1<<compiler->loop_shift)-1, X86_EAX);
+ x86_emit_mov_reg_memoffset (compiler, 4, X86_EAX,
(int)ORC_STRUCT_OFFSET(OrcExecutor,counter3), x86_exec_ptr);
- x86_emit_jmp (program, 7);
- x86_emit_label (program, 6);
+ x86_emit_jmp (compiler, 7);
+ x86_emit_label (compiler, 6);
- x86_emit_mov_memoffset_reg (program, 4,
+ x86_emit_mov_memoffset_reg (compiler, 4,
(int)ORC_STRUCT_OFFSET(OrcExecutor,n), x86_exec_ptr, X86_EAX);
- x86_emit_mov_reg_memoffset (program, 4, X86_EAX,
+ x86_emit_mov_reg_memoffset (compiler, 4, X86_EAX,
(int)ORC_STRUCT_OFFSET(OrcExecutor,counter1), x86_exec_ptr);
- x86_emit_mov_imm_reg (program, 4, 0, X86_EAX);
- x86_emit_mov_reg_memoffset (program, 4, X86_EAX,
+ x86_emit_mov_imm_reg (compiler, 4, 0, X86_EAX);
+ x86_emit_mov_reg_memoffset (compiler, 4, X86_EAX,
(int)ORC_STRUCT_OFFSET(OrcExecutor,counter2), x86_exec_ptr);
- x86_emit_mov_reg_memoffset (program, 4, X86_EAX,
+ x86_emit_mov_reg_memoffset (compiler, 4, X86_EAX,
(int)ORC_STRUCT_OFFSET(OrcExecutor,counter3), x86_exec_ptr);
- x86_emit_label (program, 7);
+ x86_emit_label (compiler, 7);
} else {
- x86_emit_mov_memoffset_reg (program, 4,
+ x86_emit_mov_memoffset_reg (compiler, 4,
(int)ORC_STRUCT_OFFSET(OrcExecutor,n), x86_exec_ptr, X86_ECX);
- x86_emit_mov_reg_memoffset (program, 4, X86_ECX,
+ x86_emit_mov_reg_memoffset (compiler, 4, X86_ECX,
(int)ORC_STRUCT_OFFSET(OrcExecutor,counter2), x86_exec_ptr);
}
- sse_load_constants (program);
+ sse_load_constants (compiler);
- if (program->loop_shift > 0) {
+ if (compiler->loop_shift > 0) {
int save_loop_shift;
- x86_emit_cmp_imm_memoffset (program, 4, 0,
+ x86_emit_cmp_imm_memoffset (compiler, 4, 0,
(int)ORC_STRUCT_OFFSET(OrcExecutor,counter1), x86_exec_ptr);
- x86_emit_je (program, 1);
+ x86_emit_je (compiler, 1);
- save_loop_shift = program->loop_shift;
- program->loop_shift = 0;
+ save_loop_shift = compiler->loop_shift;
+ compiler->loop_shift = 0;
- x86_emit_label (program, 0);
- sse_emit_loop (program);
- x86_emit_dec_memoffset (program, 4,
+ x86_emit_label (compiler, 0);
+ sse_emit_loop (compiler);
+ x86_emit_dec_memoffset (compiler, 4,
(int)ORC_STRUCT_OFFSET(OrcExecutor,counter1),
x86_exec_ptr);
- x86_emit_jne (program, 0);
+ x86_emit_jne (compiler, 0);
- program->loop_shift = save_loop_shift;
- program->vars[dest_var].is_aligned = TRUE;
+ compiler->loop_shift = save_loop_shift;
+ compiler->vars[dest_var].is_aligned = TRUE;
}
- x86_emit_label (program, 1);
+ x86_emit_label (compiler, 1);
- x86_emit_cmp_imm_memoffset (program, 4, 0,
+ x86_emit_cmp_imm_memoffset (compiler, 4, 0,
(int)ORC_STRUCT_OFFSET(OrcExecutor,counter2), x86_exec_ptr);
- x86_emit_je (program, 3);
+ x86_emit_je (compiler, 3);
- x86_emit_align (program);
- x86_emit_label (program, 2);
- sse_emit_loop (program);
- x86_emit_dec_memoffset (program, 4,
+ x86_emit_align (compiler);
+ x86_emit_label (compiler, 2);
+ sse_emit_loop (compiler);
+ x86_emit_dec_memoffset (compiler, 4,
(int)ORC_STRUCT_OFFSET(OrcExecutor,counter2),
x86_exec_ptr);
- x86_emit_jne (program, 2);
- x86_emit_label (program, 3);
+ x86_emit_jne (compiler, 2);
+ x86_emit_label (compiler, 3);
- if (program->loop_shift > 0) {
+ if (compiler->loop_shift > 0) {
int save_loop_shift;
- program->vars[dest_var].is_aligned = FALSE;
- x86_emit_cmp_imm_memoffset (program, 4, 0,
+ compiler->vars[dest_var].is_aligned = FALSE;
+ x86_emit_cmp_imm_memoffset (compiler, 4, 0,
(int)ORC_STRUCT_OFFSET(OrcExecutor,counter3), x86_exec_ptr);
- x86_emit_je (program, 5);
+ x86_emit_je (compiler, 5);
- save_loop_shift = program->loop_shift;
- program->loop_shift = 0;
+ save_loop_shift = compiler->loop_shift;
+ compiler->loop_shift = 0;
- x86_emit_label (program, 4);
- sse_emit_loop (program);
- x86_emit_dec_memoffset (program, 4,
+ x86_emit_label (compiler, 4);
+ sse_emit_loop (compiler);
+ x86_emit_dec_memoffset (compiler, 4,
(int)ORC_STRUCT_OFFSET(OrcExecutor,counter3),
x86_exec_ptr);
- x86_emit_jne (program, 4);
+ x86_emit_jne (compiler, 4);
- x86_emit_label (program, 5);
+ x86_emit_label (compiler, 5);
- program->loop_shift = save_loop_shift;
+ compiler->loop_shift = save_loop_shift;
}
- x86_emit_epilogue (program);
+ x86_emit_epilogue (compiler);
- x86_do_fixups (program);
+ x86_do_fixups (compiler);
}
void
-sse_emit_loop (OrcProgram *program)
+sse_emit_loop (OrcCompiler *compiler)
{
int j;
int k;
OrcVariable *args[10];
OrcRule *rule;
- for(j=0;j<program->n_insns;j++){
- insn = program->insns + j;
+ for(j=0;j<compiler->n_insns;j++){
+ insn = compiler->insns + j;
opcode = insn->opcode;
- ORC_ASM_CODE(program,"# %d: %s", j, insn->opcode->name);
+ ORC_ASM_CODE(compiler,"# %d: %s", j, insn->opcode->name);
/* set up args */
for(k=0;k<opcode->n_src + opcode->n_dest;k++){
- args[k] = program->vars + insn->args[k];
- ORC_ASM_CODE(program," %d", args[k]->alloc);
+ args[k] = compiler->vars + insn->args[k];
+ ORC_ASM_CODE(compiler," %d", args[k]->alloc);
if (args[k]->is_chained) {
- ORC_ASM_CODE(program," (chained)");
+ ORC_ASM_CODE(compiler," (chained)");
}
}
- ORC_ASM_CODE(program,"\n");
+ ORC_ASM_CODE(compiler,"\n");
for(k=opcode->n_dest;k<opcode->n_src + opcode->n_dest;k++){
switch (args[k]->vartype) {
case ORC_VAR_TYPE_SRC:
- sse_emit_load_src (program, args[k]);
+ sse_emit_load_src (compiler, args[k]);
break;
case ORC_VAR_TYPE_CONST:
break;
rule = insn->rule;
if (rule && rule->emit) {
if (args[0]->alloc != args[1]->alloc) {
- x86_emit_mov_sse_reg_reg (program, args[1]->alloc, args[0]->alloc);
+ x86_emit_mov_sse_reg_reg (compiler, args[1]->alloc, args[0]->alloc);
}
- rule->emit (program, rule->emit_user, insn);
+ rule->emit (compiler, rule->emit_user, insn);
} else {
- ORC_PROGRAM_ERROR(program,"No rule for: %s", opcode->name);
+ ORC_PROGRAM_ERROR(compiler,"No rule for: %s", opcode->name);
}
for(k=0;k<opcode->n_dest;k++){
switch (args[k]->vartype) {
case ORC_VAR_TYPE_DEST:
- sse_emit_store_dest (program, args[k]);
+ sse_emit_store_dest (compiler, args[k]);
break;
case ORC_VAR_TYPE_TEMP:
break;
}
}
- for(k=0;k<program->n_vars;k++){
- if (program->vars[k].vartype == ORC_VAR_TYPE_SRC ||
- program->vars[k].vartype == ORC_VAR_TYPE_DEST) {
- if (program->vars[k].ptr_register) {
- x86_emit_add_imm_reg (program, x86_ptr_size,
- program->vars[k].size << program->loop_shift,
- program->vars[k].ptr_register);
+ for(k=0;k<compiler->n_vars;k++){
+ if (compiler->vars[k].vartype == ORC_VAR_TYPE_SRC ||
+ compiler->vars[k].vartype == ORC_VAR_TYPE_DEST) {
+ if (compiler->vars[k].ptr_register) {
+ x86_emit_add_imm_reg (compiler, x86_ptr_size,
+ compiler->vars[k].size << compiler->loop_shift,
+ compiler->vars[k].ptr_register);
} else {
- x86_emit_add_imm_memoffset (program, x86_ptr_size,
- program->vars[k].size << program->loop_shift,
+ x86_emit_add_imm_memoffset (compiler, x86_ptr_size,
+ compiler->vars[k].size << compiler->loop_shift,
(int)ORC_STRUCT_OFFSET(OrcExecutor, arrays[k]),
x86_exec_ptr);
}
}
int
-orc_program_get_dest (OrcProgram *program)
+orc_compiler_get_dest (OrcCompiler *compiler)
{
int k;
- for(k=0;k<program->n_vars;k++){
- if (program->vars[k].vartype == ORC_VAR_TYPE_DEST) {
+ for(k=0;k<compiler->n_vars;k++){
+ if (compiler->vars[k].vartype == ORC_VAR_TYPE_DEST) {
return k;
}
}
- ORC_PROGRAM_ERROR(program, "failed to find destination array");
+ ORC_PROGRAM_ERROR(compiler, "failed to find destination array");
return -1;
}
program->n_insns++;
}
+const char *
+orc_program_get_asm_code (OrcProgram *program)
+{
+ return program->asm_code;
+}
+
typedef struct _OrcArgument OrcArgument;
typedef struct _OrcInstruction OrcInstruction;
typedef struct _OrcProgram OrcProgram;
+typedef struct _OrcCompiler OrcCompiler;
typedef struct _OrcRegister OrcRegister;
typedef struct _OrcRule OrcRule;
typedef struct _OrcFixup OrcFixup;
typedef void (*OrcOpcodeEmulateFunc)(OrcOpcodeExecutor *ex, void *user);
-typedef void (*OrcRuleEmitFunc)(OrcProgram *p, void *user, OrcInstruction *insn);
+typedef void (*OrcRuleEmitFunc)(OrcCompiler *p, void *user, OrcInstruction *insn);
#define ORC_N_REGS (32*4)
#define ORC_N_INSNS 100
#define ORC_ENABLE_ASM_CODE
#ifdef ORC_ENABLE_ASM_CODE
-#define ORC_ASM_CODE(fmt,...) orc_program_append_code(fmt, __VA_ARGS__)
+#define ORC_ASM_CODE(compiler,...) orc_compiler_append_code(compiler, __VA_ARGS__)
#else
-#define ORC_ASM_CODE(fmt,...)
+#define ORC_ASM_CODE(compiler,...)
#endif
#define ORC_PROGRAM_ERROR(program, ...) do { \
OrcVariable vars[ORC_N_VARIABLES];
int n_vars;
+ char *name;
+ char *asm_code;
+
+ unsigned char *code;
+ void *code_exec;
+ int code_size;
+
+#if 0
OrcInstruction *insn;
OrcRegister registers[ORC_N_REGISTERS];
int n_regs;
- char *name;
+ OrcFixup fixups[ORC_N_FIXUPS];
+ int n_fixups;
+ unsigned char *labels[ORC_N_LABELS];
+
+ int error;
+
+ int valid_regs[ORC_N_REGS];
+ int save_regs[ORC_N_REGS];
+ int used_regs[ORC_N_REGS];
+ int alloc_regs[ORC_N_REGS];
+
+ int loop_shift;
+ int long_jumps;
+#endif
+
+};
+
+struct _OrcCompiler {
+ OrcProgram *program;
+ int target;
+ OrcInstruction insns[ORC_N_INSNS];
+ int n_insns;
+
+ OrcVariable vars[ORC_N_VARIABLES];
+ int n_vars;
+
+ OrcInstruction *insn;
+
+ OrcRegister registers[ORC_N_REGISTERS];
+ int n_regs;
+
+ unsigned char *codeptr;
+#if 0
unsigned char *code;
void *code_exec;
- unsigned char *codeptr;
int code_size;
+#endif
OrcFixup fixups[ORC_N_FIXUPS];
int n_fixups;
int used_regs[ORC_N_REGS];
int alloc_regs[ORC_N_REGS];
- int target;
int loop_shift;
int long_jumps;
orc_bool orc_program_compile (OrcProgram *p);
orc_bool orc_program_compile_for_target (OrcProgram *p, int target);
-void orc_program_c_init (OrcProgram *p);
-void orc_program_mmx_init (OrcProgram *p);
-void orc_program_sse_init (OrcProgram *p);
-void orc_program_arm_init (OrcProgram *p);
-void orc_program_powerpc_init (OrcProgram *p);
-void orc_program_mmx_assemble (OrcProgram *p);
-void orc_program_sse_assemble (OrcProgram *p);
-void orc_program_arm_assemble (OrcProgram *p);
-void orc_program_assemble_powerpc (OrcProgram *p);
-void orc_program_assemble_c (OrcProgram *p);
+void orc_compiler_c_init (OrcCompiler *compiler);
+void orc_compiler_mmx_init (OrcCompiler *compiler);
+void orc_compiler_sse_init (OrcCompiler *compiler);
+void orc_compiler_arm_init (OrcCompiler *compiler);
+void orc_compiler_powerpc_init (OrcCompiler *compiler);
+void orc_compiler_mmx_assemble (OrcCompiler *compiler);
+void orc_compiler_sse_assemble (OrcCompiler *compiler);
+void orc_compiler_arm_assemble (OrcCompiler *compiler);
+void orc_compiler_assemble_powerpc (OrcCompiler *compiler);
+void orc_compiler_assemble_c (OrcCompiler *compiler);
void orc_program_free (OrcProgram *program);
int orc_program_find_var_by_name (OrcProgram *program, const char *name);
-int orc_program_get_dest (OrcProgram *program);
+int orc_compiler_get_dest (OrcCompiler *compiler);
int orc_program_add_temporary (OrcProgram *program, int size, const char *name);
int orc_program_dup_temporary (OrcProgram *program, int i, int j);
int orc_program_powerpc_allocate_register (OrcProgram *program, int is_data);
void orc_program_x86_register_rules (void);
-void orc_program_allocate_codemem (OrcProgram *program);
+void orc_compiler_allocate_codemem (OrcCompiler *compiler);
void orc_program_dump_code (OrcProgram *program);
const char *orc_program_get_asm_code (OrcProgram *program);
void orc_program_dump_asm (OrcProgram *program);
const char *orc_target_get_asm_preamble (int target);
-void orc_program_append_code (OrcProgram *p, const char *fmt, ...);
+void orc_compiler_append_code (OrcCompiler *p, const char *fmt, ...);
#endif
void
-arm_loadw (OrcProgram *program, int dest, int src1, int offset)
+arm_loadw (OrcCompiler *compiler, int dest, int src1, int offset)
{
uint32_t code;
code |= (offset&0xf0) << 4;
code |= offset&0x0f;
- ORC_ASM_CODE(program," ldrh %s, [%s, #%d]\n",
+ ORC_ASM_CODE(compiler," ldrh %s, [%s, #%d]\n",
arm_reg_name (dest),
arm_reg_name (src1), offset);
- arm_emit (program, code);
+ arm_emit (compiler, code);
}
void
-arm_storew (OrcProgram *program, int dest, int offset, int src1)
+arm_storew (OrcCompiler *compiler, int dest, int offset, int src1)
{
uint32_t code;
code |= (offset&0xf0) << 4;
code |= offset&0x0f;
- ORC_ASM_CODE(program," strh %s, [%s, #%d]\n",
+ ORC_ASM_CODE(compiler," strh %s, [%s, #%d]\n",
arm_reg_name (src1),
arm_reg_name (dest), offset);
- arm_emit (program, code);
+ arm_emit (compiler, code);
}
static void
-arm_rule_addw (OrcProgram *p, void *user, OrcInstruction *insn)
+arm_rule_addw (OrcCompiler *p, void *user, OrcInstruction *insn)
{
uint32_t code;
}
static void
-arm_rule_subw (OrcProgram *p, void *user, OrcInstruction *insn)
+arm_rule_subw (OrcCompiler *p, void *user, OrcInstruction *insn)
{
uint32_t code;
}
static void
-arm_rule_mullw (OrcProgram *p, void *user, OrcInstruction *insn)
+arm_rule_mullw (OrcCompiler *p, void *user, OrcInstruction *insn)
{
uint32_t code;
}
static void
-arm_rule_shrsw (OrcProgram *p, void *user, OrcInstruction *insn)
+arm_rule_shrsw (OrcCompiler *p, void *user, OrcInstruction *insn)
{
uint32_t code;
#if 0
void
-arm_emit_loadiw (OrcProgram *p, int reg, int value)
+arm_emit_loadiw (OrcCompiler *p, int reg, int value)
{
if (value == 0) {
- ORC_ASM_CODE(program," pxor %%%s, %%%s\n", x86_get_regname_sse(reg),
+ ORC_ASM_CODE(compiler," pxor %%%s, %%%s\n", x86_get_regname_sse(reg),
x86_get_regname_sse(reg));
*p->codeptr++ = 0x0f;
*p->codeptr++ = 0xef;
x86_emit_modrm_reg (p, reg, reg);
} else if (value == -1) {
- ORC_ASM_CODE(program," pcmpeqw %%%s, %%%s\n", x86_get_regname_sse(reg),
+ ORC_ASM_CODE(compiler," pcmpeqw %%%s, %%%s\n", x86_get_regname_sse(reg),
x86_get_regname_sse(reg));
*p->codeptr++ = 0x66;
*p->codeptr++ = 0x0f;
x86_emit_modrm_reg (p, reg, reg);
} else if (value == 1) {
- ORC_ASM_CODE(program," pcmpeqw %%%s, %%%s\n", x86_get_regname_sse(reg),
+ ORC_ASM_CODE(compiler," pcmpeqw %%%s, %%%s\n", x86_get_regname_sse(reg),
x86_get_regname_sse(reg));
*p->codeptr++ = 0x66;
*p->codeptr++ = 0x0f;
*p->codeptr++ = 0x75;
x86_emit_modrm_reg (p, reg, reg);
- ORC_ASM_CODE(program," psrlw $15, %%%s\n", x86_get_regname_sse(reg));
+ ORC_ASM_CODE(compiler," psrlw $15, %%%s\n", x86_get_regname_sse(reg));
*p->codeptr++ = 0x66;
*p->codeptr++ = 0x0f;
*p->codeptr++ = 0x71;
x86_emit_mov_imm_reg (p, 4, value, X86_ECX);
- ORC_ASM_CODE(program," movd %%ecx, %%%s\n", x86_get_regname_sse(reg));
+ ORC_ASM_CODE(compiler," movd %%ecx, %%%s\n", x86_get_regname_sse(reg));
*p->codeptr++ = 0x66;
*p->codeptr++ = 0x0f;
*p->codeptr++ = 0x6e;
x86_emit_modrm_reg (p, X86_ECX, reg);
- ORC_ASM_CODE(program," pshufd $0, %%%s, %%%s\n", x86_get_regname_sse(reg),
+ ORC_ASM_CODE(compiler," pshufd $0, %%%s, %%%s\n", x86_get_regname_sse(reg),
x86_get_regname_sse(reg));
*p->codeptr++ = 0x66;
}
void
-arm_emit_loadw (OrcProgram *p, int reg, int offset, int reg1)
+arm_emit_loadw (OrcCompiler *p, int reg, int offset, int reg1)
{
- ORC_ASM_CODE(program," movd %d(%%%s), %%%s\n", offset, x86_get_regname_ptr(reg1),
+ ORC_ASM_CODE(compiler," movd %d(%%%s), %%%s\n", offset, x86_get_regname_ptr(reg1),
x86_get_regname_sse(reg));
*p->codeptr++ = 0x66;
*p->codeptr++ = 0x0f;
*p->codeptr++ = 0x6e;
x86_emit_modrm_memoffset (p, reg, offset, reg1);
- ORC_ASM_CODE(program," pshuflw $0, %%%s, %%%s\n", x86_get_regname_sse(reg),
+ ORC_ASM_CODE(compiler," pshuflw $0, %%%s, %%%s\n", x86_get_regname_sse(reg),
x86_get_regname_sse(reg));
*p->codeptr++ = 0xf2;
*p->codeptr++ = 0x0f;
x86_emit_modrm_reg (p, reg, reg);
*p->codeptr++ = 0x00;
- ORC_ASM_CODE(program," pshufd $0, %%%s, %%%s\n", x86_get_regname_sse(reg),
+ ORC_ASM_CODE(compiler," pshufd $0, %%%s, %%%s\n", x86_get_regname_sse(reg),
x86_get_regname_sse(reg));
*p->codeptr++ = 0x66;
*p->codeptr++ = 0x0f;
}
static void
-arm_rule_copyx (OrcProgram *p, void *user, OrcInstruction *insn)
+arm_rule_copyx (OrcCompiler *p, void *user, OrcInstruction *insn)
{
- ORC_ASM_CODE(program," movdqa %%%s, %%%s\n",
+ ORC_ASM_CODE(compiler," movdqa %%%s, %%%s\n",
x86_get_regname_sse(p->vars[insn->args[1]].alloc),
x86_get_regname_sse(p->vars[insn->args[0]].alloc));
}
static void
-arm_emit_66_rex_0f (OrcProgram *p, OrcInstruction *insn, int code,
+arm_emit_66_rex_0f (OrcCompiler *p, OrcInstruction *insn, int code,
const char *insn_name)
{
- ORC_ASM_CODE(program," %s %%%s, %%%s\n", insn_name,
+ ORC_ASM_CODE(compiler," %s %%%s, %%%s\n", insn_name,
x86_get_regname_sse(p->vars[insn->args[2]].alloc),
x86_get_regname_sse(p->vars[insn->args[0]].alloc));
#if 0
static void
-arm_rule_addw (OrcProgram *p, void *user, OrcInstruction *insn)
+arm_rule_addw (OrcCompiler *p, void *user, OrcInstruction *insn)
{
arm_emit_66_rex_0f (p, insn, 0xfd, "paddw");
}
static void
-arm_rule_subw (OrcProgram *p, void *user, OrcInstruction *insn)
+arm_rule_subw (OrcCompiler *p, void *user, OrcInstruction *insn)
{
arm_emit_66_rex_0f (p, insn, 0xf9, "psubw");
}
static void
-arm_rule_mullw (OrcProgram *p, void *user, OrcInstruction *insn)
+arm_rule_mullw (OrcCompiler *p, void *user, OrcInstruction *insn)
{
arm_emit_66_rex_0f (p, insn, 0xd5, "pmullw");
}
#define UNARY(opcode,insn_name,code) \
static void \
-arm_rule_ ## opcode (OrcProgram *p, void *user, OrcInstruction *insn) \
+arm_rule_ ## opcode (OrcCompiler *p, void *user, OrcInstruction *insn) \
{ \
arm_emit_66_rex_0f (p, insn, code, insn_name); \
}
#define BINARY(opcode,insn_name,code) \
static void \
-arm_rule_ ## opcode (OrcProgram *p, void *user, OrcInstruction *insn) \
+arm_rule_ ## opcode (OrcCompiler *p, void *user, OrcInstruction *insn) \
{ \
arm_emit_66_rex_0f (p, insn, code, insn_name); \
}
static void
-arm_rule_shlw (OrcProgram *p, void *user, OrcInstruction *insn)
+arm_rule_shlw (OrcCompiler *p, void *user, OrcInstruction *insn)
{
if (p->vars[insn->args[2]].vartype == ORC_VAR_TYPE_CONST) {
- ORC_ASM_CODE(program," psllw $%d, %%%s\n",
+ ORC_ASM_CODE(compiler," psllw $%d, %%%s\n",
p->vars[insn->args[2]].value,
x86_get_regname_sse(p->vars[insn->args[0]].alloc));
} else if (p->vars[insn->args[2]].vartype == ORC_VAR_TYPE_PARAM) {
/* FIXME this is a gross hack to reload the register with a
* 64-bit version of the parameter. */
- ORC_ASM_CODE(program," movd %d(%%%s), %%%s\n",
+ ORC_ASM_CODE(compiler," movd %d(%%%s), %%%s\n",
(int)ORC_STRUCT_OFFSET(OrcExecutor, params[insn->args[2]]),
x86_get_regname_ptr(x86_exec_ptr),
x86_get_regname_sse(p->vars[insn->args[2]].alloc));
(int)ORC_STRUCT_OFFSET(OrcExecutor, params[insn->args[2]]),
x86_exec_ptr);
- ORC_ASM_CODE(program," psllw %%%s, %%%s\n",
+ ORC_ASM_CODE(compiler," psllw %%%s, %%%s\n",
x86_get_regname_sse(p->vars[insn->args[2]].alloc),
x86_get_regname_sse(p->vars[insn->args[0]].alloc));
x86_emit_modrm_reg (p, p->vars[insn->args[0]].alloc,
p->vars[insn->args[2]].alloc);
} else {
- ORC_ASM_CODE(program,"ERROR\n");
+ ORC_ASM_CODE(compiler,"ERROR\n");
}
}
static void
-arm_rule_shrsw (OrcProgram *p, void *user, OrcInstruction *insn)
+arm_rule_shrsw (OrcCompiler *p, void *user, OrcInstruction *insn)
{
if (p->vars[insn->args[2]].vartype == ORC_VAR_TYPE_CONST) {
- ORC_ASM_CODE(program," psraw $%d, %%%s\n",
+ ORC_ASM_CODE(compiler," psraw $%d, %%%s\n",
p->vars[insn->args[2]].value,
x86_get_regname_sse(p->vars[insn->args[0]].alloc));
} else if (p->vars[insn->args[2]].vartype == ORC_VAR_TYPE_PARAM) {
/* FIXME this is a gross hack to reload the register with a
* 64-bit version of the parameter. */
- ORC_ASM_CODE(program," movd %d(%%%s), %%%s\n",
+ ORC_ASM_CODE(compiler," movd %d(%%%s), %%%s\n",
(int)ORC_STRUCT_OFFSET(OrcExecutor, params[insn->args[2]]),
x86_get_regname_ptr(x86_exec_ptr),
x86_get_regname_sse(p->vars[insn->args[2]].alloc));
(int)ORC_STRUCT_OFFSET(OrcExecutor, params[insn->args[2]]),
x86_exec_ptr);
- ORC_ASM_CODE(program," psraw %%%s, %%%s\n",
+ ORC_ASM_CODE(compiler," psraw %%%s, %%%s\n",
x86_get_regname_sse(p->vars[insn->args[2]].alloc),
x86_get_regname_sse(p->vars[insn->args[0]].alloc));
x86_emit_modrm_reg (p, p->vars[insn->args[2]].alloc,
p->vars[insn->args[0]].alloc);
} else {
- ORC_ASM_CODE(program,"ERROR\n");
+ ORC_ASM_CODE(compiler,"ERROR\n");
}
}
static void
-arm_rule_convsbw (OrcProgram *p, void *user, OrcInstruction *insn)
+arm_rule_convsbw (OrcCompiler *p, void *user, OrcInstruction *insn)
{
- ORC_ASM_CODE(program," punpcklbw %%%s, %%%s\n",
+ ORC_ASM_CODE(compiler," punpcklbw %%%s, %%%s\n",
x86_get_regname_sse(p->vars[insn->args[1]].alloc),
x86_get_regname_sse(p->vars[insn->args[0]].alloc));
x86_emit_modrm_reg (p, p->vars[insn->args[0]].alloc,
p->vars[insn->args[1]].alloc);
- ORC_ASM_CODE(program," psraw $8, %%%s\n",
+ ORC_ASM_CODE(compiler," psraw $8, %%%s\n",
x86_get_regname_sse(p->vars[insn->args[0]].alloc));
*p->codeptr++ = 0x66;
}
static void
-arm_rule_convubw (OrcProgram *p, void *user, OrcInstruction *insn)
+arm_rule_convubw (OrcCompiler *p, void *user, OrcInstruction *insn)
{
/* FIXME should do this by unpacking with a zero reg */
- ORC_ASM_CODE(program," punpcklbw %%%s, %%%s\n",
+ ORC_ASM_CODE(compiler," punpcklbw %%%s, %%%s\n",
x86_get_regname_sse(p->vars[insn->args[1]].alloc),
x86_get_regname_sse(p->vars[insn->args[0]].alloc));
x86_emit_modrm_reg (p, p->vars[insn->args[0]].alloc,
p->vars[insn->args[1]].alloc);
- ORC_ASM_CODE(program," psrlw $8, %%%s\n",
+ ORC_ASM_CODE(compiler," psrlw $8, %%%s\n",
x86_get_regname_sse(p->vars[insn->args[0]].alloc));
*p->codeptr++ = 0x66;
}
static void
-arm_rule_convsuswb (OrcProgram *p, void *user, OrcInstruction *insn)
+arm_rule_convsuswb (OrcCompiler *p, void *user, OrcInstruction *insn)
{
- ORC_ASM_CODE(program," packuswb %%%s, %%%s\n",
+ ORC_ASM_CODE(compiler," packuswb %%%s, %%%s\n",
x86_get_regname_sse(p->vars[insn->args[1]].alloc),
x86_get_regname_sse(p->vars[insn->args[0]].alloc));
#endif
void
-orc_program_arm_register_rules (void)
+orc_compiler_arm_register_rules (void)
{
#if 0
#define REG(x) \
/* mmx rules */
void
-mmx_emit_loadiw (OrcProgram *p, int reg, int value)
+mmx_emit_loadiw (OrcCompiler *p, int reg, int value)
{
if (value == 0) {
ORC_ASM_CODE(p," pxor %%%s, %%%s\n", x86_get_regname_mmx(reg),
}
static void
-mmx_rule_addw (OrcProgram *p, void *user, OrcInstruction *insn)
+mmx_rule_addw (OrcCompiler *p, void *user, OrcInstruction *insn)
{
ORC_ASM_CODE(p," paddw %%%s, %%%s\n",
x86_get_regname_mmx(p->vars[insn->args[2]].alloc),
}
static void
-mmx_rule_subw (OrcProgram *p, void *user, OrcInstruction *insn)
+mmx_rule_subw (OrcCompiler *p, void *user, OrcInstruction *insn)
{
ORC_ASM_CODE(p," psubw %%%s, %%%s\n",
x86_get_regname_mmx(p->vars[insn->args[2]].alloc),
}
static void
-mmx_rule_mullw (OrcProgram *p, void *user, OrcInstruction *insn)
+mmx_rule_mullw (OrcCompiler *p, void *user, OrcInstruction *insn)
{
ORC_ASM_CODE(p," pmullw %%%s, %%%s\n",
x86_get_regname_mmx(p->vars[insn->args[2]].alloc),
}
static void
-mmx_rule_shlw (OrcProgram *p, void *user, OrcInstruction *insn)
+mmx_rule_shlw (OrcCompiler *p, void *user, OrcInstruction *insn)
{
if (p->vars[insn->args[2]].vartype == ORC_VAR_TYPE_CONST) {
ORC_ASM_CODE(p," psllw $%d, %%%s\n",
}
static void
-mmx_rule_shrsw (OrcProgram *p, void *user, OrcInstruction *insn)
+mmx_rule_shrsw (OrcCompiler *p, void *user, OrcInstruction *insn)
{
if (p->vars[insn->args[2]].vartype == ORC_VAR_TYPE_CONST) {
ORC_ASM_CODE(p," psraw $%d, %%%s\n",
}
void
-orc_program_mmx_register_rules (void)
+orc_compiler_mmx_register_rules (void)
{
orc_rule_register ("addw", ORC_TARGET_MMX, mmx_rule_addw, NULL);
orc_rule_register ("subw", ORC_TARGET_MMX, mmx_rule_subw, NULL);
#include <sys/types.h>
#include <orc/orcprogram.h>
+#include <orc/orcdebug.h>
#include <orc/x86.h>
#define SIZE 65536
/* sse rules */
void
-sse_emit_loadiw (OrcProgram *p, int reg, int value)
+sse_emit_loadiw (OrcCompiler *p, int reg, int value)
{
if (value == 0) {
ORC_ASM_CODE(p," pxor %%%s, %%%s\n", x86_get_regname_sse(reg),
}
void
-sse_emit_loadw (OrcProgram *p, int reg, int offset, int reg1)
+sse_emit_loadw (OrcCompiler *p, int reg, int offset, int reg1)
{
ORC_ASM_CODE(p," movd %d(%%%s), %%%s\n", offset, x86_get_regname_ptr(reg1),
x86_get_regname_sse(reg));
}
static void
-sse_rule_copyx (OrcProgram *p, void *user, OrcInstruction *insn)
+sse_rule_copyx (OrcCompiler *p, void *user, OrcInstruction *insn)
{
ORC_ASM_CODE(p," movdqa %%%s, %%%s\n",
x86_get_regname_sse(p->vars[insn->args[1]].alloc),
}
static void
-sse_emit_66_rex_0f (OrcProgram *p, OrcInstruction *insn, int code,
+sse_emit_66_rex_0f (OrcCompiler *p, OrcInstruction *insn, int code,
const char *insn_name)
{
ORC_ASM_CODE(p," %s %%%s, %%%s\n", insn_name,
#if 0
static void
-sse_rule_addw (OrcProgram *p, void *user, OrcInstruction *insn)
+sse_rule_addw (OrcCompiler *p, void *user, OrcInstruction *insn)
{
sse_emit_66_rex_0f (p, insn, 0xfd, "paddw");
}
static void
-sse_rule_subw (OrcProgram *p, void *user, OrcInstruction *insn)
+sse_rule_subw (OrcCompiler *p, void *user, OrcInstruction *insn)
{
sse_emit_66_rex_0f (p, insn, 0xf9, "psubw");
}
static void
-sse_rule_mullw (OrcProgram *p, void *user, OrcInstruction *insn)
+sse_rule_mullw (OrcCompiler *p, void *user, OrcInstruction *insn)
{
sse_emit_66_rex_0f (p, insn, 0xd5, "pmullw");
}
#define UNARY(opcode,insn_name,code) \
static void \
-sse_rule_ ## opcode (OrcProgram *p, void *user, OrcInstruction *insn) \
+sse_rule_ ## opcode (OrcCompiler *p, void *user, OrcInstruction *insn) \
{ \
sse_emit_66_rex_0f (p, insn, code, insn_name); \
}
#define BINARY(opcode,insn_name,code) \
static void \
-sse_rule_ ## opcode (OrcProgram *p, void *user, OrcInstruction *insn) \
+sse_rule_ ## opcode (OrcCompiler *p, void *user, OrcInstruction *insn) \
{ \
sse_emit_66_rex_0f (p, insn, code, insn_name); \
}
BINARY(minsl,"pminsd",0x3839)
BINARY(minul,"pminud",0x383b)
BINARY(mulll,"pmulld",0x3840)
-BINARY(mulhsl,"pmulhd",0xe5)
-BINARY(mulhul,"pmulhud",0xe4)
+//BINARY(mulhsl,"pmulhd",0xe5)
+//BINARY(mulhul,"pmulhud",0xe4)
BINARY(orl,"por",0xeb)
UNARY(signl,"psignd",0x380a)
BINARY(subl,"psubd",0xfa)
static void
-sse_rule_shlw (OrcProgram *p, void *user, OrcInstruction *insn)
+sse_rule_shlw (OrcCompiler *p, void *user, OrcInstruction *insn)
{
if (p->vars[insn->args[2]].vartype == ORC_VAR_TYPE_CONST) {
ORC_ASM_CODE(p," psllw $%d, %%%s\n",
x86_emit_modrm_reg (p, p->vars[insn->args[0]].alloc,
p->vars[insn->args[2]].alloc);
} else {
- ORC_ASM_CODE(p,"ERROR\n");
+ ORC_PROGRAM_ERROR(p,"rule only works with constants or params");
}
}
static void
-sse_rule_shrsw (OrcProgram *p, void *user, OrcInstruction *insn)
+sse_rule_shrsw (OrcCompiler *p, void *user, OrcInstruction *insn)
{
if (p->vars[insn->args[2]].vartype == ORC_VAR_TYPE_CONST) {
ORC_ASM_CODE(p," psraw $%d, %%%s\n",
x86_emit_modrm_reg (p, p->vars[insn->args[2]].alloc,
p->vars[insn->args[0]].alloc);
} else {
- ORC_ASM_CODE(p,"ERROR\n");
+ ORC_PROGRAM_ERROR(p,"rule only works with constants or params");
}
}
static void
-sse_rule_convsbw (OrcProgram *p, void *user, OrcInstruction *insn)
+sse_rule_convsbw (OrcCompiler *p, void *user, OrcInstruction *insn)
{
ORC_ASM_CODE(p," punpcklbw %%%s, %%%s\n",
x86_get_regname_sse(p->vars[insn->args[1]].alloc),
}
static void
-sse_rule_convubw (OrcProgram *p, void *user, OrcInstruction *insn)
+sse_rule_convubw (OrcCompiler *p, void *user, OrcInstruction *insn)
{
/* FIXME should do this by unpacking with a zero reg */
}
static void
-sse_rule_convsuswb (OrcProgram *p, void *user, OrcInstruction *insn)
+sse_rule_convsuswb (OrcCompiler *p, void *user, OrcInstruction *insn)
{
ORC_ASM_CODE(p," packuswb %%%s, %%%s\n",
x86_get_regname_sse(p->vars[insn->args[1]].alloc),
}
void
-orc_program_sse_register_rules (void)
+orc_compiler_sse_register_rules (void)
{
#define REG(x) \
orc_rule_register ( #x , ORC_TARGET_SSE, sse_rule_ ## x, NULL)
if (sse41) REG(minsl);
if (sse41) REG(minul);
if (sse41) REG(mulll);
- REG(mulhsl);
- REG(mulhul);
+ //REG(mulhsl);
+ //REG(mulhul);
REG(orl);
REG(signl);
REG(subl);
}
void
-x86_emit_push (OrcProgram *program, int size, int reg)
+x86_emit_push (OrcCompiler *compiler, int size, int reg)
{
if (size == 1) {
- program->error = 1;
+ compiler->error = 1;
} else if (size == 2) {
- ORC_ASM_CODE(program," pushw %%%s\n", x86_get_regname_16(reg));
- *program->codeptr++ = 0x66;
- *program->codeptr++ = 0x50 + x86_get_regnum(reg);
+ ORC_ASM_CODE(compiler," pushw %%%s\n", x86_get_regname_16(reg));
+ *compiler->codeptr++ = 0x66;
+ *compiler->codeptr++ = 0x50 + x86_get_regnum(reg);
} else {
- ORC_ASM_CODE(program," pushl %%%s\n", x86_get_regname(reg));
- *program->codeptr++ = 0x50 + x86_get_regnum(reg);
+ ORC_ASM_CODE(compiler," pushl %%%s\n", x86_get_regname(reg));
+ *compiler->codeptr++ = 0x50 + x86_get_regnum(reg);
}
}
void
-x86_emit_pop (OrcProgram *program, int size, int reg)
+x86_emit_pop (OrcCompiler *compiler, int size, int reg)
{
if (size == 1) {
- program->error = 1;
+ compiler->error = 1;
} else if (size == 2) {
- ORC_ASM_CODE(program," popw %%%s\n", x86_get_regname_16(reg));
- *program->codeptr++ = 0x66;
- *program->codeptr++ = 0x58 + x86_get_regnum(reg);
+ ORC_ASM_CODE(compiler," popw %%%s\n", x86_get_regname_16(reg));
+ *compiler->codeptr++ = 0x66;
+ *compiler->codeptr++ = 0x58 + x86_get_regnum(reg);
} else {
- ORC_ASM_CODE(program," popl %%%s\n", x86_get_regname(reg));
- *program->codeptr++ = 0x58 + x86_get_regnum(reg);
+ ORC_ASM_CODE(compiler," popl %%%s\n", x86_get_regname(reg));
+ *compiler->codeptr++ = 0x58 + x86_get_regnum(reg);
}
}
#define X86_SIB(ss, ind, reg) ((((ss)&3)<<6)|(((ind)&7)<<3)|((reg)&7))
void
-x86_emit_modrm_memoffset (OrcProgram *program, int reg1, int offset, int reg2)
+x86_emit_modrm_memoffset (OrcCompiler *compiler, int reg1, int offset, int reg2)
{
if (offset == 0 && reg2 != x86_exec_ptr) {
if (reg2 == X86_ESP) {
- *program->codeptr++ = X86_MODRM(0, 4, reg1);
- *program->codeptr++ = X86_SIB(0, 4, reg2);
+ *compiler->codeptr++ = X86_MODRM(0, 4, reg1);
+ *compiler->codeptr++ = X86_SIB(0, 4, reg2);
} else {
- *program->codeptr++ = X86_MODRM(0, reg2, reg1);
+ *compiler->codeptr++ = X86_MODRM(0, reg2, reg1);
}
} else if (offset >= -128 && offset < 128) {
- *program->codeptr++ = X86_MODRM(1, reg2, reg1);
+ *compiler->codeptr++ = X86_MODRM(1, reg2, reg1);
if (reg2 == X86_ESP) {
- *program->codeptr++ = X86_SIB(0, 4, reg2);
+ *compiler->codeptr++ = X86_SIB(0, 4, reg2);
}
- *program->codeptr++ = (offset & 0xff);
+ *compiler->codeptr++ = (offset & 0xff);
} else {
- *program->codeptr++ = X86_MODRM(2, reg2, reg1);
+ *compiler->codeptr++ = X86_MODRM(2, reg2, reg1);
if (reg2 == X86_ESP) {
- *program->codeptr++ = X86_SIB(0, 4, reg2);
+ *compiler->codeptr++ = X86_SIB(0, 4, reg2);
}
- *program->codeptr++ = (offset & 0xff);
- *program->codeptr++ = ((offset>>8) & 0xff);
- *program->codeptr++ = ((offset>>16) & 0xff);
- *program->codeptr++ = ((offset>>24) & 0xff);
+ *compiler->codeptr++ = (offset & 0xff);
+ *compiler->codeptr++ = ((offset>>8) & 0xff);
+ *compiler->codeptr++ = ((offset>>16) & 0xff);
+ *compiler->codeptr++ = ((offset>>24) & 0xff);
}
}
void
-x86_emit_modrm_reg (OrcProgram *program, int reg1, int reg2)
+x86_emit_modrm_reg (OrcCompiler *compiler, int reg1, int reg2)
{
- *program->codeptr++ = X86_MODRM(3, reg1, reg2);
+ *compiler->codeptr++ = X86_MODRM(3, reg1, reg2);
}
void
-x86_emit_rex (OrcProgram *program, int size, int reg1, int reg2, int reg3)
+x86_emit_rex (OrcCompiler *compiler, int size, int reg1, int reg2, int reg3)
{
int rex = 0x40;
if (reg2 == 1 || (x86_get_regnum(reg2)>=8)) rex |= 0x2;
if (reg3 == 1 || (x86_get_regnum(reg3)>=8)) rex |= 0x1;
- if (rex != 0x40) *program->codeptr++ = rex;
+ if (rex != 0x40) *compiler->codeptr++ = rex;
}
}
void
-x86_emit_mov_memoffset_reg (OrcProgram *program, int size, int offset,
+x86_emit_mov_memoffset_reg (OrcCompiler *compiler, int size, int offset,
int reg1, int reg2)
{
switch (size) {
case 1:
- ORC_ASM_CODE(program," movb %d(%%%s), %%%s\n", offset, x86_get_regname_ptr(reg1),
+ ORC_ASM_CODE(compiler," movb %d(%%%s), %%%s\n", offset, x86_get_regname_ptr(reg1),
x86_get_regname_8(reg2));
- *program->codeptr++ = 0x8a;
- x86_emit_modrm_memoffset (program, reg2, offset, reg1);
+ *compiler->codeptr++ = 0x8a;
+ x86_emit_modrm_memoffset (compiler, reg2, offset, reg1);
return;
case 2:
- ORC_ASM_CODE(program," movw %d(%%%s), %%%s\n", offset, x86_get_regname_ptr(reg1),
+ ORC_ASM_CODE(compiler," movw %d(%%%s), %%%s\n", offset, x86_get_regname_ptr(reg1),
x86_get_regname_16(reg2));
- *program->codeptr++ = 0x66;
+ *compiler->codeptr++ = 0x66;
break;
case 4:
- ORC_ASM_CODE(program," movl %d(%%%s), %%%s\n", offset, x86_get_regname_ptr(reg1),
+ ORC_ASM_CODE(compiler," movl %d(%%%s), %%%s\n", offset, x86_get_regname_ptr(reg1),
x86_get_regname(reg2));
break;
case 8:
- ORC_ASM_CODE(program," mov %d(%%%s), %%%s\n", offset, x86_get_regname_ptr(reg1),
+ ORC_ASM_CODE(compiler," mov %d(%%%s), %%%s\n", offset, x86_get_regname_ptr(reg1),
x86_get_regname_64(reg2));
break;
default:
- ORC_PROGRAM_ERROR(program, "bad size");
+ ORC_PROGRAM_ERROR(compiler, "bad size");
break;
}
- x86_emit_rex(program, size, reg2, 0, reg1);
- *program->codeptr++ = 0x8b;
- x86_emit_modrm_memoffset (program, reg2, offset, reg1);
+ x86_emit_rex(compiler, size, reg2, 0, reg1);
+ *compiler->codeptr++ = 0x8b;
+ x86_emit_modrm_memoffset (compiler, reg2, offset, reg1);
}
void
-x86_emit_mov_memoffset_mmx (OrcProgram *program, int size, int offset,
+x86_emit_mov_memoffset_mmx (OrcCompiler *compiler, int size, int offset,
int reg1, int reg2)
{
if (size == 4) {
- ORC_ASM_CODE(program," movd %d(%%%s), %%%s\n", offset, x86_get_regname_ptr(reg1),
+ ORC_ASM_CODE(compiler," movd %d(%%%s), %%%s\n", offset, x86_get_regname_ptr(reg1),
x86_get_regname_mmx(reg2));
- x86_emit_rex(program, 0, reg2, 0, reg1);
- *program->codeptr++ = 0x0f;
- *program->codeptr++ = 0x6e;
+ x86_emit_rex(compiler, 0, reg2, 0, reg1);
+ *compiler->codeptr++ = 0x0f;
+ *compiler->codeptr++ = 0x6e;
} else {
- ORC_ASM_CODE(program," movq %d(%%%s), %%%s\n", offset, x86_get_regname_ptr(reg1),
+ ORC_ASM_CODE(compiler," movq %d(%%%s), %%%s\n", offset, x86_get_regname_ptr(reg1),
x86_get_regname_mmx(reg2));
- x86_emit_rex(program, 0, reg2, 0, reg1);
- *program->codeptr++ = 0x0f;
- *program->codeptr++ = 0x6f;
+ x86_emit_rex(compiler, 0, reg2, 0, reg1);
+ *compiler->codeptr++ = 0x0f;
+ *compiler->codeptr++ = 0x6f;
}
- x86_emit_modrm_memoffset (program, reg2, offset, reg1);
+ x86_emit_modrm_memoffset (compiler, reg2, offset, reg1);
}
void
-x86_emit_mov_memoffset_sse (OrcProgram *program, int size, int offset,
+x86_emit_mov_memoffset_sse (OrcCompiler *compiler, int size, int offset,
int reg1, int reg2)
{
switch (size) {
case 4:
- ORC_ASM_CODE(program," movd %d(%%%s), %%%s\n", offset, x86_get_regname_ptr(reg1),
+ ORC_ASM_CODE(compiler," movd %d(%%%s), %%%s\n", offset, x86_get_regname_ptr(reg1),
x86_get_regname_sse(reg2));
- *program->codeptr++ = 0x66;
- x86_emit_rex(program, 0, reg2, 0, reg1);
- *program->codeptr++ = 0x0f;
- *program->codeptr++ = 0x6e;
+ *compiler->codeptr++ = 0x66;
+ x86_emit_rex(compiler, 0, reg2, 0, reg1);
+ *compiler->codeptr++ = 0x0f;
+ *compiler->codeptr++ = 0x6e;
break;
case 8:
- ORC_ASM_CODE(program," movq %d(%%%s), %%%s\n", offset, x86_get_regname_ptr(reg1),
+ ORC_ASM_CODE(compiler," movq %d(%%%s), %%%s\n", offset, x86_get_regname_ptr(reg1),
x86_get_regname_sse(reg2));
- *program->codeptr++ = 0xf3;
- *program->codeptr++ = 0x0f;
- *program->codeptr++ = 0x7e;
+ *compiler->codeptr++ = 0xf3;
+ *compiler->codeptr++ = 0x0f;
+ *compiler->codeptr++ = 0x7e;
break;
case 16:
- ORC_ASM_CODE(program," movdqu %d(%%%s), %%%s\n", offset, x86_get_regname_ptr(reg1),
+ ORC_ASM_CODE(compiler," movdqu %d(%%%s), %%%s\n", offset, x86_get_regname_ptr(reg1),
x86_get_regname_sse(reg2));
- *program->codeptr++ = 0xf3;
- x86_emit_rex(program, 0, reg2, 0, reg1);
- *program->codeptr++ = 0x0f;
- *program->codeptr++ = 0x6f;
+ *compiler->codeptr++ = 0xf3;
+ x86_emit_rex(compiler, 0, reg2, 0, reg1);
+ *compiler->codeptr++ = 0x0f;
+ *compiler->codeptr++ = 0x6f;
break;
default:
- ORC_PROGRAM_ERROR(program, "bad size");
+ ORC_PROGRAM_ERROR(compiler, "bad size");
break;
}
- x86_emit_modrm_memoffset (program, reg2, offset, reg1);
+ x86_emit_modrm_memoffset (compiler, reg2, offset, reg1);
}
void
-x86_emit_mov_reg_memoffset (OrcProgram *program, int size, int reg1, int offset,
+x86_emit_mov_reg_memoffset (OrcCompiler *compiler, int size, int reg1, int offset,
int reg2)
{
switch (size) {
case 1:
- ORC_ASM_CODE(program," movb %%%s, %d(%%%s)\n", x86_get_regname_8(reg1), offset,
+ ORC_ASM_CODE(compiler," movb %%%s, %d(%%%s)\n", x86_get_regname_8(reg1), offset,
x86_get_regname_ptr(reg2));
- *program->codeptr++ = 0x88;
- x86_emit_modrm_memoffset (program, reg1, offset, reg2);
+ *compiler->codeptr++ = 0x88;
+ x86_emit_modrm_memoffset (compiler, reg1, offset, reg2);
return;
case 2:
- ORC_ASM_CODE(program," movw %%%s, %d(%%%s)\n", x86_get_regname_16(reg1), offset,
+ ORC_ASM_CODE(compiler," movw %%%s, %d(%%%s)\n", x86_get_regname_16(reg1), offset,
x86_get_regname_ptr(reg2));
- *program->codeptr++ = 0x66;
+ *compiler->codeptr++ = 0x66;
break;
case 4:
- ORC_ASM_CODE(program," movl %%%s, %d(%%%s)\n", x86_get_regname(reg1), offset,
+ ORC_ASM_CODE(compiler," movl %%%s, %d(%%%s)\n", x86_get_regname(reg1), offset,
x86_get_regname_ptr(reg2));
break;
case 8:
- ORC_ASM_CODE(program," mov %%%s, %d(%%%s)\n", x86_get_regname(reg1), offset,
+ ORC_ASM_CODE(compiler," mov %%%s, %d(%%%s)\n", x86_get_regname(reg1), offset,
x86_get_regname_ptr(reg2));
break;
default:
- ORC_PROGRAM_ERROR(program, "bad size");
+ ORC_PROGRAM_ERROR(compiler, "bad size");
break;
}
- x86_emit_rex(program, size, reg1, 0, reg2);
- *program->codeptr++ = 0x89;
- x86_emit_modrm_memoffset (program, reg1, offset, reg2);
+ x86_emit_rex(compiler, size, reg1, 0, reg2);
+ *compiler->codeptr++ = 0x89;
+ x86_emit_modrm_memoffset (compiler, reg1, offset, reg2);
}
void
-x86_emit_mov_mmx_memoffset (OrcProgram *program, int size, int reg1, int offset,
+x86_emit_mov_mmx_memoffset (OrcCompiler *compiler, int size, int reg1, int offset,
int reg2)
{
- x86_emit_rex(program, 0, reg1, 0, reg2);
+ x86_emit_rex(compiler, 0, reg1, 0, reg2);
if (size == 4) {
- ORC_ASM_CODE(program," movd %%%s, %d(%%%s)\n", x86_get_regname_mmx(reg1), offset,
+ ORC_ASM_CODE(compiler," movd %%%s, %d(%%%s)\n", x86_get_regname_mmx(reg1), offset,
x86_get_regname_ptr(reg2));
- *program->codeptr++ = 0x0f;
- *program->codeptr++ = 0x7e;
+ *compiler->codeptr++ = 0x0f;
+ *compiler->codeptr++ = 0x7e;
} else if (size == 8) {
- ORC_ASM_CODE(program," movq %%%s, %d(%%%s)\n", x86_get_regname_mmx(reg1), offset,
+ ORC_ASM_CODE(compiler," movq %%%s, %d(%%%s)\n", x86_get_regname_mmx(reg1), offset,
x86_get_regname_ptr(reg2));
- *program->codeptr++ = 0x0f;
- *program->codeptr++ = 0x7f;
+ *compiler->codeptr++ = 0x0f;
+ *compiler->codeptr++ = 0x7f;
}
- x86_emit_modrm_memoffset (program, reg1, offset, reg2);
+ x86_emit_modrm_memoffset (compiler, reg1, offset, reg2);
}
void
-x86_emit_mov_sse_memoffset (OrcProgram *program, int size, int reg1, int offset,
+x86_emit_mov_sse_memoffset (OrcCompiler *compiler, int size, int reg1, int offset,
int reg2, int aligned, int uncached)
{
switch (size) {
case 4:
- ORC_ASM_CODE(program," movd %%%s, %d(%%%s)\n", x86_get_regname_sse(reg1), offset,
+ ORC_ASM_CODE(compiler," movd %%%s, %d(%%%s)\n", x86_get_regname_sse(reg1), offset,
x86_get_regname_ptr(reg2));
- *program->codeptr++ = 0x66;
- x86_emit_rex(program, 0, reg1, 0, reg2);
- *program->codeptr++ = 0x0f;
- *program->codeptr++ = 0x7e;
+ *compiler->codeptr++ = 0x66;
+ x86_emit_rex(compiler, 0, reg1, 0, reg2);
+ *compiler->codeptr++ = 0x0f;
+ *compiler->codeptr++ = 0x7e;
break;
case 8:
- ORC_ASM_CODE(program," movq %%%s, %d(%%%s)\n", x86_get_regname_sse(reg1), offset,
+ ORC_ASM_CODE(compiler," movq %%%s, %d(%%%s)\n", x86_get_regname_sse(reg1), offset,
x86_get_regname_ptr(reg2));
- *program->codeptr++ = 0x66;
- x86_emit_rex(program, 0, reg1, 0, reg2);
- *program->codeptr++ = 0x0f;
- *program->codeptr++ = 0xd6;
+ *compiler->codeptr++ = 0x66;
+ x86_emit_rex(compiler, 0, reg1, 0, reg2);
+ *compiler->codeptr++ = 0x0f;
+ *compiler->codeptr++ = 0xd6;
break;
case 16:
if (aligned) {
if (uncached) {
- ORC_ASM_CODE(program," movntdq %%%s, %d(%%%s)\n", x86_get_regname_sse(reg1), offset,
+ ORC_ASM_CODE(compiler," movntdq %%%s, %d(%%%s)\n", x86_get_regname_sse(reg1), offset,
x86_get_regname_ptr(reg2));
- *program->codeptr++ = 0x66;
- *program->codeptr++ = 0x0f;
- *program->codeptr++ = 0xe7;
+ *compiler->codeptr++ = 0x66;
+ *compiler->codeptr++ = 0x0f;
+ *compiler->codeptr++ = 0xe7;
} else {
- ORC_ASM_CODE(program," movdqa %%%s, %d(%%%s)\n", x86_get_regname_sse(reg1), offset,
+ ORC_ASM_CODE(compiler," movdqa %%%s, %d(%%%s)\n", x86_get_regname_sse(reg1), offset,
x86_get_regname_ptr(reg2));
- *program->codeptr++ = 0x66;
- *program->codeptr++ = 0x0f;
- *program->codeptr++ = 0x7f;
+ *compiler->codeptr++ = 0x66;
+ *compiler->codeptr++ = 0x0f;
+ *compiler->codeptr++ = 0x7f;
}
} else {
- ORC_ASM_CODE(program," movdqu %%%s, %d(%%%s)\n", x86_get_regname_sse(reg1), offset,
+ ORC_ASM_CODE(compiler," movdqu %%%s, %d(%%%s)\n", x86_get_regname_sse(reg1), offset,
x86_get_regname_ptr(reg2));
- *program->codeptr++ = 0xf3;
- *program->codeptr++ = 0x0f;
- *program->codeptr++ = 0x7f;
+ *compiler->codeptr++ = 0xf3;
+ *compiler->codeptr++ = 0x0f;
+ *compiler->codeptr++ = 0x7f;
}
break;
default:
- ORC_PROGRAM_ERROR(program, "bad size");
+ ORC_PROGRAM_ERROR(compiler, "bad size");
break;
}
- x86_emit_modrm_memoffset (program, reg1, offset, reg2);
+ x86_emit_modrm_memoffset (compiler, reg1, offset, reg2);
}
void
-x86_emit_mov_imm_reg (OrcProgram *program, int size, int value, int reg1)
+x86_emit_mov_imm_reg (OrcCompiler *compiler, int size, int value, int reg1)
{
if (size == 2) {
- ORC_ASM_CODE(program," movw $%d, %%%s\n", value, x86_get_regname_16(reg1));
- x86_emit_rex(program, size, reg1, 0, 0);
- *program->codeptr++ = 0x66;
- *program->codeptr++ = 0xb8 + x86_get_regnum(reg1);
- *program->codeptr++ = (value & 0xff);
- *program->codeptr++ = ((value>>8) & 0xff);
+ ORC_ASM_CODE(compiler," movw $%d, %%%s\n", value, x86_get_regname_16(reg1));
+ x86_emit_rex(compiler, size, reg1, 0, 0);
+ *compiler->codeptr++ = 0x66;
+ *compiler->codeptr++ = 0xb8 + x86_get_regnum(reg1);
+ *compiler->codeptr++ = (value & 0xff);
+ *compiler->codeptr++ = ((value>>8) & 0xff);
} else if (size == 4) {
- ORC_ASM_CODE(program," movl $%d, %%%s\n", value, x86_get_regname(reg1));
- x86_emit_rex(program, size, reg1, 0, 0);
- *program->codeptr++ = 0xb8 + x86_get_regnum(reg1);
- *program->codeptr++ = (value & 0xff);
- *program->codeptr++ = ((value>>8) & 0xff);
- *program->codeptr++ = ((value>>16) & 0xff);
- *program->codeptr++ = ((value>>24) & 0xff);
+ ORC_ASM_CODE(compiler," movl $%d, %%%s\n", value, x86_get_regname(reg1));
+ x86_emit_rex(compiler, size, reg1, 0, 0);
+ *compiler->codeptr++ = 0xb8 + x86_get_regnum(reg1);
+ *compiler->codeptr++ = (value & 0xff);
+ *compiler->codeptr++ = ((value>>8) & 0xff);
+ *compiler->codeptr++ = ((value>>16) & 0xff);
+ *compiler->codeptr++ = ((value>>24) & 0xff);
} else {
/* FIXME */
}
}
-void x86_emit_mov_reg_reg (OrcProgram *program, int size, int reg1, int reg2)
+void x86_emit_mov_reg_reg (OrcCompiler *compiler, int size, int reg1, int reg2)
{
if (size == 2) {
- ORC_ASM_CODE(program," movw %%%s, %%%s\n", x86_get_regname_16(reg1),
+ ORC_ASM_CODE(compiler," movw %%%s, %%%s\n", x86_get_regname_16(reg1),
x86_get_regname_16(reg2));
- *program->codeptr++ = 0x66;
+ *compiler->codeptr++ = 0x66;
} else if (size == 4) {
- ORC_ASM_CODE(program," movl %%%s, %%%s\n", x86_get_regname(reg1),
+ ORC_ASM_CODE(compiler," movl %%%s, %%%s\n", x86_get_regname(reg1),
x86_get_regname(reg2));
} else {
- ORC_ASM_CODE(program," mov %%%s, %%%s\n", x86_get_regname_64(reg1),
+ ORC_ASM_CODE(compiler," mov %%%s, %%%s\n", x86_get_regname_64(reg1),
x86_get_regname_64(reg2));
}
- x86_emit_rex(program, size, reg2, 0, reg1);
- *program->codeptr++ = 0x89;
- x86_emit_modrm_reg (program, reg2, reg1);
+ x86_emit_rex(compiler, size, reg2, 0, reg1);
+ *compiler->codeptr++ = 0x89;
+ x86_emit_modrm_reg (compiler, reg2, reg1);
}
-void x86_emit_mov_sse_reg_reg (OrcProgram *program, int reg1, int reg2)
+void x86_emit_mov_sse_reg_reg (OrcCompiler *compiler, int reg1, int reg2)
{
- ORC_ASM_CODE(program," movdqa %%%s, %%%s\n", x86_get_regname_sse(reg1),
+ ORC_ASM_CODE(compiler," movdqa %%%s, %%%s\n", x86_get_regname_sse(reg1),
x86_get_regname_sse(reg2));
- *program->codeptr++ = 0x66;
- x86_emit_rex(program, 0, reg1, 0, reg2);
- *program->codeptr++ = 0x0f;
- *program->codeptr++ = 0x6f;
- x86_emit_modrm_reg (program, reg1, reg2);
+ *compiler->codeptr++ = 0x66;
+ x86_emit_rex(compiler, 0, reg1, 0, reg2);
+ *compiler->codeptr++ = 0x0f;
+ *compiler->codeptr++ = 0x6f;
+ x86_emit_modrm_reg (compiler, reg1, reg2);
}
-void x86_emit_mov_mmx_reg_reg (OrcProgram *program, int reg1, int reg2)
+void x86_emit_mov_mmx_reg_reg (OrcCompiler *compiler, int reg1, int reg2)
{
- ORC_ASM_CODE(program," movq %%%s, %%%s\n", x86_get_regname_mmx(reg1),
+ ORC_ASM_CODE(compiler," movq %%%s, %%%s\n", x86_get_regname_mmx(reg1),
x86_get_regname_mmx(reg2));
- x86_emit_rex(program, 0, reg1, 0, reg2);
- *program->codeptr++ = 0x0f;
- *program->codeptr++ = 0x6f;
- x86_emit_modrm_reg (program, reg1, reg2);
+ x86_emit_rex(compiler, 0, reg1, 0, reg2);
+ *compiler->codeptr++ = 0x0f;
+ *compiler->codeptr++ = 0x6f;
+ x86_emit_modrm_reg (compiler, reg1, reg2);
}
-void x86_emit_mov_reg_mmx (OrcProgram *program, int reg1, int reg2)
+void x86_emit_mov_reg_mmx (OrcCompiler *compiler, int reg1, int reg2)
{
/* FIXME */
- ORC_ASM_CODE(program," movd %%%s, %%%s\n", x86_get_regname(reg1),
+ ORC_ASM_CODE(compiler," movd %%%s, %%%s\n", x86_get_regname(reg1),
x86_get_regname_mmx(reg2));
- x86_emit_rex(program, 0, reg1, 0, reg2);
- *program->codeptr++ = 0x0f;
- *program->codeptr++ = 0x6e;
- x86_emit_modrm_reg (program, reg1, reg2);
+ x86_emit_rex(compiler, 0, reg1, 0, reg2);
+ *compiler->codeptr++ = 0x0f;
+ *compiler->codeptr++ = 0x6e;
+ x86_emit_modrm_reg (compiler, reg1, reg2);
}
-void x86_emit_mov_mmx_reg (OrcProgram *program, int reg1, int reg2)
+void x86_emit_mov_mmx_reg (OrcCompiler *compiler, int reg1, int reg2)
{
/* FIXME */
- ORC_ASM_CODE(program," movd %%%s, %%%s\n", x86_get_regname_mmx(reg1),
+ ORC_ASM_CODE(compiler," movd %%%s, %%%s\n", x86_get_regname_mmx(reg1),
x86_get_regname(reg2));
- x86_emit_rex(program, 0, reg2, 0, reg1);
- *program->codeptr++ = 0x0f;
- *program->codeptr++ = 0x7e;
- x86_emit_modrm_reg (program, reg2, reg1);
+ x86_emit_rex(compiler, 0, reg2, 0, reg1);
+ *compiler->codeptr++ = 0x0f;
+ *compiler->codeptr++ = 0x7e;
+ x86_emit_modrm_reg (compiler, reg2, reg1);
}
-void x86_emit_mov_reg_sse (OrcProgram *program, int reg1, int reg2)
+void x86_emit_mov_reg_sse (OrcCompiler *compiler, int reg1, int reg2)
{
/* FIXME */
- ORC_ASM_CODE(program," movd %%%s, %%%s\n", x86_get_regname(reg1),
+ ORC_ASM_CODE(compiler," movd %%%s, %%%s\n", x86_get_regname(reg1),
x86_get_regname_sse(reg2));
- *program->codeptr++ = 0x66;
- x86_emit_rex(program, 0, reg1, 0, reg2);
- *program->codeptr++ = 0x0f;
- *program->codeptr++ = 0x6e;
- x86_emit_modrm_reg (program, reg1, reg2);
+ *compiler->codeptr++ = 0x66;
+ x86_emit_rex(compiler, 0, reg1, 0, reg2);
+ *compiler->codeptr++ = 0x0f;
+ *compiler->codeptr++ = 0x6e;
+ x86_emit_modrm_reg (compiler, reg1, reg2);
}
-void x86_emit_mov_sse_reg (OrcProgram *program, int reg1, int reg2)
+void x86_emit_mov_sse_reg (OrcCompiler *compiler, int reg1, int reg2)
{
/* FIXME */
- ORC_ASM_CODE(program," movd %%%s, %%%s\n", x86_get_regname_sse(reg1),
+ ORC_ASM_CODE(compiler," movd %%%s, %%%s\n", x86_get_regname_sse(reg1),
x86_get_regname(reg2));
- *program->codeptr++ = 0x66;
- x86_emit_rex(program, 0, reg2, 0, reg1);
- *program->codeptr++ = 0x0f;
- *program->codeptr++ = 0x7e;
- x86_emit_modrm_reg (program, reg2, reg1);
+ *compiler->codeptr++ = 0x66;
+ x86_emit_rex(compiler, 0, reg2, 0, reg1);
+ *compiler->codeptr++ = 0x0f;
+ *compiler->codeptr++ = 0x7e;
+ x86_emit_modrm_reg (compiler, reg2, reg1);
}
void
-x86_emit_test_reg_reg (OrcProgram *program, int size, int reg1, int reg2)
+x86_emit_test_reg_reg (OrcCompiler *compiler, int size, int reg1, int reg2)
{
if (size == 2) {
- ORC_ASM_CODE(program," testw %%%s, %%%s\n", x86_get_regname_16(reg1),
+ ORC_ASM_CODE(compiler," testw %%%s, %%%s\n", x86_get_regname_16(reg1),
x86_get_regname_16(reg2));
- *program->codeptr++ = 0x66;
+ *compiler->codeptr++ = 0x66;
} else if (size == 4) {
- ORC_ASM_CODE(program," testl %%%s, %%%s\n", x86_get_regname(reg1),
+ ORC_ASM_CODE(compiler," testl %%%s, %%%s\n", x86_get_regname(reg1),
x86_get_regname(reg2));
} else {
- ORC_ASM_CODE(program," test %%%s, %%%s\n", x86_get_regname(reg1),
+ ORC_ASM_CODE(compiler," test %%%s, %%%s\n", x86_get_regname(reg1),
x86_get_regname(reg2));
}
- x86_emit_rex(program, size, reg2, 0, reg1);
- *program->codeptr++ = 0x85;
- x86_emit_modrm_reg (program, reg2, reg1);
+ x86_emit_rex(compiler, size, reg2, 0, reg1);
+ *compiler->codeptr++ = 0x85;
+ x86_emit_modrm_reg (compiler, reg2, reg1);
}
void
-x86_emit_sar_imm_reg (OrcProgram *program, int size, int value, int reg)
+x86_emit_sar_imm_reg (OrcCompiler *compiler, int size, int value, int reg)
{
if (size == 2) {
- ORC_ASM_CODE(program," sarw $%d, %%%s\n", value, x86_get_regname_16(reg));
+ ORC_ASM_CODE(compiler," sarw $%d, %%%s\n", value, x86_get_regname_16(reg));
} else if (size == 4) {
- ORC_ASM_CODE(program," sarl $%d, %%%s\n", value, x86_get_regname(reg));
+ ORC_ASM_CODE(compiler," sarl $%d, %%%s\n", value, x86_get_regname(reg));
} else {
- ORC_ASM_CODE(program," sar $%d, %%%s\n", value, x86_get_regname_64(reg));
+ ORC_ASM_CODE(compiler," sar $%d, %%%s\n", value, x86_get_regname_64(reg));
}
- x86_emit_rex(program, size, reg, 0, 0);
+ x86_emit_rex(compiler, size, reg, 0, 0);
if (value == 1) {
- *program->codeptr++ = 0xd1;
- x86_emit_modrm_reg (program, reg, 7);
+ *compiler->codeptr++ = 0xd1;
+ x86_emit_modrm_reg (compiler, reg, 7);
} else {
- *program->codeptr++ = 0xc1;
- x86_emit_modrm_reg (program, reg, 7);
- *program->codeptr++ = value;
+ *compiler->codeptr++ = 0xc1;
+ x86_emit_modrm_reg (compiler, reg, 7);
+ *compiler->codeptr++ = value;
}
}
void
-x86_emit_and_imm_memoffset (OrcProgram *program, int size, int value,
+x86_emit_and_imm_memoffset (OrcCompiler *compiler, int size, int value,
int offset, int reg)
{
if (size == 2) {
- ORC_ASM_CODE(program," andw $%d, %d(%%%s)\n", value, offset,
+ ORC_ASM_CODE(compiler," andw $%d, %d(%%%s)\n", value, offset,
x86_get_regname_ptr(reg));
- *program->codeptr++ = 0x66;
+ *compiler->codeptr++ = 0x66;
} else if (size == 4) {
- ORC_ASM_CODE(program," andl $%d, %d(%%%s)\n", value, offset,
+ ORC_ASM_CODE(compiler," andl $%d, %d(%%%s)\n", value, offset,
x86_get_regname_ptr(reg));
} else {
- ORC_ASM_CODE(program," and $%d, %d(%%%s)\n", value, offset,
+ ORC_ASM_CODE(compiler," and $%d, %d(%%%s)\n", value, offset,
x86_get_regname_ptr(reg));
}
- x86_emit_rex(program, size, 0, 0, reg);
+ x86_emit_rex(compiler, size, 0, 0, reg);
if (value >= -128 && value < 128) {
- *program->codeptr++ = 0x83;
+ *compiler->codeptr++ = 0x83;
/* FIXME */
- x86_emit_modrm_memoffset (program, 0, offset, reg);
- *program->codeptr++ = (value & 0xff);
+ x86_emit_modrm_memoffset (compiler, 0, offset, reg);
+ *compiler->codeptr++ = (value & 0xff);
} else {
- *program->codeptr++ = 0x81;
+ *compiler->codeptr++ = 0x81;
/* FIXME */
- x86_emit_modrm_memoffset (program, 0, offset, reg);
- *program->codeptr++ = (value & 0xff);
- *program->codeptr++ = ((value>>8) & 0xff);
+ x86_emit_modrm_memoffset (compiler, 0, offset, reg);
+ *compiler->codeptr++ = (value & 0xff);
+ *compiler->codeptr++ = ((value>>8) & 0xff);
if (size == 4) {
- *program->codeptr++ = ((value>>16) & 0xff);
- *program->codeptr++ = ((value>>24) & 0xff);
+ *compiler->codeptr++ = ((value>>16) & 0xff);
+ *compiler->codeptr++ = ((value>>24) & 0xff);
}
}
}
void
-x86_emit_and_imm_reg (OrcProgram *program, int size, int value, int reg)
+x86_emit_and_imm_reg (OrcCompiler *compiler, int size, int value, int reg)
{
if (size == 2) {
- ORC_ASM_CODE(program," andw $%d, %%%s\n", value, x86_get_regname_16(reg));
- *program->codeptr++ = 0x66;
+ ORC_ASM_CODE(compiler," andw $%d, %%%s\n", value, x86_get_regname_16(reg));
+ *compiler->codeptr++ = 0x66;
} else if (size == 4) {
- ORC_ASM_CODE(program," andl $%d, %%%s\n", value, x86_get_regname(reg));
+ ORC_ASM_CODE(compiler," andl $%d, %%%s\n", value, x86_get_regname(reg));
} else {
- ORC_ASM_CODE(program," and $%d, %%%s\n", value, x86_get_regname_64(reg));
+ ORC_ASM_CODE(compiler," and $%d, %%%s\n", value, x86_get_regname_64(reg));
}
- x86_emit_rex(program, size, 0, 0, reg);
+ x86_emit_rex(compiler, size, 0, 0, reg);
if (value >= -128 && value < 128) {
- *program->codeptr++ = 0x83;
- x86_emit_modrm_reg (program, reg, 4);
- *program->codeptr++ = (value & 0xff);
+ *compiler->codeptr++ = 0x83;
+ x86_emit_modrm_reg (compiler, reg, 4);
+ *compiler->codeptr++ = (value & 0xff);
} else {
- *program->codeptr++ = 0x81;
- x86_emit_modrm_reg (program, reg, 4);
- *program->codeptr++ = (value & 0xff);
- *program->codeptr++ = ((value>>8) & 0xff);
+ *compiler->codeptr++ = 0x81;
+ x86_emit_modrm_reg (compiler, reg, 4);
+ *compiler->codeptr++ = (value & 0xff);
+ *compiler->codeptr++ = ((value>>8) & 0xff);
if (size == 4) {
- *program->codeptr++ = ((value>>16) & 0xff);
- *program->codeptr++ = ((value>>24) & 0xff);
+ *compiler->codeptr++ = ((value>>16) & 0xff);
+ *compiler->codeptr++ = ((value>>24) & 0xff);
}
}
}
void
-x86_emit_add_imm_memoffset (OrcProgram *program, int size, int value,
+x86_emit_add_imm_memoffset (OrcCompiler *compiler, int size, int value,
int offset, int reg)
{
if (size == 2) {
- ORC_ASM_CODE(program," addw $%d, %d(%%%s)\n", value, offset,
+ ORC_ASM_CODE(compiler," addw $%d, %d(%%%s)\n", value, offset,
x86_get_regname_ptr(reg));
- *program->codeptr++ = 0x66;
+ *compiler->codeptr++ = 0x66;
} else if (size == 4) {
- ORC_ASM_CODE(program," addl $%d, %d(%%%s)\n", value, offset,
+ ORC_ASM_CODE(compiler," addl $%d, %d(%%%s)\n", value, offset,
x86_get_regname_ptr(reg));
} else {
- ORC_ASM_CODE(program," add $%d, %d(%%%s)\n", value, offset,
+ ORC_ASM_CODE(compiler," add $%d, %d(%%%s)\n", value, offset,
x86_get_regname_ptr(reg));
}
- x86_emit_rex(program, size, 0, 0, reg);
+ x86_emit_rex(compiler, size, 0, 0, reg);
if (value >= -128 && value < 128) {
- *program->codeptr++ = 0x83;
- x86_emit_modrm_memoffset (program, 0, offset, reg);
- *program->codeptr++ = (value & 0xff);
+ *compiler->codeptr++ = 0x83;
+ x86_emit_modrm_memoffset (compiler, 0, offset, reg);
+ *compiler->codeptr++ = (value & 0xff);
} else {
- *program->codeptr++ = 0x81;
- x86_emit_modrm_memoffset (program, 0, offset, reg);
- *program->codeptr++ = (value & 0xff);
- *program->codeptr++ = ((value>>8) & 0xff);
+ *compiler->codeptr++ = 0x81;
+ x86_emit_modrm_memoffset (compiler, 0, offset, reg);
+ *compiler->codeptr++ = (value & 0xff);
+ *compiler->codeptr++ = ((value>>8) & 0xff);
if (size == 4) {
- *program->codeptr++ = ((value>>16) & 0xff);
- *program->codeptr++ = ((value>>24) & 0xff);
+ *compiler->codeptr++ = ((value>>16) & 0xff);
+ *compiler->codeptr++ = ((value>>24) & 0xff);
}
}
}
void
-x86_emit_add_imm_reg (OrcProgram *program, int size, int value, int reg)
+x86_emit_add_imm_reg (OrcCompiler *compiler, int size, int value, int reg)
{
if (size == 2) {
- ORC_ASM_CODE(program," addw $%d, %%%s\n", value, x86_get_regname_16(reg));
- *program->codeptr++ = 0x66;
+ ORC_ASM_CODE(compiler," addw $%d, %%%s\n", value, x86_get_regname_16(reg));
+ *compiler->codeptr++ = 0x66;
} else if (size == 4) {
- ORC_ASM_CODE(program," addl $%d, %%%s\n", value, x86_get_regname(reg));
+ ORC_ASM_CODE(compiler," addl $%d, %%%s\n", value, x86_get_regname(reg));
} else {
- ORC_ASM_CODE(program," add $%d, %%%s\n", value, x86_get_regname_64(reg));
+ ORC_ASM_CODE(compiler," add $%d, %%%s\n", value, x86_get_regname_64(reg));
}
- x86_emit_rex(program, size, 0, 0, reg);
+ x86_emit_rex(compiler, size, 0, 0, reg);
if (value >= -128 && value < 128) {
- *program->codeptr++ = 0x83;
- x86_emit_modrm_reg (program, reg, 0);
- *program->codeptr++ = (value & 0xff);
+ *compiler->codeptr++ = 0x83;
+ x86_emit_modrm_reg (compiler, reg, 0);
+ *compiler->codeptr++ = (value & 0xff);
} else {
- *program->codeptr++ = 0x81;
- x86_emit_modrm_reg (program, reg, 0);
- *program->codeptr++ = (value & 0xff);
- *program->codeptr++ = ((value>>8) & 0xff);
+ *compiler->codeptr++ = 0x81;
+ x86_emit_modrm_reg (compiler, reg, 0);
+ *compiler->codeptr++ = (value & 0xff);
+ *compiler->codeptr++ = ((value>>8) & 0xff);
if (size == 4) {
- *program->codeptr++ = ((value>>16) & 0xff);
- *program->codeptr++ = ((value>>24) & 0xff);
+ *compiler->codeptr++ = ((value>>16) & 0xff);
+ *compiler->codeptr++ = ((value>>24) & 0xff);
}
}
}
void
-x86_emit_sub_reg_reg (OrcProgram *program, int size, int reg1, int reg2)
+x86_emit_sub_reg_reg (OrcCompiler *compiler, int size, int reg1, int reg2)
{
if (size == 2) {
- ORC_ASM_CODE(program," subw %%%s, %%%s\n", x86_get_regname_16(reg1),
+ ORC_ASM_CODE(compiler," subw %%%s, %%%s\n", x86_get_regname_16(reg1),
x86_get_regname_16(reg2));
- *program->codeptr++ = 0x66;
+ *compiler->codeptr++ = 0x66;
} else if (size == 4) {
- ORC_ASM_CODE(program," subl %%%s, %%%s\n", x86_get_regname(reg1),
+ ORC_ASM_CODE(compiler," subl %%%s, %%%s\n", x86_get_regname(reg1),
x86_get_regname(reg2));
} else {
- ORC_ASM_CODE(program," sub %%%s, %%%s\n", x86_get_regname_64(reg1),
+ ORC_ASM_CODE(compiler," sub %%%s, %%%s\n", x86_get_regname_64(reg1),
x86_get_regname_64(reg2));
}
- x86_emit_rex(program, size, reg2, 0, reg1);
- *program->codeptr++ = 0x29;
- x86_emit_modrm_reg (program, reg2, reg1);
+ x86_emit_rex(compiler, size, reg2, 0, reg1);
+ *compiler->codeptr++ = 0x29;
+ x86_emit_modrm_reg (compiler, reg2, reg1);
}
void
-x86_emit_sub_memoffset_reg (OrcProgram *program, int size,
+x86_emit_sub_memoffset_reg (OrcCompiler *compiler, int size,
int offset, int reg, int destreg)
{
if (size == 2) {
- ORC_ASM_CODE(program," subw %d(%%%s), %%%s\n", offset,
+ ORC_ASM_CODE(compiler," subw %d(%%%s), %%%s\n", offset,
x86_get_regname_ptr(reg),
x86_get_regname_16(destreg));
- *program->codeptr++ = 0x66;
+ *compiler->codeptr++ = 0x66;
} else if (size == 4) {
- ORC_ASM_CODE(program," subl %d(%%%s), %%%s\n", offset,
+ ORC_ASM_CODE(compiler," subl %d(%%%s), %%%s\n", offset,
x86_get_regname_ptr(reg),
x86_get_regname(destreg));
} else {
- ORC_ASM_CODE(program," sub %d(%%%s), %%%s\n", offset,
+ ORC_ASM_CODE(compiler," sub %d(%%%s), %%%s\n", offset,
x86_get_regname_ptr(reg),
x86_get_regname_64(destreg));
}
- x86_emit_rex(program, size, 0, 0, reg);
- *program->codeptr++ = 0x2b;
- x86_emit_modrm_memoffset (program, destreg, offset, reg);
+ x86_emit_rex(compiler, size, 0, 0, reg);
+ *compiler->codeptr++ = 0x2b;
+ x86_emit_modrm_memoffset (compiler, destreg, offset, reg);
}
void
-x86_emit_cmp_reg_memoffset (OrcProgram *program, int size, int reg1,
+x86_emit_cmp_reg_memoffset (OrcCompiler *compiler, int size, int reg1,
int offset, int reg)
{
if (size == 2) {
- ORC_ASM_CODE(program," cmpw %%%s, %d(%%%s)\n", x86_get_regname_16(reg1), offset,
+ ORC_ASM_CODE(compiler," cmpw %%%s, %d(%%%s)\n", x86_get_regname_16(reg1), offset,
x86_get_regname_ptr(reg));
- *program->codeptr++ = 0x66;
+ *compiler->codeptr++ = 0x66;
} else if (size == 4) {
- ORC_ASM_CODE(program," cmpl %%%s, %d(%%%s)\n", x86_get_regname(reg1), offset,
+ ORC_ASM_CODE(compiler," cmpl %%%s, %d(%%%s)\n", x86_get_regname(reg1), offset,
x86_get_regname_ptr(reg));
} else {
- ORC_ASM_CODE(program," cmp %%%s, %d(%%%s)\n", x86_get_regname_64(reg1), offset,
+ ORC_ASM_CODE(compiler," cmp %%%s, %d(%%%s)\n", x86_get_regname_64(reg1), offset,
x86_get_regname_ptr(reg));
}
- x86_emit_rex(program, size, 0, 0, reg);
- *program->codeptr++ = 0x39;
- x86_emit_modrm_memoffset (program, reg1, offset, reg);
+ x86_emit_rex(compiler, size, 0, 0, reg);
+ *compiler->codeptr++ = 0x39;
+ x86_emit_modrm_memoffset (compiler, reg1, offset, reg);
}
void
-x86_emit_cmp_imm_memoffset (OrcProgram *program, int size, int value,
+x86_emit_cmp_imm_memoffset (OrcCompiler *compiler, int size, int value,
int offset, int reg)
{
if (size == 2) {
- ORC_ASM_CODE(program," cmpw $%d, %d(%%%s)\n", value, offset,
+ ORC_ASM_CODE(compiler," cmpw $%d, %d(%%%s)\n", value, offset,
x86_get_regname_ptr(reg));
- *program->codeptr++ = 0x66;
+ *compiler->codeptr++ = 0x66;
} else if (size == 4) {
- ORC_ASM_CODE(program," cmpl $%d, %d(%%%s)\n", value, offset,
+ ORC_ASM_CODE(compiler," cmpl $%d, %d(%%%s)\n", value, offset,
x86_get_regname_ptr(reg));
} else {
- ORC_ASM_CODE(program," cmp $%d, %d(%%%s)\n", value, offset,
+ ORC_ASM_CODE(compiler," cmp $%d, %d(%%%s)\n", value, offset,
x86_get_regname_ptr(reg));
}
- x86_emit_rex(program, size, 0, 0, reg);
+ x86_emit_rex(compiler, size, 0, 0, reg);
if (value >= -128 && value < 128) {
- *program->codeptr++ = 0x83;
- x86_emit_modrm_memoffset (program, 7, offset, reg);
- *program->codeptr++ = (value & 0xff);
+ *compiler->codeptr++ = 0x83;
+ x86_emit_modrm_memoffset (compiler, 7, offset, reg);
+ *compiler->codeptr++ = (value & 0xff);
} else {
- *program->codeptr++ = 0x81;
- x86_emit_modrm_memoffset (program, 7, offset, reg);
- *program->codeptr++ = (value & 0xff);
- *program->codeptr++ = ((value>>8) & 0xff);
+ *compiler->codeptr++ = 0x81;
+ x86_emit_modrm_memoffset (compiler, 7, offset, reg);
+ *compiler->codeptr++ = (value & 0xff);
+ *compiler->codeptr++ = ((value>>8) & 0xff);
if (size == 4) {
- *program->codeptr++ = ((value>>16) & 0xff);
- *program->codeptr++ = ((value>>24) & 0xff);
+ *compiler->codeptr++ = ((value>>16) & 0xff);
+ *compiler->codeptr++ = ((value>>24) & 0xff);
}
}
}
void
-x86_emit_dec_memoffset (OrcProgram *program, int size,
+x86_emit_dec_memoffset (OrcCompiler *compiler, int size,
int offset, int reg)
{
if (size == 2) {
- ORC_ASM_CODE(program," decw %d(%%%s)\n", offset, x86_get_regname_ptr(reg));
- *program->codeptr++ = 0x66;
+ ORC_ASM_CODE(compiler," decw %d(%%%s)\n", offset, x86_get_regname_ptr(reg));
+ *compiler->codeptr++ = 0x66;
} else if (size == 4) {
- ORC_ASM_CODE(program," decl %d(%%%s)\n", offset, x86_get_regname_ptr(reg));
+ ORC_ASM_CODE(compiler," decl %d(%%%s)\n", offset, x86_get_regname_ptr(reg));
} else {
- ORC_ASM_CODE(program," dec %d(%%%s)\n", offset, x86_get_regname_ptr(reg));
+ ORC_ASM_CODE(compiler," dec %d(%%%s)\n", offset, x86_get_regname_ptr(reg));
}
- x86_emit_rex(program, size, 0, 0, reg);
- *program->codeptr++ = 0xff;
- x86_emit_modrm_memoffset (program, 1, offset, reg);
+ x86_emit_rex(compiler, size, 0, 0, reg);
+ *compiler->codeptr++ = 0xff;
+ x86_emit_modrm_memoffset (compiler, 1, offset, reg);
}
-void x86_emit_ret (OrcProgram *program)
+void x86_emit_ret (OrcCompiler *compiler)
{
if (x86_64) {
- ORC_ASM_CODE(program," retq\n");
+ ORC_ASM_CODE(compiler," retq\n");
} else {
- ORC_ASM_CODE(program," ret\n");
+ ORC_ASM_CODE(compiler," ret\n");
}
- *program->codeptr++ = 0xc3;
+ *compiler->codeptr++ = 0xc3;
}
-void x86_emit_emms (OrcProgram *program)
+void x86_emit_emms (OrcCompiler *compiler)
{
- ORC_ASM_CODE(program," emms\n");
- *program->codeptr++ = 0x0f;
- *program->codeptr++ = 0x77;
+ ORC_ASM_CODE(compiler," emms\n");
+ *compiler->codeptr++ = 0x0f;
+ *compiler->codeptr++ = 0x77;
}
void
-x86_add_fixup (OrcProgram *program, unsigned char *ptr, int label, int type)
+x86_add_fixup (OrcCompiler *compiler, unsigned char *ptr, int label, int type)
{
- program->fixups[program->n_fixups].ptr = ptr;
- program->fixups[program->n_fixups].label = label;
- program->fixups[program->n_fixups].type = type;
- program->n_fixups++;
+ compiler->fixups[compiler->n_fixups].ptr = ptr;
+ compiler->fixups[compiler->n_fixups].label = label;
+ compiler->fixups[compiler->n_fixups].type = type;
+ compiler->n_fixups++;
}
void
-x86_add_label (OrcProgram *program, unsigned char *ptr, int label)
+x86_add_label (OrcCompiler *compiler, unsigned char *ptr, int label)
{
- program->labels[label] = ptr;
+ compiler->labels[label] = ptr;
}
-void x86_emit_jmp (OrcProgram *program, int label)
+void x86_emit_jmp (OrcCompiler *compiler, int label)
{
- ORC_ASM_CODE(program," jmp .L%d\n", label);
+ ORC_ASM_CODE(compiler," jmp .L%d\n", label);
- if (program->long_jumps) {
- ORC_PROGRAM_ERROR(program, "unimplemented");
+ if (compiler->long_jumps) {
+ ORC_PROGRAM_ERROR(compiler, "unimplemented");
} else {
- *program->codeptr++ = 0xeb;
- x86_add_fixup (program, program->codeptr, label, 0);
- *program->codeptr++ = 0xff;
+ *compiler->codeptr++ = 0xeb;
+ x86_add_fixup (compiler, compiler->codeptr, label, 0);
+ *compiler->codeptr++ = 0xff;
}
}
-void x86_emit_jle (OrcProgram *program, int label)
+void x86_emit_jle (OrcCompiler *compiler, int label)
{
- ORC_ASM_CODE(program," jle .L%d\n", label);
+ ORC_ASM_CODE(compiler," jle .L%d\n", label);
- if (program->long_jumps) {
- ORC_PROGRAM_ERROR(program, "unimplemented");
+ if (compiler->long_jumps) {
+ ORC_PROGRAM_ERROR(compiler, "unimplemented");
} else {
- *program->codeptr++ = 0x7e;
- x86_add_fixup (program, program->codeptr, label, 0);
- *program->codeptr++ = 0xff;
+ *compiler->codeptr++ = 0x7e;
+ x86_add_fixup (compiler, compiler->codeptr, label, 0);
+ *compiler->codeptr++ = 0xff;
}
}
-void x86_emit_je (OrcProgram *program, int label)
+void x86_emit_je (OrcCompiler *compiler, int label)
{
- ORC_ASM_CODE(program," je .L%d\n", label);
-
- if (program->long_jumps) {
- *program->codeptr++ = 0x0f;
- *program->codeptr++ = 0x84;
- x86_add_fixup (program, program->codeptr, label, 1);
- *program->codeptr++ = 0xfc;
- *program->codeptr++ = 0xff;
- *program->codeptr++ = 0xff;
- *program->codeptr++ = 0xff;
+ ORC_ASM_CODE(compiler," je .L%d\n", label);
+
+ if (compiler->long_jumps) {
+ *compiler->codeptr++ = 0x0f;
+ *compiler->codeptr++ = 0x84;
+ x86_add_fixup (compiler, compiler->codeptr, label, 1);
+ *compiler->codeptr++ = 0xfc;
+ *compiler->codeptr++ = 0xff;
+ *compiler->codeptr++ = 0xff;
+ *compiler->codeptr++ = 0xff;
} else {
- *program->codeptr++ = 0x74;
- x86_add_fixup (program, program->codeptr, label, 0);
- *program->codeptr++ = 0xff;
+ *compiler->codeptr++ = 0x74;
+ x86_add_fixup (compiler, compiler->codeptr, label, 0);
+ *compiler->codeptr++ = 0xff;
}
}
-void x86_emit_jne (OrcProgram *program, int label)
+void x86_emit_jne (OrcCompiler *compiler, int label)
{
- ORC_ASM_CODE(program," jne .L%d\n", label);
-
- if (program->long_jumps) {
- *program->codeptr++ = 0x0f;
- *program->codeptr++ = 0x85;
- x86_add_fixup (program, program->codeptr, label, 1);
- *program->codeptr++ = 0xfc;
- *program->codeptr++ = 0xff;
- *program->codeptr++ = 0xff;
- *program->codeptr++ = 0xff;
+ ORC_ASM_CODE(compiler," jne .L%d\n", label);
+
+ if (compiler->long_jumps) {
+ *compiler->codeptr++ = 0x0f;
+ *compiler->codeptr++ = 0x85;
+ x86_add_fixup (compiler, compiler->codeptr, label, 1);
+ *compiler->codeptr++ = 0xfc;
+ *compiler->codeptr++ = 0xff;
+ *compiler->codeptr++ = 0xff;
+ *compiler->codeptr++ = 0xff;
} else {
- *program->codeptr++ = 0x75;
- x86_add_fixup (program, program->codeptr, label, 0);
- *program->codeptr++ = 0xff;
+ *compiler->codeptr++ = 0x75;
+ x86_add_fixup (compiler, compiler->codeptr, label, 0);
+ *compiler->codeptr++ = 0xff;
}
}
-void x86_emit_label (OrcProgram *program, int label)
+void x86_emit_label (OrcCompiler *compiler, int label)
{
- ORC_ASM_CODE(program,".L%d:\n", label);
+ ORC_ASM_CODE(compiler,".L%d:\n", label);
- x86_add_label (program, program->codeptr, label);
+ x86_add_label (compiler, compiler->codeptr, label);
}
void
-x86_do_fixups (OrcProgram *program)
+x86_do_fixups (OrcCompiler *compiler)
{
int i;
- for(i=0;i<program->n_fixups;i++){
- if (program->fixups[i].type == 0) {
- unsigned char *label = program->labels[program->fixups[i].label];
- unsigned char *ptr = program->fixups[i].ptr;
+ for(i=0;i<compiler->n_fixups;i++){
+ if (compiler->fixups[i].type == 0) {
+ unsigned char *label = compiler->labels[compiler->fixups[i].label];
+ unsigned char *ptr = compiler->fixups[i].ptr;
int diff;
diff = ((int8_t)ptr[0]) + (label - ptr);
if (diff != (int8_t)diff) {
ORC_WARNING("short jump too long");
- program->error = TRUE;
+ compiler->error = TRUE;
}
ptr[0] = diff;
- } else if (program->fixups[i].type == 1) {
- unsigned char *label = program->labels[program->fixups[i].label];
- unsigned char *ptr = program->fixups[i].ptr;
+ } else if (compiler->fixups[i].type == 1) {
+ unsigned char *label = compiler->labels[compiler->fixups[i].label];
+ unsigned char *ptr = compiler->fixups[i].ptr;
int diff;
diff = ORC_READ_UINT32_LE (ptr) + (label - ptr);
}
void
-x86_emit_prologue (OrcProgram *program)
+x86_emit_prologue (OrcCompiler *compiler)
{
- orc_program_append_code(program,".global %s\n", program->name);
- orc_program_append_code(program,"%s:\n", program->name);
+ orc_compiler_append_code(compiler,".global %s\n", compiler->program->name);
+ orc_compiler_append_code(compiler,"%s:\n", compiler->program->name);
if (x86_64) {
int i;
for(i=0;i<16;i++){
- if (program->used_regs[ORC_GP_REG_BASE+i] &&
- program->save_regs[ORC_GP_REG_BASE+i]) {
- x86_emit_push (program, 8, ORC_GP_REG_BASE+i);
+ if (compiler->used_regs[ORC_GP_REG_BASE+i] &&
+ compiler->save_regs[ORC_GP_REG_BASE+i]) {
+ x86_emit_push (compiler, 8, ORC_GP_REG_BASE+i);
}
}
} else {
- x86_emit_push (program, 4, X86_EBP);
- x86_emit_mov_memoffset_reg (program, 4, 8, X86_ESP, X86_EBP);
- if (program->used_regs[X86_EDI]) {
- x86_emit_push (program, 4, X86_EDI);
+ x86_emit_push (compiler, 4, X86_EBP);
+ x86_emit_mov_memoffset_reg (compiler, 4, 8, X86_ESP, X86_EBP);
+ if (compiler->used_regs[X86_EDI]) {
+ x86_emit_push (compiler, 4, X86_EDI);
}
- if (program->used_regs[X86_ESI]) {
- x86_emit_push (program, 4, X86_ESI);
+ if (compiler->used_regs[X86_ESI]) {
+ x86_emit_push (compiler, 4, X86_ESI);
}
- if (program->used_regs[X86_EBX]) {
- x86_emit_push (program, 4, X86_EBX);
+ if (compiler->used_regs[X86_EBX]) {
+ x86_emit_push (compiler, 4, X86_EBX);
}
}
}
void
-x86_emit_epilogue (OrcProgram *program)
+x86_emit_epilogue (OrcCompiler *compiler)
{
if (x86_64) {
int i;
for(i=15;i>=0;i--){
- if (program->used_regs[ORC_GP_REG_BASE+i] &&
- program->save_regs[ORC_GP_REG_BASE+i]) {
- x86_emit_push (program, 8, ORC_GP_REG_BASE+i);
+ if (compiler->used_regs[ORC_GP_REG_BASE+i] &&
+ compiler->save_regs[ORC_GP_REG_BASE+i]) {
+ x86_emit_push (compiler, 8, ORC_GP_REG_BASE+i);
}
}
} else {
- if (program->used_regs[X86_EBX]) {
- x86_emit_pop (program, 4, X86_EBX);
+ if (compiler->used_regs[X86_EBX]) {
+ x86_emit_pop (compiler, 4, X86_EBX);
}
- if (program->used_regs[X86_ESI]) {
- x86_emit_pop (program, 4, X86_ESI);
+ if (compiler->used_regs[X86_ESI]) {
+ x86_emit_pop (compiler, 4, X86_ESI);
}
- if (program->used_regs[X86_EDI]) {
- x86_emit_pop (program, 4, X86_EDI);
+ if (compiler->used_regs[X86_EDI]) {
+ x86_emit_pop (compiler, 4, X86_EDI);
}
- x86_emit_pop (program, 4, X86_EBP);
+ x86_emit_pop (compiler, 4, X86_EBP);
}
- x86_emit_ret (program);
+ x86_emit_ret (compiler);
}
void
-x86_emit_align (OrcProgram *program)
+x86_emit_align (OrcCompiler *compiler)
{
int diff;
int align_shift = 4;
- diff = (
program->code - program->codeptr)&((1<<align_shift) - 1);
+ diff = (
compiler->program->code - compiler->codeptr)&((1<<align_shift) - 1);
while (diff) {
- ORC_ASM_CODE(program," nop\n");
- *program->codeptr++ = 0x90;
+ ORC_ASM_CODE(compiler," nop\n");
+ *compiler->codeptr++ = 0x90;
diff--;
}
}
void
-x86_test (OrcProgram *program)
+x86_test (OrcCompiler *compiler)
{
int size;
int i;
for(size=2;size<=4;size+=2) {
for(i=0;i<8;i++){
reg = ORC_GP_REG_BASE + i;
- x86_emit_push (program, size, reg);
- x86_emit_pop (program, size, reg);
- x86_emit_mov_imm_reg (program, size, 0, reg);
- x86_emit_mov_imm_reg (program, size, 1, reg);
- x86_emit_mov_imm_reg (program, size, 256, reg);
- x86_emit_dec_memoffset (program, size, 0, reg);
- x86_emit_dec_memoffset (program, size, 1, reg);
- x86_emit_dec_memoffset (program, size, 256, reg);
- x86_emit_add_imm_memoffset (program, size, 1, 0, reg);
- x86_emit_add_imm_memoffset (program, size, 1, 1, reg);
- x86_emit_add_imm_memoffset (program, size, 1, 256, reg);
- x86_emit_add_imm_memoffset (program, size, 256, 0, reg);
- x86_emit_add_imm_memoffset (program, size, 256, 1, reg);
- x86_emit_add_imm_memoffset (program, size, 256, 256, reg);
+ x86_emit_push (compiler, size, reg);
+ x86_emit_pop (compiler, size, reg);
+ x86_emit_mov_imm_reg (compiler, size, 0, reg);
+ x86_emit_mov_imm_reg (compiler, size, 1, reg);
+ x86_emit_mov_imm_reg (compiler, size, 256, reg);
+ x86_emit_dec_memoffset (compiler, size, 0, reg);
+ x86_emit_dec_memoffset (compiler, size, 1, reg);
+ x86_emit_dec_memoffset (compiler, size, 256, reg);
+ x86_emit_add_imm_memoffset (compiler, size, 1, 0, reg);
+ x86_emit_add_imm_memoffset (compiler, size, 1, 1, reg);
+ x86_emit_add_imm_memoffset (compiler, size, 1, 256, reg);
+ x86_emit_add_imm_memoffset (compiler, size, 256, 0, reg);
+ x86_emit_add_imm_memoffset (compiler, size, 256, 1, reg);
+ x86_emit_add_imm_memoffset (compiler, size, 256, 256, reg);
for(j=0;j<8;j++){
int reg2 = ORC_GP_REG_BASE + j;
- x86_emit_mov_reg_reg (program, size, reg, reg2);
- x86_emit_mov_memoffset_reg (program, size, 0, reg, reg2);
- x86_emit_mov_memoffset_reg (program, size, 1, reg, reg2);
- x86_emit_mov_memoffset_reg (program, size, 256, reg, reg2);
- x86_emit_mov_reg_memoffset (program, size, reg, 0, reg2);
- x86_emit_mov_reg_memoffset (program, size, reg, 1, reg2);
- x86_emit_mov_reg_memoffset (program, size, reg, 256, reg2);
+ x86_emit_mov_reg_reg (compiler, size, reg, reg2);
+ x86_emit_mov_memoffset_reg (compiler, size, 0, reg, reg2);
+ x86_emit_mov_memoffset_reg (compiler, size, 1, reg, reg2);
+ x86_emit_mov_memoffset_reg (compiler, size, 256, reg, reg2);
+ x86_emit_mov_reg_memoffset (compiler, size, reg, 0, reg2);
+ x86_emit_mov_reg_memoffset (compiler, size, reg, 1, reg2);
+ x86_emit_mov_reg_memoffset (compiler, size, reg, 256, reg2);
}
}
}
extern int x86_exec_ptr;
extern int x86_ptr_size;
-void x86_emit_push (OrcProgram *program, int size, int reg);
-void x86_emit_pop (OrcProgram *program, int size, int reg);
-void x86_emit_mov_memoffset_reg (OrcProgram *program, int size, int offset, int reg1, int reg2);
-void x86_emit_mov_memoffset_mmx (OrcProgram *program, int size, int offset,
+void x86_emit_push (OrcCompiler *compiler, int size, int reg);
+void x86_emit_pop (OrcCompiler *compiler, int size, int reg);
+void x86_emit_mov_memoffset_reg (OrcCompiler *compiler, int size, int offset, int reg1, int reg2);
+void x86_emit_mov_memoffset_mmx (OrcCompiler *compiler, int size, int offset,
int reg1, int reg2);
-void x86_emit_mov_memoffset_sse (OrcProgram *program, int size, int offset,
+void x86_emit_mov_memoffset_sse (OrcCompiler *compiler, int size, int offset,
int reg1, int reg2);
-void x86_emit_mov_reg_memoffset (OrcProgram *program, int size, int reg1, int offset, int reg2);
-void x86_emit_mov_mmx_memoffset (OrcProgram *program, int size, int reg1, int offset,
+void x86_emit_mov_reg_memoffset (OrcCompiler *compiler, int size, int reg1, int offset, int reg2);
+void x86_emit_mov_mmx_memoffset (OrcCompiler *compiler, int size, int reg1, int offset,
int reg2);
-void x86_emit_mov_sse_memoffset (OrcProgram *program, int size, int reg1, int offset,
+void x86_emit_mov_sse_memoffset (OrcCompiler *compiler, int size, int reg1, int offset,
int reg2, int aligned, int uncached);
-void x86_emit_mov_imm_reg (OrcProgram *program, int size, int value, int reg1);
-void x86_emit_mov_reg_reg (OrcProgram *program, int size, int reg1, int reg2);
-void x86_emit_mov_sse_reg_reg (OrcProgram *program, int reg1, int reg2);
-void x86_emit_mov_mmx_reg_reg (OrcProgram *program, int reg1, int reg2);
-void x86_emit_mov_reg_mmx (OrcProgram *program, int reg1, int reg2);
-void x86_emit_mov_mmx_reg (OrcProgram *program, int reg1, int reg2);
-void x86_emit_mov_reg_sse (OrcProgram *program, int reg1, int reg2);
-void x86_emit_mov_sse_reg (OrcProgram *program, int reg1, int reg2);
-void x86_emit_test_reg_reg (OrcProgram *program, int size, int reg1, int reg2);
-void x86_emit_sar_imm_reg (OrcProgram *program, int size, int value, int reg);
-void x86_emit_dec_memoffset (OrcProgram *program, int size, int offset, int reg);
-void x86_emit_add_imm_memoffset (OrcProgram *program, int size, int value, int offset, int reg);
-void x86_emit_and_imm_memoffset (OrcProgram *program, int size, int value, int offset, int reg);
-void x86_emit_add_imm_reg (OrcProgram *program, int size, int value, int reg);
-void x86_emit_and_imm_reg (OrcProgram *program, int size, int value, int reg);
-void x86_emit_sub_reg_reg (OrcProgram *program, int size, int reg1, int reg2);
-void x86_emit_sub_memoffset_reg (OrcProgram *program, int size,
+void x86_emit_mov_imm_reg (OrcCompiler *compiler, int size, int value, int reg1);
+void x86_emit_mov_reg_reg (OrcCompiler *compiler, int size, int reg1, int reg2);
+void x86_emit_mov_sse_reg_reg (OrcCompiler *compiler, int reg1, int reg2);
+void x86_emit_mov_mmx_reg_reg (OrcCompiler *compiler, int reg1, int reg2);
+void x86_emit_mov_reg_mmx (OrcCompiler *compiler, int reg1, int reg2);
+void x86_emit_mov_mmx_reg (OrcCompiler *compiler, int reg1, int reg2);
+void x86_emit_mov_reg_sse (OrcCompiler *compiler, int reg1, int reg2);
+void x86_emit_mov_sse_reg (OrcCompiler *compiler, int reg1, int reg2);
+void x86_emit_test_reg_reg (OrcCompiler *compiler, int size, int reg1, int reg2);
+void x86_emit_sar_imm_reg (OrcCompiler *compiler, int size, int value, int reg);
+void x86_emit_dec_memoffset (OrcCompiler *compiler, int size, int offset, int reg);
+void x86_emit_add_imm_memoffset (OrcCompiler *compiler, int size, int value, int offset, int reg);
+void x86_emit_and_imm_memoffset (OrcCompiler *compiler, int size, int value, int offset, int reg);
+void x86_emit_add_imm_reg (OrcCompiler *compiler, int size, int value, int reg);
+void x86_emit_and_imm_reg (OrcCompiler *compiler, int size, int value, int reg);
+void x86_emit_sub_reg_reg (OrcCompiler *compiler, int size, int reg1, int reg2);
+void x86_emit_sub_memoffset_reg (OrcCompiler *compiler, int size,
int offset, int reg, int destreg);
-void x86_emit_cmp_reg_memoffset (OrcProgram *program, int size, int reg1,
+void x86_emit_cmp_reg_memoffset (OrcCompiler *compiler, int size, int reg1,
int offset, int reg);
-void x86_emit_cmp_imm_memoffset (OrcProgram *program, int size, int value,
+void x86_emit_cmp_imm_memoffset (OrcCompiler *compiler, int size, int value,
int offset, int reg);
-void x86_emit_emms (OrcProgram *program);
-void x86_emit_ret (OrcProgram *program);
-void x86_emit_jle (OrcProgram *program, int label);
-void x86_emit_je (OrcProgram *program, int label);
-void x86_emit_jne (OrcProgram *program, int label);
-void x86_emit_jmp (OrcProgram *program, int label);
-void x86_emit_label (OrcProgram *program, int label);
-void x86_emit_align (OrcProgram *program);
-void x86_do_fixups (OrcProgram *program);
-void x86_emit_prologue (OrcProgram *program);
-void x86_emit_epilogue (OrcProgram *program);
+void x86_emit_emms (OrcCompiler *compiler);
+void x86_emit_ret (OrcCompiler *compiler);
+void x86_emit_jle (OrcCompiler *compiler, int label);
+void x86_emit_je (OrcCompiler *compiler, int label);
+void x86_emit_jne (OrcCompiler *compiler, int label);
+void x86_emit_jmp (OrcCompiler *compiler, int label);
+void x86_emit_label (OrcCompiler *compiler, int label);
+void x86_emit_align (OrcCompiler *compiler);
+void x86_do_fixups (OrcCompiler *compiler);
+void x86_emit_prologue (OrcCompiler *compiler);
+void x86_emit_epilogue (OrcCompiler *compiler);
-void x86_emit_rex (OrcProgram *program, int size, int reg1, int reg2, int reg3);
-void x86_emit_modrm_memoffset (OrcProgram *program, int reg1, int offset, int reg2);
-void x86_emit_modrm_reg (OrcProgram *program, int reg1, int reg2);
-void x86_test (OrcProgram *program);
+void x86_emit_rex (OrcCompiler *compiler, int size, int reg1, int reg2, int reg3);
+void x86_emit_modrm_memoffset (OrcCompiler *compiler, int reg1, int offset, int reg2);
+void x86_emit_modrm_reg (OrcCompiler *compiler, int reg1, int reg2);
+void x86_test (OrcCompiler *compiler);
-void mmx_emit_loadiw (OrcProgram *p, int reg, int value);
-void sse_emit_loadiw (OrcProgram *p, int reg, int value);
-void sse_emit_loadw (OrcProgram *p, int reg, int offset, int reg1);
+void mmx_emit_loadiw (OrcCompiler *p, int reg, int value);
+void sse_emit_loadiw (OrcCompiler *p, int reg, int value);
+void sse_emit_loadw (OrcCompiler *p, int reg, int offset, int reg1);
enum {
X86_EAX = ORC_GP_REG_BASE,
ret = orc_program_compile (p);
if (!ret) {
error = TRUE;
+ goto out;
}
printf("%s", orc_program_get_asm_code (p));
+out:
orc_program_free (p);
}
projects / platform / upstream / orc.git / commitdiff