#define X86_MODRM(mod, rm, reg) ((((mod)&3)<<6)|(((rm)&7)<<0)|(((reg)&7)<<3))
-#ifdef HAVE_AMD64
-int x86_64 = 1;
-int x86_ptr_size = 8;
-int x86_exec_ptr = X86_EDI;
-#else
-int x86_64 = 0;
-int x86_ptr_size = 4;
-int x86_exec_ptr = X86_EBP;
-#endif
-
-const char *
-x86_get_regname_sse(int i)
-{
- static const char *x86_regs[] = {
- "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
- "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15"
- };
-
- if (i>=X86_XMM0 && i<X86_XMM0 + 16) return x86_regs[i - X86_XMM0];
- switch (i) {
- case 0:
- return "UNALLOCATED";
- case 1:
- return "direct";
- default:
- return "ERROR";
- }
-}
-
-int
-x86_get_regnum(int i)
-{
- return (i&0xf);
-}
-
-void
-x86_emit_rex (OrcCompiler *compiler, int size, int reg1, int reg2, int reg3)
-{
- int rex = 0x40;
-
- if (x86_64) {
- if (size >= 8) rex |= 0x08;
- if (reg1 == 1 || (x86_get_regnum(reg1)>=8)) rex |= 0x4;
- if (reg2 == 1 || (x86_get_regnum(reg2)>=8)) rex |= 0x2;
- if (reg3 == 1 || (x86_get_regnum(reg3)>=8)) rex |= 0x1;
-
- if (rex != 0x40) *compiler->codeptr++ = rex;
- }
-}
-
-void
-x86_emit_modrm_reg (OrcCompiler *compiler, int reg1, int reg2)
-{
- *compiler->codeptr++ = X86_MODRM(3, reg1, reg2);
-}
-
-void
-sse_emit_f20f (OrcCompiler *p, const char *insn_name, int code,
- int src, int dest)
-{
- ORC_ASM_CODE(p," %s %%%s, %%%s\n", insn_name,
- x86_get_regname_sse(src),
- x86_get_regname_sse(dest));
- *p->codeptr++ = 0xf2;
- x86_emit_rex (p, 0, src, 0, dest);
- *p->codeptr++ = 0x0f;
- *p->codeptr++ = code;
- x86_emit_modrm_reg (p, src, dest);
-}
-
-void
-sse_emit_f30f (OrcCompiler *p, const char *insn_name, int code,
- int src, int dest)
-{
- ORC_ASM_CODE(p," %s %%%s, %%%s\n", insn_name,
- x86_get_regname_sse(src),
- x86_get_regname_sse(dest));
- *p->codeptr++ = 0xf3;
- x86_emit_rex (p, 0, src, 0, dest);
- *p->codeptr++ = 0x0f;
- *p->codeptr++ = code;
- x86_emit_modrm_reg (p, src, dest);
-}
-
-void
-sse_emit_660f (OrcCompiler *p, const char *insn_name, int code,
- int src, int dest)
-{
- ORC_ASM_CODE(p," %s %%%s, %%%s\n", insn_name,
- x86_get_regname_sse(src),
- x86_get_regname_sse(dest));
- *p->codeptr++ = 0x66;
- x86_emit_rex (p, 0, src, 0, dest);
- *p->codeptr++ = 0x0f;
- *p->codeptr++ = code;
- x86_emit_modrm_reg (p, src, dest);
-}
-
-void
-sse_emit_0f (OrcCompiler *p, const char *insn_name, int code,
- int src, int dest)
-{
- ORC_ASM_CODE(p," %s %%%s, %%%s\n", insn_name,
- x86_get_regname_sse(src),
- x86_get_regname_sse(dest));
- x86_emit_rex (p, 0, src, 0, dest);
- *p->codeptr++ = 0x0f;
- *p->codeptr++ = code;
- x86_emit_modrm_reg (p, src, dest);
-}
-
-
#define UNARY(opcode,insn_name,code) \
static void \
sse_rule_ ## opcode (OrcCompiler *p, void *user, OrcInstruction *insn) \
{ \
- sse_emit_0f (p, insn_name, code, \
+ orc_sse_emit_0f (p, insn_name, code, \
p->vars[insn->src_args[0]].alloc, \
p->vars[insn->dest_args[0]].alloc); \
}
static void \
sse_rule_ ## opcode (OrcCompiler *p, void *user, OrcInstruction *insn) \
{ \
- sse_emit_0f (p, insn_name, code, \
+ orc_sse_emit_0f (p, insn_name, code, \
p->vars[insn->src_args[1]].alloc, \
p->vars[insn->dest_args[0]].alloc); \
}
static void
sse_rule_cmpeqf (OrcCompiler *p, void *user, OrcInstruction *insn)
{
- sse_emit_0f (p, "cmpeqps", 0xc2,
+ orc_sse_emit_0f (p, "cmpeqps", 0xc2,
p->vars[insn->src_args[1]].alloc,
p->vars[insn->dest_args[0]].alloc);
*p->codeptr++ = 0x00;
static void
sse_rule_cmpltf (OrcCompiler *p, void *user, OrcInstruction *insn)
{
- sse_emit_0f (p, "cmpltps", 0xc2,
+ orc_sse_emit_0f (p, "cmpltps", 0xc2,
p->vars[insn->src_args[1]].alloc,
p->vars[insn->dest_args[0]].alloc);
*p->codeptr++ = 0x01;
static void
sse_rule_cmplef (OrcCompiler *p, void *user, OrcInstruction *insn)
{
- sse_emit_0f (p, "cmpleps", 0xc2,
+ orc_sse_emit_0f (p, "cmpleps", 0xc2,
p->vars[insn->src_args[1]].alloc,
p->vars[insn->dest_args[0]].alloc);
*p->codeptr++ = 0x02;
static void
sse_rule_convfl (OrcCompiler *p, void *user, OrcInstruction *insn)
{
- sse_emit_660f (p, "cvtps2dq", 0x5b,
+ orc_sse_emit_660f (p, "cvtps2dq", 0x5b,
p->vars[insn->src_args[0]].alloc,
p->vars[insn->dest_args[0]].alloc);
}
static void
sse_rule_convlf (OrcCompiler *p, void *user, OrcInstruction *insn)
{
- sse_emit_0f (p, "cvtdq2ps", 0x5b,
+ orc_sse_emit_0f (p, "cvtdq2ps", 0x5b,
p->vars[insn->src_args[0]].alloc,
p->vars[insn->dest_args[0]].alloc);
}
static void \
sse_rule_ ## opcode (OrcCompiler *p, void *user, OrcInstruction *insn) \
{ \
- sse_emit_660f (p, insn_name, code, \
+ orc_sse_emit_660f (p, insn_name, code, \
p->vars[insn->src_args[0]].alloc, \
p->vars[insn->dest_args[0]].alloc); \
}
static void \
sse_rule_ ## opcode (OrcCompiler *p, void *user, OrcInstruction *insn) \
{ \
- sse_emit_660f (p, insn_name, code, \
+ orc_sse_emit_660f (p, insn_name, code, \
p->vars[insn->src_args[1]].alloc, \
p->vars[insn->dest_args[0]].alloc); \
}
static void
sse_rule_cmpeqg (OrcCompiler *p, void *user, OrcInstruction *insn)
{
- sse_emit_660f (p, "cmpeqpd", 0xc2,
+ orc_sse_emit_660f (p, "cmpeqpd", 0xc2,
p->vars[insn->src_args[1]].alloc,
p->vars[insn->dest_args[0]].alloc);
*p->codeptr++ = 0x00;
static void
sse_rule_cmpltg (OrcCompiler *p, void *user, OrcInstruction *insn)
{
- sse_emit_660f (p, "cmpltpd", 0xc2,
+ orc_sse_emit_660f (p, "cmpltpd", 0xc2,
p->vars[insn->src_args[1]].alloc,
p->vars[insn->dest_args[0]].alloc);
*p->codeptr++ = 0x01;
static void
sse_rule_cmpleg (OrcCompiler *p, void *user, OrcInstruction *insn)
{
- sse_emit_660f (p, "cmplepd", 0xc2,
+ orc_sse_emit_660f (p, "cmplepd", 0xc2,
p->vars[insn->src_args[1]].alloc,
p->vars[insn->dest_args[0]].alloc);
*p->codeptr++ = 0x02;
static void
sse_rule_convgl (OrcCompiler *p, void *user, OrcInstruction *insn)
{
- sse_emit_f20f (p, "cvtpd2dq", 0xe6,
+ orc_sse_emit_f20f (p, "cvtpd2dq", 0xe6,
p->vars[insn->src_args[0]].alloc,
p->vars[insn->dest_args[0]].alloc);
}
static void
sse_rule_convlg (OrcCompiler *p, void *user, OrcInstruction *insn)
{
- sse_emit_f30f (p, "cvtdq2pd", 0xe6,
+ orc_sse_emit_f30f (p, "cvtdq2pd", 0xe6,
p->vars[insn->src_args[0]].alloc,
p->vars[insn->dest_args[0]].alloc);
}
static void
sse_rule_convgf (OrcCompiler *p, void *user, OrcInstruction *insn)
{
- sse_emit_660f (p, "cvtpd2ps", 0x5a,
+ orc_sse_emit_660f (p, "cvtpd2ps", 0x5a,
p->vars[insn->src_args[0]].alloc,
p->vars[insn->dest_args[0]].alloc);
}
static void
sse_rule_convfg (OrcCompiler *p, void *user, OrcInstruction *insn)
{
- sse_emit_0f (p, "cvtps2pd", 0x5a,
+ orc_sse_emit_0f (p, "cvtps2pd", 0x5a,
p->vars[insn->src_args[0]].alloc,
p->vars[insn->dest_args[0]].alloc);
}
#include <orc/x86.h>
-#define X86_MODRM(mod, rm, reg) ((((mod)&3)<<6)|(((rm)&7)<<0)|(((reg)&7)<<3))
-
-#ifdef HAVE_AMD64
-int x86_64 = 1;
-int x86_ptr_size = 8;
-int x86_exec_ptr = X86_EDI;
-#else
-int x86_64 = 0;
-int x86_ptr_size = 4;
-int x86_exec_ptr = X86_EBP;
-#endif
-
-const char *
-x86_get_regname_sse(int i)
-{
- static const char *x86_regs[] = {
- "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
- "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15"
- };
-
- if (i>=X86_XMM0 && i<X86_XMM0 + 16) return x86_regs[i - X86_XMM0];
- switch (i) {
- case 0:
- return "UNALLOCATED";
- case 1:
- return "direct";
- default:
- return "ERROR";
- }
-}
-
-int
-x86_get_regnum(int i)
-{
- return (i&0xf);
-}
-
-void
-x86_emit_rex (OrcCompiler *compiler, int size, int reg1, int reg2, int reg3)
-{
- int rex = 0x40;
-
- if (x86_64) {
- if (size >= 8) rex |= 0x08;
- if (reg1 == 1 || (x86_get_regnum(reg1)>=8)) rex |= 0x4;
- if (reg2 == 1 || (x86_get_regnum(reg2)>=8)) rex |= 0x2;
- if (reg3 == 1 || (x86_get_regnum(reg3)>=8)) rex |= 0x1;
-
- if (rex != 0x40) *compiler->codeptr++ = rex;
- }
-}
-
-void
-x86_emit_modrm_reg (OrcCompiler *compiler, int reg1, int reg2)
-{
- *compiler->codeptr++ = X86_MODRM(3, reg1, reg2);
-}
-
-void
-sse_emit_f20f (OrcCompiler *p, const char *insn_name, int code,
- int src, int dest)
-{
- ORC_ASM_CODE(p," %s %%%s, %%%s\n", insn_name,
- x86_get_regname_sse(src),
- x86_get_regname_sse(dest));
- *p->codeptr++ = 0xf2;
- x86_emit_rex (p, 0, src, 0, dest);
- *p->codeptr++ = 0x0f;
- *p->codeptr++ = code;
- x86_emit_modrm_reg (p, src, dest);
-}
-
-void
-sse_emit_660f (OrcCompiler *p, const char *insn_name, int code,
- int src, int dest)
-{
- ORC_ASM_CODE(p," %s %%%s, %%%s\n", insn_name,
- x86_get_regname_sse(src),
- x86_get_regname_sse(dest));
- *p->codeptr++ = 0x66;
- x86_emit_rex (p, 0, src, 0, dest);
- *p->codeptr++ = 0x0f;
- *p->codeptr++ = code;
- x86_emit_modrm_reg (p, src, dest);
-}
-
static void
sse_rule_compin (OrcCompiler *p, void *user, OrcInstruction *insn)
{
int tmpreg2 = X86_XMM7;
- sse_emit_660f (p, "punpcklbw", 0x60,
+ orc_sse_emit_660f (p, "punpcklbw", 0x60,
p->vars[insn->src_args[0]].alloc,
p->tmpreg);
ORC_ASM_CODE(p," psrlw $8, %%%s\n",
- x86_get_regname_sse(p->tmpreg));
+ orc_x86_get_regname_sse(p->tmpreg));
*p->codeptr++ = 0x66;
*p->codeptr++ = 0x0f;
*p->codeptr++ = 0x71;
- x86_emit_modrm_reg (p, p->tmpreg, 2);
+ orc_x86_emit_modrm_reg (p, p->tmpreg, 2);
*p->codeptr++ = 8;
- sse_emit_660f (p, "punpcklbw", 0x60,
+ orc_sse_emit_660f (p, "punpcklbw", 0x60,
p->vars[insn->src_args[1]].alloc,
tmpreg2);
if (p->loop_shift > 0) {
- sse_emit_660f (p, "punpcklwd", 0x61,
+ orc_sse_emit_660f (p, "punpcklwd", 0x61,
tmpreg2, tmpreg2);
- sse_emit_660f (p, "punpckldq", 0x62,
+ orc_sse_emit_660f (p, "punpckldq", 0x62,
tmpreg2, tmpreg2);
} else {
- sse_emit_f20f (p, "pshuflw $00,", 0x70,
+ orc_sse_emit_f20f (p, "pshuflw $00,", 0x70,
tmpreg2, tmpreg2);
*p->codeptr++ = 0x00;
}
ORC_ASM_CODE(p," psrlw $8, %%%s\n",
- x86_get_regname_sse(tmpreg2));
+ orc_x86_get_regname_sse(tmpreg2));
*p->codeptr++ = 0x66;
*p->codeptr++ = 0x0f;
*p->codeptr++ = 0x71;
- x86_emit_modrm_reg (p, tmpreg2, 2);
+ orc_x86_emit_modrm_reg (p, tmpreg2, 2);
*p->codeptr++ = 8;
- sse_emit_660f (p, "pmullw", 0xd5,
+ orc_sse_emit_660f (p, "pmullw", 0xd5,
p->tmpreg,
tmpreg2);
ORC_ASM_CODE(p," movl $0x00800080, %%ecx\n");
- x86_emit_rex(p, 4, X86_ECX, 0, 0);
- *p->codeptr++ = 0xb8 + x86_get_regnum(X86_ECX);
+ orc_x86_emit_rex(p, 4, X86_ECX, 0, 0);
+ *p->codeptr++ = 0xb8 + orc_x86_get_regnum(X86_ECX);
*p->codeptr++ = 0x80;
*p->codeptr++ = 0x00;
*p->codeptr++ = 0x80;
*p->codeptr++ = 0x00;
- ORC_ASM_CODE(p," movd %%ecx, %%%s\n", x86_get_regname_sse(p->tmpreg));
+ ORC_ASM_CODE(p," movd %%ecx, %%%s\n", orc_x86_get_regname_sse(p->tmpreg));
*p->codeptr++ = 0x66;
*p->codeptr++ = 0x0f;
*p->codeptr++ = 0x6e;
- x86_emit_modrm_reg (p, X86_ECX, p->tmpreg);
+ orc_x86_emit_modrm_reg (p, X86_ECX, p->tmpreg);
- ORC_ASM_CODE(p," pshufd $0, %%%s, %%%s\n", x86_get_regname_sse(p->tmpreg),
- x86_get_regname_sse(p->tmpreg));
+ ORC_ASM_CODE(p," pshufd $0, %%%s, %%%s\n", orc_x86_get_regname_sse(p->tmpreg),
+ orc_x86_get_regname_sse(p->tmpreg));
*p->codeptr++ = 0x66;
*p->codeptr++ = 0x0f;
*p->codeptr++ = 0x70;
- x86_emit_modrm_reg (p, p->tmpreg, p->tmpreg);
+ orc_x86_emit_modrm_reg (p, p->tmpreg, p->tmpreg);
*p->codeptr++ = 0x00;
- sse_emit_660f (p, "paddw", 0xfd,
+ orc_sse_emit_660f (p, "paddw", 0xfd,
p->tmpreg,
tmpreg2);
- sse_emit_660f (p, "movdqa", 0x6f,
+ orc_sse_emit_660f (p, "movdqa", 0x6f,
tmpreg2,
p->tmpreg);
ORC_ASM_CODE(p," psrlw $8, %%%s\n",
- x86_get_regname_sse(p->tmpreg));
+ orc_x86_get_regname_sse(p->tmpreg));
*p->codeptr++ = 0x66;
*p->codeptr++ = 0x0f;
*p->codeptr++ = 0x71;
- x86_emit_modrm_reg (p, p->tmpreg, 2);
+ orc_x86_emit_modrm_reg (p, p->tmpreg, 2);
*p->codeptr++ = 8;
- sse_emit_660f (p, "paddw", 0xfd,
+ orc_sse_emit_660f (p, "paddw", 0xfd,
p->tmpreg,
tmpreg2);
ORC_ASM_CODE(p," psrlw $8, %%%s\n",
- x86_get_regname_sse(tmpreg2));
+ orc_x86_get_regname_sse(tmpreg2));
*p->codeptr++ = 0x66;
*p->codeptr++ = 0x0f;
*p->codeptr++ = 0x71;
- x86_emit_modrm_reg (p, tmpreg2, 2);
+ orc_x86_emit_modrm_reg (p, tmpreg2, 2);
*p->codeptr++ = 8;
- sse_emit_660f (p, "packuswb", 0x67,
+ orc_sse_emit_660f (p, "packuswb", 0x67,
tmpreg2,
tmpreg2);
- sse_emit_660f (p, "movdqa", 0x6f,
+ orc_sse_emit_660f (p, "movdqa", 0x6f,
tmpreg2,
p->vars[insn->dest_args[0]].alloc);
}
static void
sse_rule_compadd (OrcCompiler *p, void *user, OrcInstruction *insn)
{
- sse_emit_660f (p, "paddusb", 0xdc,
+ orc_sse_emit_660f (p, "paddusb", 0xdc,
p->vars[insn->src_args[1]].alloc,
p->vars[insn->dest_args[0]].alloc);
}
{
int i;
- if (x86_64) {
+ if (compiler->is_64bit) {
for(i=ORC_GP_REG_BASE;i<ORC_GP_REG_BASE+16;i++){
compiler->valid_regs[i] = 1;
}
if (compiler->vars[i].name == NULL) continue;
switch (compiler->vars[i].vartype) {
case ORC_VAR_TYPE_CONST:
- mmx_emit_loadiw (compiler, compiler->vars[i].alloc,
+ orc_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 (compiler->vars[i].ptr_register) {
- x86_emit_mov_memoffset_reg (compiler, x86_ptr_size,
- (int)ORC_STRUCT_OFFSET(OrcExecutor, arrays[i]), x86_exec_ptr,
+ orc_x86_emit_mov_memoffset_reg (compiler, compiler->is_64bit ? 8 : 4,
+ (int)ORC_STRUCT_OFFSET(OrcExecutor, arrays[i]), compiler->exec_reg,
compiler->vars[i].ptr_register);
} else {
ORC_PROGRAM_ERROR(compiler, "unimplemented");
}
void
-mmx_emit_load_src (OrcCompiler *compiler, OrcVariable *var)
+orc_mmx_emit_load_src (OrcCompiler *compiler, OrcVariable *var)
{
int ptr_reg;
if (var->ptr_register == 0) {
- x86_emit_mov_memoffset_reg (compiler, x86_ptr_size,
- var->ptr_offset, x86_exec_ptr, X86_ECX);
+ orc_x86_emit_mov_memoffset_reg (compiler, compiler->is_64bit ? 8 : 4,
+ var->ptr_offset, compiler->exec_reg, X86_ECX);
ptr_reg = X86_ECX;
} else {
ptr_reg = var->ptr_register;
}
switch (compiler->loop_shift) {
case 0:
- x86_emit_mov_memoffset_reg (compiler, 2, 0, ptr_reg, X86_ECX);
- x86_emit_mov_reg_mmx (compiler, X86_ECX, var->alloc);
+ orc_x86_emit_mov_memoffset_reg (compiler, 2, 0, ptr_reg, X86_ECX);
+ orc_x86_emit_mov_reg_mmx (compiler, X86_ECX, var->alloc);
break;
case 1:
- x86_emit_mov_memoffset_mmx (compiler, 4, 0, ptr_reg, var->alloc);
+ orc_x86_emit_mov_memoffset_mmx (compiler, 4, 0, ptr_reg, var->alloc);
break;
case 2:
- x86_emit_mov_memoffset_mmx (compiler, 8, 0, ptr_reg, var->alloc);
+ orc_x86_emit_mov_memoffset_mmx (compiler, 8, 0, ptr_reg, var->alloc);
break;
default:
ORC_PROGRAM_ERROR(compiler, "bad size");
{
int ptr_reg;
if (var->ptr_register == 0) {
- x86_emit_mov_memoffset_reg (compiler, x86_ptr_size,
- var->ptr_offset, x86_exec_ptr, X86_ECX);
+ orc_x86_emit_mov_memoffset_reg (compiler, compiler->is_64bit ? 8 : 4,
+ var->ptr_offset, compiler->exec_reg, X86_ECX);
ptr_reg = X86_ECX;
} else {
ptr_reg = var->ptr_register;
if (ptr_reg == X86_ECX) {
ORC_PROGRAM_ERROR(compiler, "unimplemented");
}
- x86_emit_mov_mmx_reg (compiler, var->alloc, X86_ECX);
- x86_emit_mov_reg_memoffset (compiler, 2, X86_ECX, 0, ptr_reg);
+ orc_x86_emit_mov_mmx_reg (compiler, var->alloc, X86_ECX);
+ orc_x86_emit_mov_reg_memoffset (compiler, 2, X86_ECX, 0, ptr_reg);
break;
case 1:
- x86_emit_mov_mmx_memoffset (compiler, 4, var->alloc, 0, ptr_reg);
+ orc_x86_emit_mov_mmx_memoffset (compiler, 4, var->alloc, 0, ptr_reg);
break;
case 2:
- x86_emit_mov_mmx_memoffset (compiler, 8, var->alloc, 0, ptr_reg);
+ orc_x86_emit_mov_mmx_memoffset (compiler, 8, var->alloc, 0, ptr_reg);
break;
default:
ORC_PROGRAM_ERROR(compiler, "unimplemented");
void
orc_compiler_mmx_assemble (OrcCompiler *compiler)
{
- x86_emit_prologue (compiler);
+ orc_x86_emit_prologue (compiler);
- x86_emit_mov_memoffset_reg (compiler, 4, (int)ORC_STRUCT_OFFSET(OrcExecutor,n),
- x86_exec_ptr, 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);
+ orc_x86_emit_mov_memoffset_reg (compiler, 4, (int)ORC_STRUCT_OFFSET(OrcExecutor,n),
+ compiler->exec_reg, X86_ECX);
+ orc_x86_emit_sar_imm_reg (compiler, 4, compiler->loop_shift, X86_ECX);
+ orc_x86_emit_mov_reg_memoffset (compiler, 4, X86_ECX,
+ (int)ORC_STRUCT_OFFSET(OrcExecutor,counter2), compiler->exec_reg);
- x86_emit_mov_memoffset_reg (compiler, 4,
- (int)ORC_STRUCT_OFFSET(OrcExecutor,n), x86_exec_ptr, 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);
+ orc_x86_emit_mov_memoffset_reg (compiler, 4,
+ (int)ORC_STRUCT_OFFSET(OrcExecutor,n), compiler->exec_reg, X86_ECX);
+ orc_x86_emit_and_imm_reg (compiler, 4, (1<<compiler->loop_shift)-1, X86_ECX);
+ orc_x86_emit_mov_reg_memoffset (compiler, 4, X86_ECX,
+ (int)ORC_STRUCT_OFFSET(OrcExecutor,counter1), compiler->exec_reg);
mmx_load_constants (compiler);
if (compiler->loop_shift > 0) {
int save_loop_shift;
- x86_emit_cmp_imm_memoffset (compiler, 4, 0,
- (int)ORC_STRUCT_OFFSET(OrcExecutor,counter1), x86_exec_ptr);
- x86_emit_je (compiler, 1);
+ orc_x86_emit_cmp_imm_memoffset (compiler, 4, 0,
+ (int)ORC_STRUCT_OFFSET(OrcExecutor,counter1), compiler->exec_reg);
+ orc_x86_emit_je (compiler, 1);
save_loop_shift = compiler->loop_shift;
compiler->loop_shift = 0;
- x86_emit_label (compiler, 0);
+ orc_x86_emit_label (compiler, 0);
mmx_emit_loop (compiler);
- x86_emit_dec_memoffset (compiler, 4,
+ orc_x86_emit_dec_memoffset (compiler, 4,
(int)ORC_STRUCT_OFFSET(OrcExecutor,counter1),
- x86_exec_ptr);
- x86_emit_jne (compiler, 0);
+ compiler->exec_reg);
+ orc_x86_emit_jne (compiler, 0);
compiler->loop_shift = save_loop_shift;
}
- x86_emit_label (compiler, 1);
+ orc_x86_emit_label (compiler, 1);
- x86_emit_cmp_imm_memoffset (compiler, 4, 0,
- (int)ORC_STRUCT_OFFSET(OrcExecutor,counter2), x86_exec_ptr);
- x86_emit_je (compiler, 3);
+ orc_x86_emit_cmp_imm_memoffset (compiler, 4, 0,
+ (int)ORC_STRUCT_OFFSET(OrcExecutor,counter2), compiler->exec_reg);
+ orc_x86_emit_je (compiler, 3);
- x86_emit_label (compiler, 2);
+ orc_x86_emit_label (compiler, 2);
mmx_emit_loop (compiler);
- x86_emit_dec_memoffset (compiler, 4,
+ orc_x86_emit_dec_memoffset (compiler, 4,
(int)ORC_STRUCT_OFFSET(OrcExecutor,counter2),
- x86_exec_ptr);
- x86_emit_jne (compiler, 2);
- x86_emit_label (compiler, 3);
+ compiler->exec_reg);
+ orc_x86_emit_jne (compiler, 2);
+ orc_x86_emit_label (compiler, 3);
- x86_emit_emms (compiler);
- x86_emit_epilogue (compiler);
+ orc_x86_emit_emms (compiler);
+ orc_x86_emit_epilogue (compiler);
x86_do_fixups (compiler);
}
switch (var->vartype) {
case ORC_VAR_TYPE_SRC:
- mmx_emit_load_src (compiler, var);
+ orc_mmx_emit_load_src (compiler, var);
break;
case ORC_VAR_TYPE_CONST:
break;
if (rule) {
if (compiler->vars[insn->dest_args[0]].alloc !=
compiler->vars[insn->src_args[0]].alloc) {
- x86_emit_mov_mmx_reg_reg (compiler,
+ orc_x86_emit_mov_mmx_reg_reg (compiler,
compiler->vars[insn->src_args[0]].alloc,
compiler->vars[insn->dest_args[0]].alloc);
}
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,
+ orc_x86_emit_add_imm_reg (compiler, compiler->is_64bit ? 8 : 4,
compiler->vars[k].size << compiler->loop_shift,
compiler->vars[k].ptr_register);
} else {
- x86_emit_add_imm_memoffset (compiler, x86_ptr_size,
+ orc_x86_emit_add_imm_memoffset (compiler, compiler->is_64bit ? 8 : 4,
compiler->vars[k].size << compiler->loop_shift,
(int)ORC_STRUCT_OFFSET(OrcExecutor, arrays[k]),
- x86_exec_ptr);
+ compiler->exec_reg);
}
}
}
#define SIZE 65536
-void sse_emit_loop (OrcCompiler *compiler);
+void orc_sse_emit_loop (OrcCompiler *compiler);
void orc_compiler_sse_init (OrcCompiler *compiler);
void orc_compiler_sse_assemble (OrcCompiler *compiler);
{
int i;
- if (x86_64) {
+#ifdef HAVE_AMD64
+ compiler->is_64bit = TRUE;
+#else
+ compiler->is_64bit = FALSE;
+#endif
+
+ if (compiler->is_64bit) {
for(i=ORC_GP_REG_BASE;i<ORC_GP_REG_BASE+16;i++){
compiler->valid_regs[i] = 1;
}
compiler->tmpreg = X86_XMM0;
compiler->valid_regs[compiler->tmpreg] = 0;
+ if (compiler->is_64bit) {
+ compiler->exec_reg = X86_EDI;
+ } else {
+ compiler->exec_reg = X86_EBP;
+ }
+
switch (orc_program_get_max_var_size (compiler->program)) {
case 1:
compiler->loop_shift = 4;
case ORC_VAR_TYPE_ACCUMULATOR:
src = compiler->vars[i].alloc;
- sse_emit_660f (compiler, "pshufd $0xee,", 0x70, src, compiler->tmpreg);
-#if 0
- ORC_ASM_CODE(compiler," pshufd $0xee, %%%s, %%%s\n",
- x86_get_regname_sse(src),
- x86_get_regname_sse(compiler->tmpreg));
- *compiler->codeptr++ = 0x66;
- x86_emit_rex (compiler, 0, src, 0, compiler->tmpreg);
- *compiler->codeptr++ = 0x0f;
- *compiler->codeptr++ = 0x70;
- x86_emit_modrm_reg (compiler, src, compiler->tmpreg);
-#endif
+ orc_sse_emit_660f (compiler, "pshufd $0xee,", 0x70, src, compiler->tmpreg);
*compiler->codeptr++ = 0xee;
if (compiler->vars[i].size == 2) {
- sse_emit_660f (compiler, "paddw", 0xfd, compiler->tmpreg, src);
+ orc_sse_emit_660f (compiler, "paddw", 0xfd, compiler->tmpreg, src);
} else {
- sse_emit_660f (compiler, "paddd", 0xfe, compiler->tmpreg, src);
+ orc_sse_emit_660f (compiler, "paddd", 0xfe, compiler->tmpreg, src);
}
- sse_emit_660f (compiler, "pshufd $0x55,", 0x70, src, compiler->tmpreg);
-#if 0
- ORC_ASM_CODE(compiler," pshufd $0x55, %%%s, %%%s\n",
- x86_get_regname_sse(src),
- x86_get_regname_sse(compiler->tmpreg));
- *compiler->codeptr++ = 0x66;
- x86_emit_rex (compiler, 0, src, 0, compiler->tmpreg);
- *compiler->codeptr++ = 0x0f;
- *compiler->codeptr++ = 0xef;
- x86_emit_modrm_reg (compiler, src, compiler->tmpreg);
-#endif
+ orc_sse_emit_660f (compiler, "pshufd $0x55,", 0x70, src, compiler->tmpreg);
*compiler->codeptr++ = 0x55;
if (compiler->vars[i].size == 2) {
- sse_emit_660f (compiler, "paddw", 0xfd, compiler->tmpreg, src);
+ orc_sse_emit_660f (compiler, "paddw", 0xfd, compiler->tmpreg, src);
} else {
- sse_emit_660f (compiler, "paddd", 0xfe, compiler->tmpreg, src);
+ orc_sse_emit_660f (compiler, "paddd", 0xfe, compiler->tmpreg, src);
}
if (compiler->vars[i].size == 2) {
- sse_emit_f20f (compiler, "pshuflw $0x55,", 0x70, src, compiler->tmpreg);
-#if 0
- ORC_ASM_CODE(compiler," pshuflw $0x55, %%%s, %%%s\n",
- x86_get_regname_sse(src),
- x86_get_regname_sse(compiler->tmpreg));
- *compiler->codeptr++ = 0x66;
- x86_emit_rex (compiler, 0, src, 0, compiler->tmpreg);
- *compiler->codeptr++ = 0x0f;
- *compiler->codeptr++ = 0xef;
- x86_emit_modrm_reg (compiler, src, compiler->tmpreg);
-#endif
+ orc_sse_emit_f20f (compiler, "pshuflw $0x55,", 0x70, src, compiler->tmpreg);
*compiler->codeptr++ = 0x55;
- sse_emit_660f (compiler, "paddw", 0xfd, compiler->tmpreg, src);
+ orc_sse_emit_660f (compiler, "paddw", 0xfd, compiler->tmpreg, src);
}
if (compiler->vars[i].size == 2) {
- x86_emit_mov_sse_reg (compiler, src, X86_ECX);
- x86_emit_mov_reg_memoffset (compiler, 2, X86_ECX,
+ orc_x86_emit_mov_sse_reg (compiler, src, X86_ECX);
+ orc_x86_emit_mov_reg_memoffset (compiler, 2, X86_ECX,
(int)ORC_STRUCT_OFFSET(OrcExecutor, accumulators[i-ORC_VAR_A1]),
- x86_exec_ptr);
+ compiler->exec_reg);
} else {
- x86_emit_mov_sse_memoffset (compiler, 4, src,
+ orc_x86_emit_mov_sse_memoffset (compiler, 4, src,
(int)ORC_STRUCT_OFFSET(OrcExecutor, accumulators[i-ORC_VAR_A1]),
- x86_exec_ptr,
+ compiler->exec_reg,
var->is_aligned, var->is_uncached);
}
switch (compiler->vars[i].vartype) {
case ORC_VAR_TYPE_CONST:
if (compiler->vars[i].size == 1) {
- sse_emit_loadib (compiler, compiler->vars[i].alloc,
+ orc_sse_emit_loadib (compiler, compiler->vars[i].alloc,
(int)compiler->vars[i].value);
} else if (compiler->vars[i].size == 2) {
- sse_emit_loadiw (compiler, compiler->vars[i].alloc,
+ orc_sse_emit_loadiw (compiler, compiler->vars[i].alloc,
(int)compiler->vars[i].value);
} else if (compiler->vars[i].size == 4) {
- sse_emit_loadil (compiler, compiler->vars[i].alloc,
+ orc_sse_emit_loadil (compiler, compiler->vars[i].alloc,
(int)compiler->vars[i].value);
} else {
ORC_PROGRAM_ERROR(compiler, "unimplemented");
break;
case ORC_VAR_TYPE_PARAM:
if (compiler->vars[i].size == 1) {
- sse_emit_loadpb (compiler, compiler->vars[i].alloc, i);
+ orc_sse_emit_loadpb (compiler, compiler->vars[i].alloc, i);
} else if (compiler->vars[i].size == 2) {
- sse_emit_loadpw (compiler, compiler->vars[i].alloc, i);
+ orc_sse_emit_loadpw (compiler, compiler->vars[i].alloc, i);
} else if (compiler->vars[i].size == 4) {
- sse_emit_loadpl (compiler, compiler->vars[i].alloc, i);
+ orc_sse_emit_loadpl (compiler, compiler->vars[i].alloc, i);
} else if (compiler->vars[i].size == 8) {
- sse_emit_loadpq (compiler, compiler->vars[i].alloc, i);
+ orc_sse_emit_loadpq (compiler, compiler->vars[i].alloc, i);
} else {
ORC_PROGRAM_ERROR(compiler, "unimplemented");
}
case ORC_VAR_TYPE_SRC:
case ORC_VAR_TYPE_DEST:
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,
+ orc_x86_emit_mov_memoffset_reg (compiler, compiler->is_64bit ? 8 : 4,
+ (int)ORC_STRUCT_OFFSET(OrcExecutor, arrays[i]), compiler->exec_reg,
compiler->vars[i].ptr_register);
} else {
ORC_PROGRAM_ERROR(compiler,"unimplemented");
break;
case ORC_VAR_TYPE_ACCUMULATOR:
ORC_ASM_CODE(compiler," pxor %%%s, %%%s\n",
- x86_get_regname_sse(compiler->vars[i].alloc),
- x86_get_regname_sse(compiler->vars[i].alloc));
+ orc_x86_get_regname_sse(compiler->vars[i].alloc),
+ orc_x86_get_regname_sse(compiler->vars[i].alloc));
*compiler->codeptr++ = 0x66;
- x86_emit_rex (compiler, 0, compiler->vars[i].alloc, 0, compiler->vars[i].alloc);
+ orc_x86_emit_rex (compiler, 0, compiler->vars[i].alloc, 0, compiler->vars[i].alloc);
*compiler->codeptr++ = 0x0f;
*compiler->codeptr++ = 0xef;
- x86_emit_modrm_reg (compiler, compiler->vars[i].alloc, compiler->vars[i].alloc);
+ orc_x86_emit_modrm_reg (compiler, compiler->vars[i].alloc, compiler->vars[i].alloc);
break;
case ORC_VAR_TYPE_TEMP:
break;
}
void
-sse_emit_load_src (OrcCompiler *compiler, OrcVariable *var)
+orc_sse_emit_load_src (OrcCompiler *compiler, OrcVariable *var)
{
int ptr_reg;
if (var->ptr_register == 0) {
int i;
i = var - compiler->vars;
- x86_emit_mov_memoffset_reg (compiler, x86_ptr_size,
+ orc_x86_emit_mov_memoffset_reg (compiler, compiler->is_64bit ? 8 : 4,
(int)ORC_STRUCT_OFFSET(OrcExecutor, arrays[i]),
- x86_exec_ptr, X86_ECX);
+ compiler->exec_reg, X86_ECX);
ptr_reg = X86_ECX;
} else {
ptr_reg = var->ptr_register;
}
switch (var->size << compiler->loop_shift) {
case 1:
- x86_emit_mov_memoffset_reg (compiler, 1, 0, ptr_reg, X86_ECX);
- x86_emit_mov_reg_sse (compiler, X86_ECX, var->alloc);
+ orc_x86_emit_mov_memoffset_reg (compiler, 1, 0, ptr_reg, X86_ECX);
+ orc_x86_emit_mov_reg_sse (compiler, X86_ECX, var->alloc);
break;
case 2:
- x86_emit_mov_memoffset_reg (compiler, 2, 0, ptr_reg, X86_ECX);
- x86_emit_mov_reg_sse (compiler, X86_ECX, var->alloc);
+ orc_x86_emit_mov_memoffset_reg (compiler, 2, 0, ptr_reg, X86_ECX);
+ orc_x86_emit_mov_reg_sse (compiler, X86_ECX, var->alloc);
break;
case 4:
- x86_emit_mov_memoffset_sse (compiler, 4, 0, ptr_reg, var->alloc,
+ orc_x86_emit_mov_memoffset_sse (compiler, 4, 0, ptr_reg, var->alloc,
var->is_aligned);
break;
case 8:
- x86_emit_mov_memoffset_sse (compiler, 8, 0, ptr_reg, var->alloc,
+ orc_x86_emit_mov_memoffset_sse (compiler, 8, 0, ptr_reg, var->alloc,
var->is_aligned);
break;
case 16:
- x86_emit_mov_memoffset_sse (compiler, 16, 0, ptr_reg, var->alloc,
+ orc_x86_emit_mov_memoffset_sse (compiler, 16, 0, ptr_reg, var->alloc,
var->is_aligned);
break;
default:
}
void
-sse_emit_store_dest (OrcCompiler *compiler, OrcVariable *var)
+orc_sse_emit_store_dest (OrcCompiler *compiler, OrcVariable *var)
{
int ptr_reg;
if (var->ptr_register == 0) {
- x86_emit_mov_memoffset_reg (compiler, x86_ptr_size,
- var->ptr_offset, x86_exec_ptr, X86_ECX);
+ orc_x86_emit_mov_memoffset_reg (compiler, compiler->is_64bit ? 8 : 4,
+ var->ptr_offset, compiler->exec_reg, X86_ECX);
ptr_reg = X86_ECX;
} else {
ptr_reg = var->ptr_register;
if (ptr_reg == X86_ECX) {
ORC_PROGRAM_ERROR(compiler,"unimplemented");
}
- x86_emit_mov_sse_reg (compiler, var->alloc, X86_ECX);
- x86_emit_mov_reg_memoffset (compiler, 1, X86_ECX, 0, ptr_reg);
+ orc_x86_emit_mov_sse_reg (compiler, var->alloc, X86_ECX);
+ orc_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(compiler,"unimplemented");
}
- x86_emit_mov_sse_reg (compiler, var->alloc, X86_ECX);
- x86_emit_mov_reg_memoffset (compiler, 2, X86_ECX, 0, ptr_reg);
+ orc_x86_emit_mov_sse_reg (compiler, var->alloc, X86_ECX);
+ orc_x86_emit_mov_reg_memoffset (compiler, 2, X86_ECX, 0, ptr_reg);
break;
case 4:
- x86_emit_mov_sse_memoffset (compiler, 4, var->alloc, 0, ptr_reg,
+ orc_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 (compiler, 8, var->alloc, 0, ptr_reg,
+ orc_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 (compiler, 16, var->alloc, 0, ptr_reg,
+ orc_x86_emit_mov_sse_memoffset (compiler, 16, var->alloc, 0, ptr_reg,
var->is_aligned, var->is_uncached);
break;
default:
compiler->vars[align_var].is_aligned = FALSE;
- x86_emit_prologue (compiler);
+ orc_x86_emit_prologue (compiler);
if (compiler->loop_shift > 0) {
- x86_emit_mov_imm_reg (compiler, 4, 16, X86_EAX);
- x86_emit_sub_memoffset_reg (compiler, 4,
+ orc_x86_emit_mov_imm_reg (compiler, 4, 16, X86_EAX);
+ orc_x86_emit_sub_memoffset_reg (compiler, 4,
(int)ORC_STRUCT_OFFSET(OrcExecutor, arrays[align_var]),
- x86_exec_ptr, X86_EAX);
- x86_emit_and_imm_reg (compiler, 4, 15, X86_EAX);
- x86_emit_sar_imm_reg (compiler, 4, align_shift, X86_EAX);
+ compiler->exec_reg, X86_EAX);
+ orc_x86_emit_and_imm_reg (compiler, 4, 15, X86_EAX);
+ orc_x86_emit_sar_imm_reg (compiler, 4, align_shift, X86_EAX);
- x86_emit_cmp_reg_memoffset (compiler, 4, X86_EAX,
- (int)ORC_STRUCT_OFFSET(OrcExecutor,n), x86_exec_ptr);
+ orc_x86_emit_cmp_reg_memoffset (compiler, 4, X86_EAX,
+ (int)ORC_STRUCT_OFFSET(OrcExecutor,n), compiler->exec_reg);
- x86_emit_jle (compiler, 6);
+ orc_x86_emit_jle (compiler, 6);
- x86_emit_mov_reg_memoffset (compiler, 4, X86_EAX,
- (int)ORC_STRUCT_OFFSET(OrcExecutor,counter1), x86_exec_ptr);
+ orc_x86_emit_mov_reg_memoffset (compiler, 4, X86_EAX,
+ (int)ORC_STRUCT_OFFSET(OrcExecutor,counter1), compiler->exec_reg);
- x86_emit_mov_memoffset_reg (compiler, 4,
- (int)ORC_STRUCT_OFFSET(OrcExecutor,n), x86_exec_ptr, X86_ECX);
- x86_emit_sub_reg_reg (compiler, 4, X86_EAX, X86_ECX);
-
- x86_emit_mov_reg_reg (compiler, 4, X86_ECX, X86_EAX);
-
- 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 (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 (compiler, 7);
- x86_emit_label (compiler, 6);
-
- x86_emit_mov_memoffset_reg (compiler, 4,
- (int)ORC_STRUCT_OFFSET(OrcExecutor,n), x86_exec_ptr, 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 (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 (compiler, 4, X86_EAX,
- (int)ORC_STRUCT_OFFSET(OrcExecutor,counter3), x86_exec_ptr);
-
- x86_emit_label (compiler, 7);
+ orc_x86_emit_mov_memoffset_reg (compiler, 4,
+ (int)ORC_STRUCT_OFFSET(OrcExecutor,n), compiler->exec_reg, X86_ECX);
+ orc_x86_emit_sub_reg_reg (compiler, 4, X86_EAX, X86_ECX);
+
+ orc_x86_emit_mov_reg_reg (compiler, 4, X86_ECX, X86_EAX);
+
+ orc_x86_emit_sar_imm_reg (compiler, 4, compiler->loop_shift, X86_ECX);
+ orc_x86_emit_mov_reg_memoffset (compiler, 4, X86_ECX,
+ (int)ORC_STRUCT_OFFSET(OrcExecutor,counter2), compiler->exec_reg);
+
+ orc_x86_emit_and_imm_reg (compiler, 4, (1<<compiler->loop_shift)-1, X86_EAX);
+ orc_x86_emit_mov_reg_memoffset (compiler, 4, X86_EAX,
+ (int)ORC_STRUCT_OFFSET(OrcExecutor,counter3), compiler->exec_reg);
+
+ orc_x86_emit_jmp (compiler, 7);
+ orc_x86_emit_label (compiler, 6);
+
+ orc_x86_emit_mov_memoffset_reg (compiler, 4,
+ (int)ORC_STRUCT_OFFSET(OrcExecutor,n), compiler->exec_reg, X86_EAX);
+ orc_x86_emit_mov_reg_memoffset (compiler, 4, X86_EAX,
+ (int)ORC_STRUCT_OFFSET(OrcExecutor,counter1), compiler->exec_reg);
+ orc_x86_emit_mov_imm_reg (compiler, 4, 0, X86_EAX);
+ orc_x86_emit_mov_reg_memoffset (compiler, 4, X86_EAX,
+ (int)ORC_STRUCT_OFFSET(OrcExecutor,counter2), compiler->exec_reg);
+ orc_x86_emit_mov_reg_memoffset (compiler, 4, X86_EAX,
+ (int)ORC_STRUCT_OFFSET(OrcExecutor,counter3), compiler->exec_reg);
+
+ orc_x86_emit_label (compiler, 7);
} else {
- x86_emit_mov_memoffset_reg (compiler, 4,
- (int)ORC_STRUCT_OFFSET(OrcExecutor,n), x86_exec_ptr, X86_ECX);
- x86_emit_mov_reg_memoffset (compiler, 4, X86_ECX,
- (int)ORC_STRUCT_OFFSET(OrcExecutor,counter2), x86_exec_ptr);
+ orc_x86_emit_mov_memoffset_reg (compiler, 4,
+ (int)ORC_STRUCT_OFFSET(OrcExecutor,n), compiler->exec_reg, X86_ECX);
+ orc_x86_emit_mov_reg_memoffset (compiler, 4, X86_ECX,
+ (int)ORC_STRUCT_OFFSET(OrcExecutor,counter2), compiler->exec_reg);
}
sse_load_constants (compiler);
if (compiler->loop_shift > 0) {
int save_loop_shift;
- x86_emit_cmp_imm_memoffset (compiler, 4, 0,
- (int)ORC_STRUCT_OFFSET(OrcExecutor,counter1), x86_exec_ptr);
- x86_emit_je (compiler, 1);
+ orc_x86_emit_cmp_imm_memoffset (compiler, 4, 0,
+ (int)ORC_STRUCT_OFFSET(OrcExecutor,counter1), compiler->exec_reg);
+ orc_x86_emit_je (compiler, 1);
save_loop_shift = compiler->loop_shift;
compiler->loop_shift = 0;
- x86_emit_label (compiler, 0);
- sse_emit_loop (compiler);
- x86_emit_dec_memoffset (compiler, 4,
+ orc_x86_emit_label (compiler, 0);
+ orc_sse_emit_loop (compiler);
+ orc_x86_emit_dec_memoffset (compiler, 4,
(int)ORC_STRUCT_OFFSET(OrcExecutor,counter1),
- x86_exec_ptr);
- x86_emit_jne (compiler, 0);
+ compiler->exec_reg);
+ orc_x86_emit_jne (compiler, 0);
compiler->loop_shift = save_loop_shift;
compiler->vars[align_var].is_aligned = TRUE;
}
- x86_emit_label (compiler, 1);
+ orc_x86_emit_label (compiler, 1);
- x86_emit_cmp_imm_memoffset (compiler, 4, 0,
- (int)ORC_STRUCT_OFFSET(OrcExecutor,counter2), x86_exec_ptr);
- x86_emit_je (compiler, 3);
+ orc_x86_emit_cmp_imm_memoffset (compiler, 4, 0,
+ (int)ORC_STRUCT_OFFSET(OrcExecutor,counter2), compiler->exec_reg);
+ orc_x86_emit_je (compiler, 3);
- x86_emit_align (compiler);
- x86_emit_label (compiler, 2);
- sse_emit_loop (compiler);
- x86_emit_dec_memoffset (compiler, 4,
+ orc_x86_emit_align (compiler);
+ orc_x86_emit_label (compiler, 2);
+ orc_sse_emit_loop (compiler);
+ orc_x86_emit_dec_memoffset (compiler, 4,
(int)ORC_STRUCT_OFFSET(OrcExecutor,counter2),
- x86_exec_ptr);
- x86_emit_jne (compiler, 2);
- x86_emit_label (compiler, 3);
+ compiler->exec_reg);
+ orc_x86_emit_jne (compiler, 2);
+ orc_x86_emit_label (compiler, 3);
if (compiler->loop_shift > 0) {
int save_loop_shift;
compiler->vars[align_var].is_aligned = FALSE;
- x86_emit_cmp_imm_memoffset (compiler, 4, 0,
- (int)ORC_STRUCT_OFFSET(OrcExecutor,counter3), x86_exec_ptr);
- x86_emit_je (compiler, 5);
+ orc_x86_emit_cmp_imm_memoffset (compiler, 4, 0,
+ (int)ORC_STRUCT_OFFSET(OrcExecutor,counter3), compiler->exec_reg);
+ orc_x86_emit_je (compiler, 5);
save_loop_shift = compiler->loop_shift;
compiler->loop_shift = 0;
- x86_emit_label (compiler, 4);
- sse_emit_loop (compiler);
- x86_emit_dec_memoffset (compiler, 4,
+ orc_x86_emit_label (compiler, 4);
+ orc_sse_emit_loop (compiler);
+ orc_x86_emit_dec_memoffset (compiler, 4,
(int)ORC_STRUCT_OFFSET(OrcExecutor,counter3),
- x86_exec_ptr);
- x86_emit_jne (compiler, 4);
+ compiler->exec_reg);
+ orc_x86_emit_jne (compiler, 4);
- x86_emit_label (compiler, 5);
+ orc_x86_emit_label (compiler, 5);
compiler->loop_shift = save_loop_shift;
}
sse_save_accumulators (compiler);
- x86_emit_epilogue (compiler);
+ orc_x86_emit_epilogue (compiler);
x86_do_fixups (compiler);
}
void
-sse_emit_loop (OrcCompiler *compiler)
+orc_sse_emit_loop (OrcCompiler *compiler)
{
int j;
int k;
switch (var->vartype) {
case ORC_VAR_TYPE_SRC:
case ORC_VAR_TYPE_DEST:
- sse_emit_load_src (compiler, var);
+ orc_sse_emit_load_src (compiler, var);
break;
case ORC_VAR_TYPE_CONST:
break;
if (!(insn->opcode->flags & ORC_STATIC_OPCODE_ACCUMULATOR) &&
compiler->vars[insn->dest_args[0]].alloc !=
compiler->vars[insn->src_args[0]].alloc) {
- x86_emit_mov_sse_reg_reg (compiler,
+ orc_x86_emit_mov_sse_reg_reg (compiler,
compiler->vars[insn->src_args[0]].alloc,
compiler->vars[insn->dest_args[0]].alloc);
}
switch (var->vartype) {
case ORC_VAR_TYPE_DEST:
- sse_emit_store_dest (compiler, var);
+ orc_sse_emit_store_dest (compiler, var);
break;
case ORC_VAR_TYPE_TEMP:
break;
if (compiler->vars[k].vartype == ORC_VAR_TYPE_SRC ||
compiler->vars[k].vartype == ORC_VAR_TYPE_DEST) {
if (compiler->vars[k].ptr_register) {
- x86_emit_add_imm_reg (compiler, x86_ptr_size,
+ orc_x86_emit_add_imm_reg (compiler, compiler->is_64bit ? 8 : 4,
compiler->vars[k].size << compiler->loop_shift,
compiler->vars[k].ptr_register);
} else {
- x86_emit_add_imm_memoffset (compiler, x86_ptr_size,
+ orc_x86_emit_add_imm_memoffset (compiler, compiler->is_64bit ? 8 : 4,
compiler->vars[k].size << compiler->loop_shift,
(int)ORC_STRUCT_OFFSET(OrcExecutor, arrays[k]),
- x86_exec_ptr);
+ compiler->exec_reg);
}
}
}
char *asm_code;
int asm_code_len;
+ int is_64bit;
int tmpreg;
+ int exec_reg;
+ int gp_tmpreg;
};
struct _OrcOpcodeExecutor {
/* mmx rules */
void
-mmx_emit_loadiw (OrcCompiler *p, int reg, int value)
+orc_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),
- x86_get_regname_mmx(reg));
+ ORC_ASM_CODE(p," pxor %%%s, %%%s\n", orc_x86_get_regname_mmx(reg),
+ orc_x86_get_regname_mmx(reg));
*p->codeptr++ = 0x0f;
*p->codeptr++ = 0xef;
- x86_emit_modrm_reg (p, reg, reg);
+ orc_x86_emit_modrm_reg (p, reg, reg);
} else {
#if 1
- x86_emit_mov_imm_reg (p, 4, value, X86_ECX);
+ orc_x86_emit_mov_imm_reg (p, 4, value, X86_ECX);
- ORC_ASM_CODE(p," movd %%ecx, %%%s\n", x86_get_regname_mmx(reg));
+ ORC_ASM_CODE(p," movd %%ecx, %%%s\n", orc_x86_get_regname_mmx(reg));
*p->codeptr++ = 0x0f;
*p->codeptr++ = 0x6e;
- x86_emit_modrm_reg (p, X86_ECX, reg);
+ orc_x86_emit_modrm_reg (p, X86_ECX, reg);
#else
- ORC_ASM_CODE(p," pinsrw $0, %%ecx, %%%s\n", x86_get_regname_mmx(reg));
+ ORC_ASM_CODE(p," pinsrw $0, %%ecx, %%%s\n", orc_x86_get_regname_mmx(reg));
#endif
- ORC_ASM_CODE(p," pshufw $0, %%%s, %%%s\n", x86_get_regname_mmx(reg),
- x86_get_regname_mmx(reg));
+ ORC_ASM_CODE(p," pshufw $0, %%%s, %%%s\n", orc_x86_get_regname_mmx(reg),
+ orc_x86_get_regname_mmx(reg));
*p->codeptr++ = 0x0f;
*p->codeptr++ = 0x70;
- x86_emit_modrm_reg (p, reg, reg);
+ orc_x86_emit_modrm_reg (p, reg, reg);
*p->codeptr++ = 0x00;
}
}
mmx_rule_addw (OrcCompiler *p, void *user, OrcInstruction *insn)
{
ORC_ASM_CODE(p," paddw %%%s, %%%s\n",
- x86_get_regname_mmx(p->vars[insn->src_args[1]].alloc),
- x86_get_regname_mmx(p->vars[insn->dest_args[0]].alloc));
+ orc_x86_get_regname_mmx(p->vars[insn->src_args[1]].alloc),
+ orc_x86_get_regname_mmx(p->vars[insn->dest_args[0]].alloc));
*p->codeptr++ = 0x0f;
*p->codeptr++ = 0xfd;
- x86_emit_modrm_reg (p, p->vars[insn->src_args[1]].alloc,
+ orc_x86_emit_modrm_reg (p, p->vars[insn->src_args[1]].alloc,
p->vars[insn->dest_args[0]].alloc);
}
mmx_rule_subw (OrcCompiler *p, void *user, OrcInstruction *insn)
{
ORC_ASM_CODE(p," psubw %%%s, %%%s\n",
- x86_get_regname_mmx(p->vars[insn->src_args[1]].alloc),
- x86_get_regname_mmx(p->vars[insn->dest_args[0]].alloc));
+ orc_x86_get_regname_mmx(p->vars[insn->src_args[1]].alloc),
+ orc_x86_get_regname_mmx(p->vars[insn->dest_args[0]].alloc));
*p->codeptr++ = 0x0f;
*p->codeptr++ = 0xf9;
- x86_emit_modrm_reg (p, p->vars[insn->src_args[1]].alloc,
+ orc_x86_emit_modrm_reg (p, p->vars[insn->src_args[1]].alloc,
p->vars[insn->dest_args[0]].alloc);
}
mmx_rule_mullw (OrcCompiler *p, void *user, OrcInstruction *insn)
{
ORC_ASM_CODE(p," pmullw %%%s, %%%s\n",
- x86_get_regname_mmx(p->vars[insn->src_args[1]].alloc),
- x86_get_regname_mmx(p->vars[insn->dest_args[0]].alloc));
+ orc_x86_get_regname_mmx(p->vars[insn->src_args[1]].alloc),
+ orc_x86_get_regname_mmx(p->vars[insn->dest_args[0]].alloc));
*p->codeptr++ = 0x0f;
*p->codeptr++ = 0xd5;
- x86_emit_modrm_reg (p, p->vars[insn->src_args[1]].alloc,
+ orc_x86_emit_modrm_reg (p, p->vars[insn->src_args[1]].alloc,
p->vars[insn->dest_args[0]].alloc);
}
if (p->vars[insn->src_args[1]].vartype == ORC_VAR_TYPE_CONST) {
ORC_ASM_CODE(p," psllw $%d, %%%s\n",
p->vars[insn->src_args[1]].value,
- x86_get_regname_mmx(p->vars[insn->dest_args[0]].alloc));
+ orc_x86_get_regname_mmx(p->vars[insn->dest_args[0]].alloc));
*p->codeptr++ = 0x0f;
*p->codeptr++ = 0x71;
- x86_emit_modrm_reg (p, p->vars[insn->dest_args[0]].alloc, 6);
+ orc_x86_emit_modrm_reg (p, p->vars[insn->dest_args[0]].alloc, 6);
*p->codeptr++ = p->vars[insn->src_args[1]].value;
} else {
/* FIXME this doesn't work quite right */
ORC_ASM_CODE(p," psllw %%%s, %%%s\n",
- x86_get_regname_mmx(p->vars[insn->src_args[1]].alloc),
- x86_get_regname_mmx(p->vars[insn->dest_args[0]].alloc));
+ orc_x86_get_regname_mmx(p->vars[insn->src_args[1]].alloc),
+ orc_x86_get_regname_mmx(p->vars[insn->dest_args[0]].alloc));
*p->codeptr++ = 0x0f;
*p->codeptr++ = 0xf1;
- x86_emit_modrm_reg (p, p->vars[insn->dest_args[0]].alloc,
+ orc_x86_emit_modrm_reg (p, p->vars[insn->dest_args[0]].alloc,
p->vars[insn->src_args[1]].alloc);
}
}
if (p->vars[insn->src_args[1]].vartype == ORC_VAR_TYPE_CONST) {
ORC_ASM_CODE(p," psraw $%d, %%%s\n",
p->vars[insn->src_args[1]].value,
- x86_get_regname_mmx(p->vars[insn->dest_args[0]].alloc));
+ orc_x86_get_regname_mmx(p->vars[insn->dest_args[0]].alloc));
*p->codeptr++ = 0x0f;
*p->codeptr++ = 0x71;
- x86_emit_modrm_reg (p, p->vars[insn->dest_args[0]].alloc, 4);
+ orc_x86_emit_modrm_reg (p, p->vars[insn->dest_args[0]].alloc, 4);
*p->codeptr++ = p->vars[insn->src_args[1]].value;
} else {
/* FIXME this doesn't work quite right */
ORC_ASM_CODE(p," psraw %%%s, %%%s\n",
- x86_get_regname_mmx(p->vars[insn->src_args[1]].alloc),
- x86_get_regname_mmx(p->vars[insn->dest_args[0]].alloc));
+ orc_x86_get_regname_mmx(p->vars[insn->src_args[1]].alloc),
+ orc_x86_get_regname_mmx(p->vars[insn->dest_args[0]].alloc));
*p->codeptr++ = 0x0f;
*p->codeptr++ = 0xe1;
- x86_emit_modrm_reg (p, p->vars[insn->dest_args[0]].alloc,
+ orc_x86_emit_modrm_reg (p, p->vars[insn->dest_args[0]].alloc,
p->vars[insn->src_args[1]].alloc);
}
}
int sse41 = FALSE;
void
-sse_emit_f20f (OrcCompiler *p, const char *insn_name, int code,
+orc_sse_emit_f20f (OrcCompiler *p, const char *insn_name, int code,
int src, int dest)
{
ORC_ASM_CODE(p," %s %%%s, %%%s\n", insn_name,
- x86_get_regname_sse(src),
- x86_get_regname_sse(dest));
+ orc_x86_get_regname_sse(src),
+ orc_x86_get_regname_sse(dest));
*p->codeptr++ = 0xf2;
- x86_emit_rex (p, 0, dest, 0, src);
+ orc_x86_emit_rex (p, 0, dest, 0, src);
*p->codeptr++ = 0x0f;
*p->codeptr++ = code;
- x86_emit_modrm_reg (p, src, dest);
+ orc_x86_emit_modrm_reg (p, src, dest);
}
void
-sse_emit_660f (OrcCompiler *p, const char *insn_name, int code,
+orc_sse_emit_f30f (OrcCompiler *p, const char *insn_name, int code,
int src, int dest)
{
ORC_ASM_CODE(p," %s %%%s, %%%s\n", insn_name,
- x86_get_regname_sse(src),
- x86_get_regname_sse(dest));
+ orc_x86_get_regname_sse(src),
+ orc_x86_get_regname_sse(dest));
+ *p->codeptr++ = 0xf3;
+ orc_x86_emit_rex (p, 0, dest, 0, src);
+ *p->codeptr++ = 0x0f;
+ *p->codeptr++ = code;
+ orc_x86_emit_modrm_reg (p, src, dest);
+}
+
+void
+orc_sse_emit_0f (OrcCompiler *p, const char *insn_name, int code,
+ int src, int dest)
+{
+ ORC_ASM_CODE(p," %s %%%s, %%%s\n", insn_name,
+ orc_x86_get_regname_sse(src),
+ orc_x86_get_regname_sse(dest));
+ orc_x86_emit_rex (p, 0, dest, 0, src);
+ *p->codeptr++ = 0x0f;
+ *p->codeptr++ = code;
+ orc_x86_emit_modrm_reg (p, src, dest);
+}
+
+void
+orc_sse_emit_660f (OrcCompiler *p, const char *insn_name, int code,
+ int src, int dest)
+{
+ ORC_ASM_CODE(p," %s %%%s, %%%s\n", insn_name,
+ orc_x86_get_regname_sse(src),
+ orc_x86_get_regname_sse(dest));
*p->codeptr++ = 0x66;
- x86_emit_rex (p, 0, dest, 0, src);
+ orc_x86_emit_rex (p, 0, dest, 0, src);
*p->codeptr++ = 0x0f;
*p->codeptr++ = code;
- x86_emit_modrm_reg (p, src, dest);
+ orc_x86_emit_modrm_reg (p, src, dest);
}
void
-sse_emit_660f38 (OrcCompiler *p, const char *insn_name, int code,
+orc_sse_emit_660f38 (OrcCompiler *p, const char *insn_name, int code,
int src, int dest)
{
ORC_ASM_CODE(p," %s %%%s, %%%s\n", insn_name,
- x86_get_regname_sse(src),
- x86_get_regname_sse(dest));
+ orc_x86_get_regname_sse(src),
+ orc_x86_get_regname_sse(dest));
*p->codeptr++ = 0x66;
- x86_emit_rex (p, 0, dest, 0, src);
+ orc_x86_emit_rex (p, 0, dest, 0, src);
*p->codeptr++ = 0x0f;
*p->codeptr++ = 0x38;
*p->codeptr++ = code;
- x86_emit_modrm_reg (p, src, dest);
+ orc_x86_emit_modrm_reg (p, src, dest);
}
/* sse rules */
void
-sse_emit_loadil (OrcCompiler *p, int reg, int value)
+orc_sse_emit_loadil (OrcCompiler *p, int reg, int value)
{
if (value == 0) {
- ORC_ASM_CODE(p," pxor %%%s, %%%s\n", x86_get_regname_sse(reg),
- x86_get_regname_sse(reg));
- x86_emit_rex (p, 0, reg, 0, reg);
+ ORC_ASM_CODE(p," pxor %%%s, %%%s\n", orc_x86_get_regname_sse(reg),
+ orc_x86_get_regname_sse(reg));
+ orc_x86_emit_rex (p, 0, reg, 0, reg);
*p->codeptr++ = 0x0f;
*p->codeptr++ = 0xef;
- x86_emit_modrm_reg (p, reg, reg);
+ orc_x86_emit_modrm_reg (p, reg, reg);
} else {
- x86_emit_mov_imm_reg (p, 4, value, X86_ECX);
+ orc_x86_emit_mov_imm_reg (p, 4, value, X86_ECX);
- ORC_ASM_CODE(p," movd %%ecx, %%%s\n", x86_get_regname_sse(reg));
+ ORC_ASM_CODE(p," movd %%ecx, %%%s\n", orc_x86_get_regname_sse(reg));
*p->codeptr++ = 0x66;
- x86_emit_rex (p, 0, reg, 0, X86_ECX);
+ orc_x86_emit_rex (p, 0, reg, 0, X86_ECX);
*p->codeptr++ = 0x0f;
*p->codeptr++ = 0x6e;
- x86_emit_modrm_reg (p, X86_ECX, reg);
+ orc_x86_emit_modrm_reg (p, X86_ECX, reg);
- ORC_ASM_CODE(p," pshufd $0, %%%s, %%%s\n", x86_get_regname_sse(reg),
- x86_get_regname_sse(reg));
+ ORC_ASM_CODE(p," pshufd $0, %%%s, %%%s\n", orc_x86_get_regname_sse(reg),
+ orc_x86_get_regname_sse(reg));
*p->codeptr++ = 0x66;
- x86_emit_rex (p, 0, reg, 0, reg);
+ orc_x86_emit_rex (p, 0, reg, 0, reg);
*p->codeptr++ = 0x0f;
*p->codeptr++ = 0x70;
- x86_emit_modrm_reg (p, reg, reg);
+ orc_x86_emit_modrm_reg (p, reg, reg);
*p->codeptr++ = 0x00;
}
}
void
-sse_emit_loadib (OrcCompiler *p, int reg, int value)
+orc_sse_emit_loadib (OrcCompiler *p, int reg, int value)
{
value &= 0xff;
value |= (value<<8);
value |= (value<<16);
- sse_emit_loadil (p, reg, value);
+ orc_sse_emit_loadil (p, reg, value);
}
void
-sse_emit_loadiw (OrcCompiler *p, int reg, int value)
+orc_sse_emit_loadiw (OrcCompiler *p, int reg, int value)
{
value &= 0xffff;
value |= (value<<16);
- sse_emit_loadil (p, reg, value);
+ orc_sse_emit_loadil (p, reg, value);
}
void
-sse_emit_loadpb (OrcCompiler *p, int reg, int param)
+orc_sse_emit_loadpb (OrcCompiler *p, int reg, int param)
{
- x86_emit_mov_memoffset_sse (p, 4,
+ orc_x86_emit_mov_memoffset_sse (p, 4,
(int)ORC_STRUCT_OFFSET(OrcExecutor, params[param]),
- x86_exec_ptr, reg, FALSE);
+ p->exec_reg, reg, FALSE);
- sse_emit_660f (p, "punpcklbw", 0x60, reg, reg);
+ orc_sse_emit_660f (p, "punpcklbw", 0x60, reg, reg);
- ORC_ASM_CODE(p," pshuflw $0, %%%s, %%%s\n", x86_get_regname_sse(reg),
- x86_get_regname_sse(reg));
+ ORC_ASM_CODE(p," pshuflw $0, %%%s, %%%s\n", orc_x86_get_regname_sse(reg),
+ orc_x86_get_regname_sse(reg));
*p->codeptr++ = 0xf2;
- x86_emit_rex (p, 0, reg, 0, reg);
+ orc_x86_emit_rex (p, 0, reg, 0, reg);
*p->codeptr++ = 0x0f;
*p->codeptr++ = 0x70;
- x86_emit_modrm_reg (p, reg, reg);
+ orc_x86_emit_modrm_reg (p, reg, reg);
*p->codeptr++ = 0x00;
- ORC_ASM_CODE(p," pshufd $0, %%%s, %%%s\n", x86_get_regname_sse(reg),
- x86_get_regname_sse(reg));
+ ORC_ASM_CODE(p," pshufd $0, %%%s, %%%s\n", orc_x86_get_regname_sse(reg),
+ orc_x86_get_regname_sse(reg));
*p->codeptr++ = 0x66;
- x86_emit_rex (p, 0, reg, 0, reg);
+ orc_x86_emit_rex (p, 0, reg, 0, reg);
*p->codeptr++ = 0x0f;
*p->codeptr++ = 0x70;
- x86_emit_modrm_reg (p, reg, reg);
+ orc_x86_emit_modrm_reg (p, reg, reg);
*p->codeptr++ = 0x00;
}
void
-sse_emit_loadpw (OrcCompiler *p, int reg, int param)
+orc_sse_emit_loadpw (OrcCompiler *p, int reg, int param)
{
- x86_emit_mov_memoffset_sse (p, 4,
+ orc_x86_emit_mov_memoffset_sse (p, 4,
(int)ORC_STRUCT_OFFSET(OrcExecutor, params[param]),
- x86_exec_ptr, reg, FALSE);
+ p->exec_reg, reg, FALSE);
- ORC_ASM_CODE(p," pshuflw $0, %%%s, %%%s\n", x86_get_regname_sse(reg),
- x86_get_regname_sse(reg));
+ ORC_ASM_CODE(p," pshuflw $0, %%%s, %%%s\n", orc_x86_get_regname_sse(reg),
+ orc_x86_get_regname_sse(reg));
*p->codeptr++ = 0xf2;
- x86_emit_rex (p, 0, reg, 0, reg);
+ orc_x86_emit_rex (p, 0, reg, 0, reg);
*p->codeptr++ = 0x0f;
*p->codeptr++ = 0x70;
- x86_emit_modrm_reg (p, reg, reg);
+ orc_x86_emit_modrm_reg (p, reg, reg);
*p->codeptr++ = 0x00;
- ORC_ASM_CODE(p," pshufd $0, %%%s, %%%s\n", x86_get_regname_sse(reg),
- x86_get_regname_sse(reg));
+ ORC_ASM_CODE(p," pshufd $0, %%%s, %%%s\n", orc_x86_get_regname_sse(reg),
+ orc_x86_get_regname_sse(reg));
*p->codeptr++ = 0x66;
- x86_emit_rex (p, 0, reg, 0, reg);
+ orc_x86_emit_rex (p, 0, reg, 0, reg);
*p->codeptr++ = 0x0f;
*p->codeptr++ = 0x70;
- x86_emit_modrm_reg (p, reg, reg);
+ orc_x86_emit_modrm_reg (p, reg, reg);
*p->codeptr++ = 0x00;
}
void
-sse_emit_loadpl (OrcCompiler *p, int reg, int param)
+orc_sse_emit_loadpl (OrcCompiler *p, int reg, int param)
{
- x86_emit_mov_memoffset_sse (p, 4,
+ orc_x86_emit_mov_memoffset_sse (p, 4,
(int)ORC_STRUCT_OFFSET(OrcExecutor, params[param]),
- x86_exec_ptr, reg, FALSE);
+ p->exec_reg, reg, FALSE);
- ORC_ASM_CODE(p," pshufd $0, %%%s, %%%s\n", x86_get_regname_sse(reg),
- x86_get_regname_sse(reg));
+ ORC_ASM_CODE(p," pshufd $0, %%%s, %%%s\n", orc_x86_get_regname_sse(reg),
+ orc_x86_get_regname_sse(reg));
*p->codeptr++ = 0x66;
- x86_emit_rex (p, 0, reg, 0, reg);
+ orc_x86_emit_rex (p, 0, reg, 0, reg);
*p->codeptr++ = 0x0f;
*p->codeptr++ = 0x70;
- x86_emit_modrm_reg (p, reg, reg);
+ orc_x86_emit_modrm_reg (p, reg, reg);
*p->codeptr++ = 0x00;
}
void
-sse_emit_loadpq (OrcCompiler *p, int reg, int param)
+orc_sse_emit_loadpq (OrcCompiler *p, int reg, int param)
{
- x86_emit_mov_memoffset_sse (p, 8,
+ orc_x86_emit_mov_memoffset_sse (p, 8,
(int)ORC_STRUCT_OFFSET(OrcExecutor, params[param]),
- x86_exec_ptr, reg, FALSE);
+ p->exec_reg, reg, FALSE);
- ORC_ASM_CODE(p," pshufd $0, %%%s, %%%s\n", x86_get_regname_sse(reg),
- x86_get_regname_sse(reg));
+ ORC_ASM_CODE(p," pshufd $0, %%%s, %%%s\n", orc_x86_get_regname_sse(reg),
+ orc_x86_get_regname_sse(reg));
*p->codeptr++ = 0x66;
- x86_emit_rex (p, 0, reg, 0, reg);
+ orc_x86_emit_rex (p, 0, reg, 0, reg);
*p->codeptr++ = 0x0f;
*p->codeptr++ = 0x70;
- x86_emit_modrm_reg (p, reg, reg);
+ orc_x86_emit_modrm_reg (p, reg, reg);
*p->codeptr++ = 0x00;
}
static void
sse_rule_copyx (OrcCompiler *p, void *user, OrcInstruction *insn)
{
- sse_emit_660f (p, "movdqa", 0x6f,
+ orc_sse_emit_660f (p, "movdqa", 0x6f,
p->vars[insn->src_args[0]].alloc,
p->vars[insn->dest_args[0]].alloc);
}
static void
-sse_emit_66_rex_0f (OrcCompiler *p, OrcInstruction *insn, int code,
+orc_sse_emit_66_rex_0f (OrcCompiler *p, OrcInstruction *insn, int code,
const char *insn_name, int src, int dest)
{
ORC_ASM_CODE(p," %s %%%s, %%%s\n", insn_name,
- x86_get_regname_sse(src), x86_get_regname_sse(dest));
+ orc_x86_get_regname_sse(src), orc_x86_get_regname_sse(dest));
*p->codeptr++ = 0x66;
- x86_emit_rex (p, 0, dest, 0, src);
+ orc_x86_emit_rex (p, 0, dest, 0, src);
*p->codeptr++ = 0x0f;
if (code & 0xff00) {
*p->codeptr++ = code >> 8;
} else {
*p->codeptr++ = code;
}
- x86_emit_modrm_reg (p, src, dest);
+ orc_x86_emit_modrm_reg (p, src, dest);
}
#define UNARY(opcode,insn_name,code) \
static void \
sse_rule_ ## opcode (OrcCompiler *p, void *user, OrcInstruction *insn) \
{ \
- sse_emit_66_rex_0f (p, insn, code, insn_name, \
+ orc_sse_emit_66_rex_0f (p, insn, code, insn_name, \
p->vars[insn->src_args[0]].alloc, \
p->vars[insn->dest_args[0]].alloc); \
}
static void \
sse_rule_ ## opcode (OrcCompiler *p, void *user, OrcInstruction *insn) \
{ \
- sse_emit_66_rex_0f (p, insn, code, insn_name, \
+ orc_sse_emit_66_rex_0f (p, insn, code, insn_name, \
p->vars[insn->src_args[1]].alloc, \
p->vars[insn->dest_args[0]].alloc); \
}
int src = p->vars[insn->src_args[0]].alloc;
int dest = p->vars[insn->dest_args[0]].alloc;
- sse_emit_660f (p, "paddw", 0xfd, src, dest);
+ orc_sse_emit_660f (p, "paddw", 0xfd, src, dest);
}
static void
int src = p->vars[insn->src_args[0]].alloc;
int dest = p->vars[insn->dest_args[0]].alloc;
- sse_emit_660f (p, "paddd", 0xfe, src, dest);
+ orc_sse_emit_660f (p, "paddd", 0xfe, src, dest);
}
static void
int src2 = p->vars[insn->src_args[1]].alloc;
int dest = p->vars[insn->dest_args[0]].alloc;
- sse_emit_660f (p, "movdqa", 0x6f, src1, p->tmpreg);
- sse_emit_660f (p, "psadbw", 0xf6, src2, p->tmpreg);
- sse_emit_660f (p, "paddd", 0xfe, p->tmpreg, dest);
+ orc_sse_emit_660f (p, "movdqa", 0x6f, src1, p->tmpreg);
+ orc_sse_emit_660f (p, "psadbw", 0xf6, src2, p->tmpreg);
+ orc_sse_emit_660f (p, "paddd", 0xfe, p->tmpreg, dest);
#if 0
- ORC_ASM_CODE(p," movd %%%s, %%ecx\n", x86_get_regname_sse(dest));
+ ORC_ASM_CODE(p," movd %%%s, %%ecx\n", orc_x86_get_regname_sse(dest));
*p->codeptr++ = 0x66;
- x86_emit_rex (p, 0, dest, 0, X86_ECX);
+ orc_x86_emit_rex (p, 0, dest, 0, X86_ECX);
*p->codeptr++ = 0x0f;
*p->codeptr++ = 0x7e;
- x86_emit_modrm_reg (p, X86_ECX, dest);
+ orc_x86_emit_modrm_reg (p, X86_ECX, dest);
- x86_emit_add_reg_memoffset (p, 4, X86_ECX,
+ orc_x86_emit_add_reg_memoffset (p, 4, X86_ECX,
(int)ORC_STRUCT_OFFSET(OrcExecutor, accumulators[0]),
- x86_exec_ptr);
+ p->exec_reg);
if (p->loop_shift > 3) {
- ORC_ASM_CODE(p," psrldq $8, %%%s\n", x86_get_regname_sse(dest));
+ ORC_ASM_CODE(p," psrldq $8, %%%s\n", orc_x86_get_regname_sse(dest));
*p->codeptr++ = 0x66;
- x86_emit_rex (p, 0, 0, 0, dest);
+ orc_x86_emit_rex (p, 0, 0, 0, dest);
*p->codeptr++ = 0x0f;
*p->codeptr++ = 0x73;
- x86_emit_modrm_reg (p, dest, 3);
+ orc_x86_emit_modrm_reg (p, dest, 3);
*p->codeptr++ = 0x08;
- ORC_ASM_CODE(p," movd %%%s, %%ecx\n", x86_get_regname_sse(dest));
+ ORC_ASM_CODE(p," movd %%%s, %%ecx\n", orc_x86_get_regname_sse(dest));
*p->codeptr++ = 0x66;
- x86_emit_rex (p, 0, dest, 0, X86_ECX);
+ orc_x86_emit_rex (p, 0, dest, 0, X86_ECX);
*p->codeptr++ = 0x0f;
*p->codeptr++ = 0x7e;
- x86_emit_modrm_reg (p, X86_ECX, dest);
+ orc_x86_emit_modrm_reg (p, X86_ECX, dest);
- x86_emit_add_reg_memoffset (p, 4, X86_ECX,
+ orc_x86_emit_add_reg_memoffset (p, 4, X86_ECX,
(int)ORC_STRUCT_OFFSET(OrcExecutor, accumulators[0]),
- x86_exec_ptr);
+ p->exec_reg);
}
#endif
int codes[] = { 0x08, 0x09, 0x0a };
if (src == dest) {
- sse_emit_660f (p, "movdqa", 0x6f, src, p->tmpreg);
+ orc_sse_emit_660f (p, "movdqa", 0x6f, src, p->tmpreg);
src = p->tmpreg;
}
- x86_emit_mov_imm_reg (p, 4, imm_vals[ORC_PTR_TO_INT(user)], X86_ECX);
+ orc_x86_emit_mov_imm_reg (p, 4, imm_vals[ORC_PTR_TO_INT(user)], X86_ECX);
- ORC_ASM_CODE(p," movd %%ecx, %%%s\n", x86_get_regname_sse(dest));
+ ORC_ASM_CODE(p," movd %%ecx, %%%s\n", orc_x86_get_regname_sse(dest));
*p->codeptr++ = 0x66;
- x86_emit_rex (p, 0, dest, 0, X86_ECX);
+ orc_x86_emit_rex (p, 0, dest, 0, X86_ECX);
*p->codeptr++ = 0x0f;
*p->codeptr++ = 0x6e;
- x86_emit_modrm_reg (p, X86_ECX, dest);
+ orc_x86_emit_modrm_reg (p, X86_ECX, dest);
- ORC_ASM_CODE(p," pshufd $0, %%%s, %%%s\n", x86_get_regname_sse(dest),
- x86_get_regname_sse(dest));
+ ORC_ASM_CODE(p," pshufd $0, %%%s, %%%s\n", orc_x86_get_regname_sse(dest),
+ orc_x86_get_regname_sse(dest));
*p->codeptr++ = 0x66;
- x86_emit_rex (p, 0, dest, 0, dest);
+ orc_x86_emit_rex (p, 0, dest, 0, dest);
*p->codeptr++ = 0x0f;
*p->codeptr++ = 0x70;
- x86_emit_modrm_reg (p, dest, dest);
+ orc_x86_emit_modrm_reg (p, dest, dest);
*p->codeptr++ = 0x00;
- sse_emit_660f38 (p, names[ORC_PTR_TO_INT(user)], codes[ORC_PTR_TO_INT(user)], src, dest);
+ orc_sse_emit_660f38 (p, names[ORC_PTR_TO_INT(user)], codes[ORC_PTR_TO_INT(user)], src, dest);
}
static void
if (p->vars[insn->src_args[1]].vartype == ORC_VAR_TYPE_CONST) {
ORC_ASM_CODE(p," %s $%d, %%%s\n", code[type],
p->vars[insn->src_args[1]].value,
- x86_get_regname_sse(p->vars[insn->dest_args[0]].alloc));
+ orc_x86_get_regname_sse(p->vars[insn->dest_args[0]].alloc));
*p->codeptr++ = 0x66;
- x86_emit_rex (p, 0, 0, 0, p->vars[insn->dest_args[0]].alloc);
+ orc_x86_emit_rex (p, 0, 0, 0, p->vars[insn->dest_args[0]].alloc);
*p->codeptr++ = 0x0f;
*p->codeptr++ = imm_code1[type];
- x86_emit_modrm_reg (p, p->vars[insn->dest_args[0]].alloc, imm_code2[type]);
+ orc_x86_emit_modrm_reg (p, p->vars[insn->dest_args[0]].alloc, imm_code2[type]);
*p->codeptr++ = p->vars[insn->src_args[1]].value;
} else if (p->vars[insn->src_args[1]].vartype == ORC_VAR_TYPE_PARAM) {
/* FIXME this is a gross hack to reload the register with a
* 64-bit version of the parameter. */
- x86_emit_mov_memoffset_sse (p, 4,
+ orc_x86_emit_mov_memoffset_sse (p, 4,
(int)ORC_STRUCT_OFFSET(OrcExecutor, params[insn->src_args[1]]),
- x86_exec_ptr, p->tmpreg, FALSE);
+ p->exec_reg, p->tmpreg, FALSE);
ORC_ASM_CODE(p," %s %%%s, %%%s\n", code[type],
- x86_get_regname_sse(p->tmpreg),
- x86_get_regname_sse(p->vars[insn->dest_args[0]].alloc));
+ orc_x86_get_regname_sse(p->tmpreg),
+ orc_x86_get_regname_sse(p->vars[insn->dest_args[0]].alloc));
*p->codeptr++ = 0x66;
- x86_emit_rex (p, 0, p->vars[insn->dest_args[0]].alloc, 0, p->tmpreg);
+ orc_x86_emit_rex (p, 0, p->vars[insn->dest_args[0]].alloc, 0, p->tmpreg);
*p->codeptr++ = 0x0f;
*p->codeptr++ = reg_code[type];
- x86_emit_modrm_reg (p, p->tmpreg, p->vars[insn->dest_args[0]].alloc);
+ orc_x86_emit_modrm_reg (p, p->tmpreg, p->vars[insn->dest_args[0]].alloc);
} else {
ORC_PROGRAM_ERROR(p,"rule only works with constants or params");
}
static void
sse_rule_convsbw (OrcCompiler *p, void *user, OrcInstruction *insn)
{
- sse_emit_660f (p, "punpcklbw", 0x60,
+ orc_sse_emit_660f (p, "punpcklbw", 0x60,
p->vars[insn->src_args[0]].alloc,
p->vars[insn->dest_args[0]].alloc);
ORC_ASM_CODE(p," psraw $8, %%%s\n",
- x86_get_regname_sse(p->vars[insn->dest_args[0]].alloc));
+ orc_x86_get_regname_sse(p->vars[insn->dest_args[0]].alloc));
*p->codeptr++ = 0x66;
- x86_emit_rex (p, 0, 0, 0, p->vars[insn->dest_args[0]].alloc);
+ orc_x86_emit_rex (p, 0, 0, 0, p->vars[insn->dest_args[0]].alloc);
*p->codeptr++ = 0x0f;
*p->codeptr++ = 0x71;
- x86_emit_modrm_reg (p, p->vars[insn->dest_args[0]].alloc, 4);
+ orc_x86_emit_modrm_reg (p, p->vars[insn->dest_args[0]].alloc, 4);
*p->codeptr++ = 8;
}
{
/* FIXME should do this by unpacking with a zero reg */
- sse_emit_660f (p, "punpcklbw", 0x60,
+ orc_sse_emit_660f (p, "punpcklbw", 0x60,
p->vars[insn->src_args[0]].alloc,
p->vars[insn->dest_args[0]].alloc);
ORC_ASM_CODE(p," psrlw $8, %%%s\n",
- x86_get_regname_sse(p->vars[insn->dest_args[0]].alloc));
+ orc_x86_get_regname_sse(p->vars[insn->dest_args[0]].alloc));
*p->codeptr++ = 0x66;
- x86_emit_rex (p, 0, 0, 0, p->vars[insn->dest_args[0]].alloc);
+ orc_x86_emit_rex (p, 0, 0, 0, p->vars[insn->dest_args[0]].alloc);
*p->codeptr++ = 0x0f;
*p->codeptr++ = 0x71;
- x86_emit_modrm_reg (p, p->vars[insn->dest_args[0]].alloc, 2);
+ orc_x86_emit_modrm_reg (p, p->vars[insn->dest_args[0]].alloc, 2);
*p->codeptr++ = 8;
}
static void
sse_rule_convssswb (OrcCompiler *p, void *user, OrcInstruction *insn)
{
- sse_emit_660f (p, "packsswb", 0x63,
+ orc_sse_emit_660f (p, "packsswb", 0x63,
p->vars[insn->src_args[0]].alloc,
p->vars[insn->dest_args[0]].alloc);
}
static void
sse_rule_convsuswb (OrcCompiler *p, void *user, OrcInstruction *insn)
{
- sse_emit_660f (p, "packuswb", 0x67,
+ orc_sse_emit_660f (p, "packuswb", 0x67,
p->vars[insn->src_args[0]].alloc,
p->vars[insn->dest_args[0]].alloc);
}
/* FIXME slow */
if (dest != src) {
- sse_emit_660f (p, "movdqa", 0x6f, src, dest);
+ orc_sse_emit_660f (p, "movdqa", 0x6f, src, dest);
}
ORC_ASM_CODE(p," psllw $8, %%%s\n",
- x86_get_regname_sse(p->vars[insn->dest_args[0]].alloc));
+ orc_x86_get_regname_sse(p->vars[insn->dest_args[0]].alloc));
*p->codeptr++ = 0x66;
- x86_emit_rex (p, 0, 0, 0, p->vars[insn->dest_args[0]].alloc);
+ orc_x86_emit_rex (p, 0, 0, 0, p->vars[insn->dest_args[0]].alloc);
*p->codeptr++ = 0x0f;
*p->codeptr++ = 0x71;
- x86_emit_modrm_reg (p, p->vars[insn->dest_args[0]].alloc, 6);
+ orc_x86_emit_modrm_reg (p, p->vars[insn->dest_args[0]].alloc, 6);
*p->codeptr++ = 8;
ORC_ASM_CODE(p," psrlw $8, %%%s\n",
- x86_get_regname_sse(p->vars[insn->dest_args[0]].alloc));
+ orc_x86_get_regname_sse(p->vars[insn->dest_args[0]].alloc));
*p->codeptr++ = 0x66;
- x86_emit_rex (p, 0, 0, 0, p->vars[insn->dest_args[0]].alloc);
+ orc_x86_emit_rex (p, 0, 0, 0, p->vars[insn->dest_args[0]].alloc);
*p->codeptr++ = 0x0f;
*p->codeptr++ = 0x71;
- x86_emit_modrm_reg (p, p->vars[insn->dest_args[0]].alloc, 2);
+ orc_x86_emit_modrm_reg (p, p->vars[insn->dest_args[0]].alloc, 2);
*p->codeptr++ = 8;
- sse_emit_660f (p, "packuswb", 0x67,
+ orc_sse_emit_660f (p, "packuswb", 0x67,
p->vars[insn->dest_args[0]].alloc,
p->vars[insn->dest_args[0]].alloc);
}
static void
sse_rule_convswl (OrcCompiler *p, void *user, OrcInstruction *insn)
{
- sse_emit_660f (p, "punpcklwd", 0x61,
+ orc_sse_emit_660f (p, "punpcklwd", 0x61,
p->vars[insn->src_args[0]].alloc,
p->vars[insn->dest_args[0]].alloc);
ORC_ASM_CODE(p," psrad $16, %%%s\n",
- x86_get_regname_sse(p->vars[insn->dest_args[0]].alloc));
+ orc_x86_get_regname_sse(p->vars[insn->dest_args[0]].alloc));
*p->codeptr++ = 0x66;
- x86_emit_rex (p, 0, 0, 0, p->vars[insn->dest_args[0]].alloc);
+ orc_x86_emit_rex (p, 0, 0, 0, p->vars[insn->dest_args[0]].alloc);
*p->codeptr++ = 0x0f;
*p->codeptr++ = 0x72;
- x86_emit_modrm_reg (p, p->vars[insn->dest_args[0]].alloc, 4);
+ orc_x86_emit_modrm_reg (p, p->vars[insn->dest_args[0]].alloc, 4);
*p->codeptr++ = 16;
}
{
/* FIXME should do this by unpacking with a zero reg */
- sse_emit_660f (p, "punpcklwd", 0x61,
+ orc_sse_emit_660f (p, "punpcklwd", 0x61,
p->vars[insn->src_args[0]].alloc,
p->vars[insn->dest_args[0]].alloc);
ORC_ASM_CODE(p," psrld $16, %%%s\n",
- x86_get_regname_sse(p->vars[insn->dest_args[0]].alloc));
+ orc_x86_get_regname_sse(p->vars[insn->dest_args[0]].alloc));
*p->codeptr++ = 0x66;
- x86_emit_rex (p, 0, 0, 0, p->vars[insn->dest_args[0]].alloc);
+ orc_x86_emit_rex (p, 0, 0, 0, p->vars[insn->dest_args[0]].alloc);
*p->codeptr++ = 0x0f;
*p->codeptr++ = 0x72;
- x86_emit_modrm_reg (p, p->vars[insn->dest_args[0]].alloc, 2);
+ orc_x86_emit_modrm_reg (p, p->vars[insn->dest_args[0]].alloc, 2);
*p->codeptr++ = 16;
}
/* FIXME slow */
if (dest != src) {
- sse_emit_660f (p, "movdqa", 0x6f, src, dest);
+ orc_sse_emit_660f (p, "movdqa", 0x6f, src, dest);
}
ORC_ASM_CODE(p," pslld $16, %%%s\n",
- x86_get_regname_sse(p->vars[insn->dest_args[0]].alloc));
+ orc_x86_get_regname_sse(p->vars[insn->dest_args[0]].alloc));
*p->codeptr++ = 0x66;
- x86_emit_rex (p, 0, 0, 0, p->vars[insn->dest_args[0]].alloc);
+ orc_x86_emit_rex (p, 0, 0, 0, p->vars[insn->dest_args[0]].alloc);
*p->codeptr++ = 0x0f;
*p->codeptr++ = 0x72;
- x86_emit_modrm_reg (p, p->vars[insn->dest_args[0]].alloc, 6);
+ orc_x86_emit_modrm_reg (p, p->vars[insn->dest_args[0]].alloc, 6);
*p->codeptr++ = 16;
ORC_ASM_CODE(p," psrad $16, %%%s\n",
- x86_get_regname_sse(p->vars[insn->dest_args[0]].alloc));
+ orc_x86_get_regname_sse(p->vars[insn->dest_args[0]].alloc));
*p->codeptr++ = 0x66;
- x86_emit_rex (p, 0, 0, 0, p->vars[insn->dest_args[0]].alloc);
+ orc_x86_emit_rex (p, 0, 0, 0, p->vars[insn->dest_args[0]].alloc);
*p->codeptr++ = 0x0f;
*p->codeptr++ = 0x72;
- x86_emit_modrm_reg (p, p->vars[insn->dest_args[0]].alloc, 4);
+ orc_x86_emit_modrm_reg (p, p->vars[insn->dest_args[0]].alloc, 4);
*p->codeptr++ = 16;
- sse_emit_660f (p, "packssdw", 0x6b, dest, dest);
+ orc_sse_emit_660f (p, "packssdw", 0x6b, dest, dest);
}
static void
sse_rule_convssslw (OrcCompiler *p, void *user, OrcInstruction *insn)
{
- sse_emit_660f (p, "packssdw", 0x6b,
+ orc_sse_emit_660f (p, "packssdw", 0x6b,
p->vars[insn->src_args[0]].alloc,
p->vars[insn->dest_args[0]].alloc);
}
static void
sse_rule_convsuslw (OrcCompiler *p, void *user, OrcInstruction *insn)
{
- sse_emit_660f38 (p, "packusdw", 0x2b,
+ orc_sse_emit_660f38 (p, "packusdw", 0x2b,
p->vars[insn->src_args[0]].alloc,
p->vars[insn->dest_args[0]].alloc);
}
int dest = p->vars[insn->dest_args[0]].alloc;
int tmp = p->tmpreg;
- sse_emit_660f (p, "movdqa", 0x6f, dest, tmp);
- sse_emit_660f (p, "pmulhw", 0xe5, src, tmp);
- sse_emit_660f (p, "pmullw", 0xd5, src, dest);
- sse_emit_660f (p, "punpcklwd", 0x61, tmp, dest);
+ orc_sse_emit_660f (p, "movdqa", 0x6f, dest, tmp);
+ orc_sse_emit_660f (p, "pmulhw", 0xe5, src, tmp);
+ orc_sse_emit_660f (p, "pmullw", 0xd5, src, dest);
+ orc_sse_emit_660f (p, "punpcklwd", 0x61, tmp, dest);
}
static void
int dest = p->vars[insn->dest_args[0]].alloc;
int tmp = p->tmpreg;
- x86_emit_mov_imm_reg (p, 4, 0x80008000, X86_ECX);
+ orc_x86_emit_mov_imm_reg (p, 4, 0x80008000, X86_ECX);
- ORC_ASM_CODE(p," movd %%ecx, %%%s\n", x86_get_regname_sse(tmp));
+ ORC_ASM_CODE(p," movd %%ecx, %%%s\n", orc_x86_get_regname_sse(tmp));
*p->codeptr++ = 0x66;
- x86_emit_rex (p, 0, tmp, 0, X86_ECX);
+ orc_x86_emit_rex (p, 0, tmp, 0, X86_ECX);
*p->codeptr++ = 0x0f;
*p->codeptr++ = 0x6e;
- x86_emit_modrm_reg (p, X86_ECX, tmp);
+ orc_x86_emit_modrm_reg (p, X86_ECX, tmp);
- ORC_ASM_CODE(p," pshufd $0, %%%s, %%%s\n", x86_get_regname_sse(tmp),
- x86_get_regname_sse(tmp));
+ ORC_ASM_CODE(p," pshufd $0, %%%s, %%%s\n", orc_x86_get_regname_sse(tmp),
+ orc_x86_get_regname_sse(tmp));
*p->codeptr++ = 0x66;
- x86_emit_rex (p, 0, tmp, 0, tmp);
+ orc_x86_emit_rex (p, 0, tmp, 0, tmp);
*p->codeptr++ = 0x0f;
*p->codeptr++ = 0x70;
- x86_emit_modrm_reg (p, tmp, tmp);
+ orc_x86_emit_modrm_reg (p, tmp, tmp);
*p->codeptr++ = 0x00;
- sse_emit_660f (p, "pxor", 0xef, tmp, src);
- sse_emit_660f (p, "pxor", 0xef, tmp, dest);
- sse_emit_660f (p, "pmaxsw", 0xee, src, dest);
- sse_emit_660f (p, "pxor", 0xef, tmp, src);
- sse_emit_660f (p, "pxor", 0xef, tmp, dest);
+ orc_sse_emit_660f (p, "pxor", 0xef, tmp, src);
+ orc_sse_emit_660f (p, "pxor", 0xef, tmp, dest);
+ orc_sse_emit_660f (p, "pmaxsw", 0xee, src, dest);
+ orc_sse_emit_660f (p, "pxor", 0xef, tmp, src);
+ orc_sse_emit_660f (p, "pxor", 0xef, tmp, dest);
}
static void
int dest = p->vars[insn->dest_args[0]].alloc;
int tmp = p->tmpreg;
- sse_emit_loadib (p, tmp, 0x80);
+ orc_sse_emit_loadib (p, tmp, 0x80);
- sse_emit_660f (p, "pxor", 0xef, tmp, src);
- sse_emit_660f (p, "pxor", 0xef, tmp, dest);
- sse_emit_660f (p, "pminsw", 0xea, src, dest);
- sse_emit_660f (p, "pxor", 0xef, tmp, src);
- sse_emit_660f (p, "pxor", 0xef, tmp, dest);
+ orc_sse_emit_660f (p, "pxor", 0xef, tmp, src);
+ orc_sse_emit_660f (p, "pxor", 0xef, tmp, dest);
+ orc_sse_emit_660f (p, "pminsw", 0xea, src, dest);
+ orc_sse_emit_660f (p, "pxor", 0xef, tmp, src);
+ orc_sse_emit_660f (p, "pxor", 0xef, tmp, dest);
}
static void
int dest = p->vars[insn->dest_args[0]].alloc;
int tmp = p->tmpreg;
- sse_emit_loadib (p, tmp, 0x80);
+ orc_sse_emit_loadib (p, tmp, 0x80);
- sse_emit_660f (p, "pxor", 0xef, tmp, src);
- sse_emit_660f (p, "pxor", 0xef, tmp, dest);
- sse_emit_660f (p, "pavgb", 0xe0, src, dest);
- sse_emit_660f (p, "pxor", 0xef, tmp, src);
- sse_emit_660f (p, "pxor", 0xef, tmp, dest);
+ orc_sse_emit_660f (p, "pxor", 0xef, tmp, src);
+ orc_sse_emit_660f (p, "pxor", 0xef, tmp, dest);
+ orc_sse_emit_660f (p, "pavgb", 0xe0, src, dest);
+ orc_sse_emit_660f (p, "pxor", 0xef, tmp, src);
+ orc_sse_emit_660f (p, "pxor", 0xef, tmp, dest);
}
static void
int dest = p->vars[insn->dest_args[0]].alloc;
int tmp = p->tmpreg;
- sse_emit_loadiw (p, tmp, 0x8000);
+ orc_sse_emit_loadiw (p, tmp, 0x8000);
- sse_emit_660f (p, "pxor", 0xef, tmp, src);
- sse_emit_660f (p, "pxor", 0xef, tmp, dest);
- sse_emit_660f (p, "pavgw", 0xe3, src, dest);
- sse_emit_660f (p, "pxor", 0xef, tmp, src);
- sse_emit_660f (p, "pxor", 0xef, tmp, dest);
+ orc_sse_emit_660f (p, "pxor", 0xef, tmp, src);
+ orc_sse_emit_660f (p, "pxor", 0xef, tmp, dest);
+ orc_sse_emit_660f (p, "pavgw", 0xe3, src, dest);
+ orc_sse_emit_660f (p, "pxor", 0xef, tmp, src);
+ orc_sse_emit_660f (p, "pxor", 0xef, tmp, dest);
}
static void
int dest = p->vars[insn->dest_args[0]].alloc;
int tmp = p->tmpreg;
- sse_emit_660f (p, "movdqa", 0x6f, dest, tmp);
- sse_emit_660f (p, "pcmpgtb", 0x64, src, tmp);
- sse_emit_660f (p, "pand", 0xdb, tmp, dest);
- sse_emit_660f (p, "pandn", 0xdf, src, tmp);
- sse_emit_660f (p, "por", 0xeb, tmp, dest);
+ orc_sse_emit_660f (p, "movdqa", 0x6f, dest, tmp);
+ orc_sse_emit_660f (p, "pcmpgtb", 0x64, src, tmp);
+ orc_sse_emit_660f (p, "pand", 0xdb, tmp, dest);
+ orc_sse_emit_660f (p, "pandn", 0xdf, src, tmp);
+ orc_sse_emit_660f (p, "por", 0xeb, tmp, dest);
}
static void
int dest = p->vars[insn->dest_args[0]].alloc;
int tmp = p->tmpreg;
- sse_emit_660f (p, "movdqa", 0x6f, src, tmp);
- sse_emit_660f (p, "pcmpgtb", 0x64, dest, tmp);
- sse_emit_660f (p, "pand", 0xdb, tmp, dest);
- sse_emit_660f (p, "pandn", 0xdf, src, tmp);
- sse_emit_660f (p, "por", 0xeb, tmp, dest);
+ orc_sse_emit_660f (p, "movdqa", 0x6f, src, tmp);
+ orc_sse_emit_660f (p, "pcmpgtb", 0x64, dest, tmp);
+ orc_sse_emit_660f (p, "pand", 0xdb, tmp, dest);
+ orc_sse_emit_660f (p, "pandn", 0xdf, src, tmp);
+ orc_sse_emit_660f (p, "por", 0xeb, tmp, dest);
}
static void
int dest = p->vars[insn->dest_args[0]].alloc;
int tmp = p->tmpreg;
- sse_emit_660f (p, "movdqa", 0x6f, dest, tmp);
- sse_emit_660f (p, "pcmpgtd", 0x66, src, tmp);
- sse_emit_660f (p, "pand", 0xdb, tmp, dest);
- sse_emit_660f (p, "pandn", 0xdf, src, tmp);
- sse_emit_660f (p, "por", 0xeb, tmp, dest);
+ orc_sse_emit_660f (p, "movdqa", 0x6f, dest, tmp);
+ orc_sse_emit_660f (p, "pcmpgtd", 0x66, src, tmp);
+ orc_sse_emit_660f (p, "pand", 0xdb, tmp, dest);
+ orc_sse_emit_660f (p, "pandn", 0xdf, src, tmp);
+ orc_sse_emit_660f (p, "por", 0xeb, tmp, dest);
}
static void
int dest = p->vars[insn->dest_args[0]].alloc;
int tmp = p->tmpreg;
- sse_emit_660f (p, "movdqa", 0x6f, src, tmp);
- sse_emit_660f (p, "pcmpgtd", 0x66, dest, tmp);
- sse_emit_660f (p, "pand", 0xdb, tmp, dest);
- sse_emit_660f (p, "pandn", 0xdf, src, tmp);
- sse_emit_660f (p, "por", 0xeb, tmp, dest);
+ orc_sse_emit_660f (p, "movdqa", 0x6f, src, tmp);
+ orc_sse_emit_660f (p, "pcmpgtd", 0x66, dest, tmp);
+ orc_sse_emit_660f (p, "pand", 0xdb, tmp, dest);
+ orc_sse_emit_660f (p, "pandn", 0xdf, src, tmp);
+ orc_sse_emit_660f (p, "por", 0xeb, tmp, dest);
}
static void
int dest = p->vars[insn->dest_args[0]].alloc;
int tmp = p->tmpreg;
- sse_emit_loadil (p, tmp, 0x80000000);
- sse_emit_660f (p, "pxor", 0xef, tmp, src);
- sse_emit_660f (p, "pxor", 0xef, tmp, dest);
+ orc_sse_emit_loadil (p, tmp, 0x80000000);
+ orc_sse_emit_660f (p, "pxor", 0xef, tmp, src);
+ orc_sse_emit_660f (p, "pxor", 0xef, tmp, dest);
- sse_emit_660f (p, "movdqa", 0x6f, dest, tmp);
- sse_emit_660f (p, "pcmpgtd", 0x66, src, tmp);
- sse_emit_660f (p, "pand", 0xdb, tmp, dest);
- sse_emit_660f (p, "pandn", 0xdf, src, tmp);
- sse_emit_660f (p, "por", 0xeb, tmp, dest);
+ orc_sse_emit_660f (p, "movdqa", 0x6f, dest, tmp);
+ orc_sse_emit_660f (p, "pcmpgtd", 0x66, src, tmp);
+ orc_sse_emit_660f (p, "pand", 0xdb, tmp, dest);
+ orc_sse_emit_660f (p, "pandn", 0xdf, src, tmp);
+ orc_sse_emit_660f (p, "por", 0xeb, tmp, dest);
- sse_emit_loadil (p, tmp, 0x80000000);
- sse_emit_660f (p, "pxor", 0xef, tmp, src);
- sse_emit_660f (p, "pxor", 0xef, tmp, dest);
+ orc_sse_emit_loadil (p, tmp, 0x80000000);
+ orc_sse_emit_660f (p, "pxor", 0xef, tmp, src);
+ orc_sse_emit_660f (p, "pxor", 0xef, tmp, dest);
}
static void
int dest = p->vars[insn->dest_args[0]].alloc;
int tmp = p->tmpreg;
- sse_emit_loadil (p, tmp, 0x80000000);
- sse_emit_660f (p, "pxor", 0xef, tmp, src);
- sse_emit_660f (p, "pxor", 0xef, tmp, dest);
+ orc_sse_emit_loadil (p, tmp, 0x80000000);
+ orc_sse_emit_660f (p, "pxor", 0xef, tmp, src);
+ orc_sse_emit_660f (p, "pxor", 0xef, tmp, dest);
- sse_emit_660f (p, "movdqa", 0x6f, src, tmp);
- sse_emit_660f (p, "pcmpgtd", 0x66, dest, tmp);
- sse_emit_660f (p, "pand", 0xdb, tmp, dest);
- sse_emit_660f (p, "pandn", 0xdf, src, tmp);
- sse_emit_660f (p, "por", 0xeb, tmp, dest);
+ orc_sse_emit_660f (p, "movdqa", 0x6f, src, tmp);
+ orc_sse_emit_660f (p, "pcmpgtd", 0x66, dest, tmp);
+ orc_sse_emit_660f (p, "pand", 0xdb, tmp, dest);
+ orc_sse_emit_660f (p, "pandn", 0xdf, src, tmp);
+ orc_sse_emit_660f (p, "por", 0xeb, tmp, dest);
- sse_emit_loadil (p, tmp, 0x80000000);
- sse_emit_660f (p, "pxor", 0xef, tmp, src);
- sse_emit_660f (p, "pxor", 0xef, tmp, dest);
+ orc_sse_emit_loadil (p, tmp, 0x80000000);
+ orc_sse_emit_660f (p, "pxor", 0xef, tmp, src);
+ orc_sse_emit_660f (p, "pxor", 0xef, tmp, dest);
}
#include <orc/orcdebug.h>
#include <orc/orcutils.h>
-#ifdef HAVE_AMD64
-int x86_64 = 1;
-int x86_ptr_size = 8;
-int x86_exec_ptr = X86_EDI;
-#else
-int x86_64 = 0;
-int x86_ptr_size = 4;
-int x86_exec_ptr = X86_EBP;
-#endif
-
const char *
-x86_get_regname(int i)
+orc_x86_get_regname(int i)
{
static const char *x86_regs[] = {
"eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi",
}
int
-x86_get_regnum(int i)
+orc_x86_get_regnum(int i)
{
return (i&0xf);
}
const char *
-x86_get_regname_8(int i)
+orc_x86_get_regname_8(int i)
{
static const char *x86_regs[] = { "al", "cl", "dl", "bl",
"ah", "ch", "dh", "bh" };
}
const char *
-x86_get_regname_16(int i)
+orc_x86_get_regname_16(int i)
{
static const char *x86_regs[] = { "ax", "cx", "dx", "bx",
"sp", "bp", "si", "di" };
}
const char *
-x86_get_regname_64(int i)
+orc_x86_get_regname_64(int i)
{
static const char *x86_regs[] = {
"rax", "rcx", "rdx", "rbx", "rsp", "rbp", "rsi", "rdi",
}
const char *
-x86_get_regname_ptr(int i)
+orc_x86_get_regname_ptr(OrcCompiler *compiler, int i)
{
- if (x86_64) {
- return x86_get_regname_64 (i);
+ if (compiler->is_64bit) {
+ return orc_x86_get_regname_64 (i);
} else {
- return x86_get_regname (i);
+ return orc_x86_get_regname (i);
}
}
const char *
-x86_get_regname_mmx(int i)
+orc_x86_get_regname_mmx(int i)
{
static const char *x86_regs[] = { "mm0", "mm1", "mm2", "mm3",
"mm4", "mm5", "mm6", "mm7" };
}
const char *
-x86_get_regname_sse(int i)
+orc_x86_get_regname_sse(int i)
{
static const char *x86_regs[] = {
"xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
}
void
-x86_emit_push (OrcCompiler *compiler, int size, int reg)
+orc_x86_emit_push (OrcCompiler *compiler, int size, int reg)
{
if (size == 1) {
ORC_PROGRAM_ERROR(compiler, "bad size");
} else if (size == 2) {
- ORC_ASM_CODE(compiler," pushw %%%s\n", x86_get_regname_16(reg));
+ ORC_ASM_CODE(compiler," pushw %%%s\n", orc_x86_get_regname_16(reg));
*compiler->codeptr++ = 0x66;
- *compiler->codeptr++ = 0x50 + x86_get_regnum(reg);
+ *compiler->codeptr++ = 0x50 + orc_x86_get_regnum(reg);
} else {
- ORC_ASM_CODE(compiler," pushl %%%s\n", x86_get_regname(reg));
- *compiler->codeptr++ = 0x50 + x86_get_regnum(reg);
+ ORC_ASM_CODE(compiler," pushl %%%s\n", orc_x86_get_regname(reg));
+ *compiler->codeptr++ = 0x50 + orc_x86_get_regnum(reg);
}
}
void
-x86_emit_pop (OrcCompiler *compiler, int size, int reg)
+orc_x86_emit_pop (OrcCompiler *compiler, int size, int reg)
{
if (size == 1) {
ORC_PROGRAM_ERROR(compiler, "bad size");
} else if (size == 2) {
- ORC_ASM_CODE(compiler," popw %%%s\n", x86_get_regname_16(reg));
+ ORC_ASM_CODE(compiler," popw %%%s\n", orc_x86_get_regname_16(reg));
*compiler->codeptr++ = 0x66;
- *compiler->codeptr++ = 0x58 + x86_get_regnum(reg);
+ *compiler->codeptr++ = 0x58 + orc_x86_get_regnum(reg);
} else {
- ORC_ASM_CODE(compiler," popl %%%s\n", x86_get_regname(reg));
- *compiler->codeptr++ = 0x58 + x86_get_regnum(reg);
+ ORC_ASM_CODE(compiler," popl %%%s\n", orc_x86_get_regname(reg));
+ *compiler->codeptr++ = 0x58 + orc_x86_get_regnum(reg);
}
}
#define X86_SIB(ss, ind, reg) ((((ss)&3)<<6)|(((ind)&7)<<3)|((reg)&7))
void
-x86_emit_modrm_memoffset (OrcCompiler *compiler, int reg1, int offset, int reg2)
+orc_x86_emit_modrm_memoffset (OrcCompiler *compiler, int reg1, int offset, int reg2)
{
- if (offset == 0 && reg2 != x86_exec_ptr) {
+ if (offset == 0 && reg2 != compiler->exec_reg) {
if (reg2 == X86_ESP) {
*compiler->codeptr++ = X86_MODRM(0, 4, reg1);
*compiler->codeptr++ = X86_SIB(0, 4, reg2);
}
void
-x86_emit_modrm_reg (OrcCompiler *compiler, int reg1, int reg2)
+orc_x86_emit_modrm_reg (OrcCompiler *compiler, int reg1, int reg2)
{
*compiler->codeptr++ = X86_MODRM(3, reg1, reg2);
}
void
-x86_emit_rex (OrcCompiler *compiler, int size, int reg1, int reg2, int reg3)
+orc_x86_emit_rex (OrcCompiler *compiler, int size, int reg1, int reg2, int reg3)
{
int rex = 0x40;
- if (x86_64) {
+ if (compiler->is_64bit) {
if (size >= 8) rex |= 0x08;
if (reg1 & 8) rex |= 0x4;
if (reg2 & 8) rex |= 0x2;
}
void
-x86_emit_mov_memoffset_reg (OrcCompiler *compiler, int size, int offset,
+orc_x86_emit_mov_memoffset_reg (OrcCompiler *compiler, int size, int offset,
int reg1, int reg2)
{
switch (size) {
case 1:
ORC_ASM_CODE(compiler," movb %d(%%%s), %%%s\n", offset,
- x86_get_regname_ptr(reg1),
- x86_get_regname_8(reg2));
- x86_emit_rex(compiler, size, reg2, 0, reg1);
+ orc_x86_get_regname_ptr(compiler, reg1),
+ orc_x86_get_regname_8(reg2));
+ orc_x86_emit_rex(compiler, size, reg2, 0, reg1);
*compiler->codeptr++ = 0x8a;
- x86_emit_modrm_memoffset (compiler, reg2, offset, reg1);
+ orc_x86_emit_modrm_memoffset (compiler, reg2, offset, reg1);
return;
case 2:
- ORC_ASM_CODE(compiler," movw %d(%%%s), %%%s\n", offset, x86_get_regname_ptr(reg1),
- x86_get_regname_16(reg2));
+ ORC_ASM_CODE(compiler," movw %d(%%%s), %%%s\n", offset, orc_x86_get_regname_ptr(compiler, reg1),
+ orc_x86_get_regname_16(reg2));
*compiler->codeptr++ = 0x66;
break;
case 4:
- ORC_ASM_CODE(compiler," movl %d(%%%s), %%%s\n", offset, x86_get_regname_ptr(reg1),
- x86_get_regname(reg2));
+ ORC_ASM_CODE(compiler," movl %d(%%%s), %%%s\n", offset, orc_x86_get_regname_ptr(compiler, reg1),
+ orc_x86_get_regname(reg2));
break;
case 8:
- ORC_ASM_CODE(compiler," mov %d(%%%s), %%%s\n", offset, x86_get_regname_ptr(reg1),
- x86_get_regname_64(reg2));
+ ORC_ASM_CODE(compiler," mov %d(%%%s), %%%s\n", offset, orc_x86_get_regname_ptr(compiler, reg1),
+ orc_x86_get_regname_64(reg2));
break;
default:
ORC_PROGRAM_ERROR(compiler, "bad size");
break;
}
- x86_emit_rex(compiler, size, reg2, 0, reg1);
+ orc_x86_emit_rex(compiler, size, reg2, 0, reg1);
*compiler->codeptr++ = 0x8b;
- x86_emit_modrm_memoffset (compiler, reg2, offset, reg1);
+ orc_x86_emit_modrm_memoffset (compiler, reg2, offset, reg1);
}
void
-x86_emit_mov_memoffset_mmx (OrcCompiler *compiler, int size, int offset,
+orc_x86_emit_mov_memoffset_mmx (OrcCompiler *compiler, int size, int offset,
int reg1, int reg2)
{
if (size == 4) {
- ORC_ASM_CODE(compiler," movd %d(%%%s), %%%s\n", offset, x86_get_regname_ptr(reg1),
- x86_get_regname_mmx(reg2));
- x86_emit_rex(compiler, 0, reg2, 0, reg1);
+ ORC_ASM_CODE(compiler," movd %d(%%%s), %%%s\n", offset, orc_x86_get_regname_ptr(compiler, reg1),
+ orc_x86_get_regname_mmx(reg2));
+ orc_x86_emit_rex(compiler, 0, reg2, 0, reg1);
*compiler->codeptr++ = 0x0f;
*compiler->codeptr++ = 0x6e;
} else {
- ORC_ASM_CODE(compiler," movq %d(%%%s), %%%s\n", offset, x86_get_regname_ptr(reg1),
- x86_get_regname_mmx(reg2));
- x86_emit_rex(compiler, 0, reg2, 0, reg1);
+ ORC_ASM_CODE(compiler," movq %d(%%%s), %%%s\n", offset, orc_x86_get_regname_ptr(compiler, reg1),
+ orc_x86_get_regname_mmx(reg2));
+ orc_x86_emit_rex(compiler, 0, reg2, 0, reg1);
*compiler->codeptr++ = 0x0f;
*compiler->codeptr++ = 0x6f;
}
- x86_emit_modrm_memoffset (compiler, reg2, offset, reg1);
+ orc_x86_emit_modrm_memoffset (compiler, reg2, offset, reg1);
}
void
-x86_emit_mov_memoffset_sse (OrcCompiler *compiler, int size, int offset,
+orc_x86_emit_mov_memoffset_sse (OrcCompiler *compiler, int size, int offset,
int reg1, int reg2, int is_aligned)
{
switch (size) {
case 4:
- ORC_ASM_CODE(compiler," movd %d(%%%s), %%%s\n", offset, x86_get_regname_ptr(reg1),
- x86_get_regname_sse(reg2));
+ ORC_ASM_CODE(compiler," movd %d(%%%s), %%%s\n", offset, orc_x86_get_regname_ptr(compiler, reg1),
+ orc_x86_get_regname_sse(reg2));
*compiler->codeptr++ = 0x66;
- x86_emit_rex(compiler, 0, reg2, 0, reg1);
+ orc_x86_emit_rex(compiler, 0, reg2, 0, reg1);
*compiler->codeptr++ = 0x0f;
*compiler->codeptr++ = 0x6e;
break;
case 8:
- ORC_ASM_CODE(compiler," movq %d(%%%s), %%%s\n", offset, x86_get_regname_ptr(reg1),
- x86_get_regname_sse(reg2));
+ ORC_ASM_CODE(compiler," movq %d(%%%s), %%%s\n", offset, orc_x86_get_regname_ptr(compiler, reg1),
+ orc_x86_get_regname_sse(reg2));
*compiler->codeptr++ = 0xf3;
- x86_emit_rex(compiler, 0, reg2, 0, reg1);
+ orc_x86_emit_rex(compiler, 0, reg2, 0, reg1);
*compiler->codeptr++ = 0x0f;
*compiler->codeptr++ = 0x7e;
break;
case 16:
if (is_aligned) {
- ORC_ASM_CODE(compiler," movdqa %d(%%%s), %%%s\n", offset, x86_get_regname_ptr(reg1),
- x86_get_regname_sse(reg2));
+ ORC_ASM_CODE(compiler," movdqa %d(%%%s), %%%s\n", offset, orc_x86_get_regname_ptr(compiler, reg1),
+ orc_x86_get_regname_sse(reg2));
*compiler->codeptr++ = 0x66;
- x86_emit_rex(compiler, 0, reg2, 0, reg1);
+ orc_x86_emit_rex(compiler, 0, reg2, 0, reg1);
*compiler->codeptr++ = 0x0f;
*compiler->codeptr++ = 0x6f;
} else {
- ORC_ASM_CODE(compiler," movdqu %d(%%%s), %%%s\n", offset, x86_get_regname_ptr(reg1),
- x86_get_regname_sse(reg2));
+ ORC_ASM_CODE(compiler," movdqu %d(%%%s), %%%s\n", offset, orc_x86_get_regname_ptr(compiler, reg1),
+ orc_x86_get_regname_sse(reg2));
*compiler->codeptr++ = 0xf3;
- x86_emit_rex(compiler, 0, reg2, 0, reg1);
+ orc_x86_emit_rex(compiler, 0, reg2, 0, reg1);
*compiler->codeptr++ = 0x0f;
*compiler->codeptr++ = 0x6f;
}
ORC_PROGRAM_ERROR(compiler, "bad size");
break;
}
- x86_emit_modrm_memoffset (compiler, reg2, offset, reg1);
+ orc_x86_emit_modrm_memoffset (compiler, reg2, offset, reg1);
}
void
-x86_emit_mov_reg_memoffset (OrcCompiler *compiler, int size, int reg1, int offset,
+orc_x86_emit_mov_reg_memoffset (OrcCompiler *compiler, int size, int reg1, int offset,
int reg2)
{
switch (size) {
case 1:
- ORC_ASM_CODE(compiler," movb %%%s, %d(%%%s)\n", x86_get_regname_8(reg1), offset,
- x86_get_regname_ptr(reg2));
- x86_emit_rex(compiler, size, reg1, 0, reg2);
+ ORC_ASM_CODE(compiler," movb %%%s, %d(%%%s)\n", orc_x86_get_regname_8(reg1), offset,
+ orc_x86_get_regname_ptr(compiler, reg2));
+ orc_x86_emit_rex(compiler, size, reg1, 0, reg2);
*compiler->codeptr++ = 0x88;
- x86_emit_modrm_memoffset (compiler, reg1, offset, reg2);
+ orc_x86_emit_modrm_memoffset (compiler, reg1, offset, reg2);
return;
case 2:
- ORC_ASM_CODE(compiler," movw %%%s, %d(%%%s)\n", x86_get_regname_16(reg1), offset,
- x86_get_regname_ptr(reg2));
+ ORC_ASM_CODE(compiler," movw %%%s, %d(%%%s)\n", orc_x86_get_regname_16(reg1), offset,
+ orc_x86_get_regname_ptr(compiler, reg2));
*compiler->codeptr++ = 0x66;
break;
case 4:
- ORC_ASM_CODE(compiler," movl %%%s, %d(%%%s)\n", x86_get_regname(reg1), offset,
- x86_get_regname_ptr(reg2));
+ ORC_ASM_CODE(compiler," movl %%%s, %d(%%%s)\n", orc_x86_get_regname(reg1), offset,
+ orc_x86_get_regname_ptr(compiler, reg2));
break;
case 8:
- ORC_ASM_CODE(compiler," mov %%%s, %d(%%%s)\n", x86_get_regname(reg1), offset,
- x86_get_regname_ptr(reg2));
+ ORC_ASM_CODE(compiler," mov %%%s, %d(%%%s)\n", orc_x86_get_regname(reg1), offset,
+ orc_x86_get_regname_ptr(compiler, reg2));
break;
default:
ORC_PROGRAM_ERROR(compiler, "bad size");
break;
}
- x86_emit_rex(compiler, size, reg1, 0, reg2);
+ orc_x86_emit_rex(compiler, size, reg1, 0, reg2);
*compiler->codeptr++ = 0x89;
- x86_emit_modrm_memoffset (compiler, reg1, offset, reg2);
+ orc_x86_emit_modrm_memoffset (compiler, reg1, offset, reg2);
}
void
-x86_emit_mov_mmx_memoffset (OrcCompiler *compiler, int size, int reg1, int offset,
+orc_x86_emit_mov_mmx_memoffset (OrcCompiler *compiler, int size, int reg1, int offset,
int reg2)
{
- x86_emit_rex(compiler, 0, reg1, 0, reg2);
+ orc_x86_emit_rex(compiler, 0, reg1, 0, reg2);
if (size == 4) {
- ORC_ASM_CODE(compiler," movd %%%s, %d(%%%s)\n", x86_get_regname_mmx(reg1), offset,
- x86_get_regname_ptr(reg2));
+ ORC_ASM_CODE(compiler," movd %%%s, %d(%%%s)\n", orc_x86_get_regname_mmx(reg1), offset,
+ orc_x86_get_regname_ptr(compiler, reg2));
*compiler->codeptr++ = 0x0f;
*compiler->codeptr++ = 0x7e;
} else if (size == 8) {
- ORC_ASM_CODE(compiler," movq %%%s, %d(%%%s)\n", x86_get_regname_mmx(reg1), offset,
- x86_get_regname_ptr(reg2));
+ ORC_ASM_CODE(compiler," movq %%%s, %d(%%%s)\n", orc_x86_get_regname_mmx(reg1), offset,
+ orc_x86_get_regname_ptr(compiler, reg2));
*compiler->codeptr++ = 0x0f;
*compiler->codeptr++ = 0x7f;
}
- x86_emit_modrm_memoffset (compiler, reg1, offset, reg2);
+ orc_x86_emit_modrm_memoffset (compiler, reg1, offset, reg2);
}
void
-x86_emit_mov_sse_memoffset (OrcCompiler *compiler, int size, int reg1, int offset,
+orc_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(compiler," movd %%%s, %d(%%%s)\n", x86_get_regname_sse(reg1), offset,
- x86_get_regname_ptr(reg2));
+ ORC_ASM_CODE(compiler," movd %%%s, %d(%%%s)\n", orc_x86_get_regname_sse(reg1), offset,
+ orc_x86_get_regname_ptr(compiler, reg2));
*compiler->codeptr++ = 0x66;
- x86_emit_rex(compiler, 0, reg1, 0, reg2);
+ orc_x86_emit_rex(compiler, 0, reg1, 0, reg2);
*compiler->codeptr++ = 0x0f;
*compiler->codeptr++ = 0x7e;
break;
case 8:
- ORC_ASM_CODE(compiler," movq %%%s, %d(%%%s)\n", x86_get_regname_sse(reg1), offset,
- x86_get_regname_ptr(reg2));
+ ORC_ASM_CODE(compiler," movq %%%s, %d(%%%s)\n", orc_x86_get_regname_sse(reg1), offset,
+ orc_x86_get_regname_ptr(compiler, reg2));
*compiler->codeptr++ = 0x66;
- x86_emit_rex(compiler, 0, reg1, 0, reg2);
+ orc_x86_emit_rex(compiler, 0, reg1, 0, reg2);
*compiler->codeptr++ = 0x0f;
*compiler->codeptr++ = 0xd6;
break;
case 16:
if (aligned) {
if (uncached) {
- ORC_ASM_CODE(compiler," movntdq %%%s, %d(%%%s)\n", x86_get_regname_sse(reg1), offset,
- x86_get_regname_ptr(reg2));
+ ORC_ASM_CODE(compiler," movntdq %%%s, %d(%%%s)\n", orc_x86_get_regname_sse(reg1), offset,
+ orc_x86_get_regname_ptr(compiler, reg2));
*compiler->codeptr++ = 0x66;
- x86_emit_rex(compiler, 0, reg1, 0, reg2);
+ orc_x86_emit_rex(compiler, 0, reg1, 0, reg2);
*compiler->codeptr++ = 0x0f;
*compiler->codeptr++ = 0xe7;
} else {
- ORC_ASM_CODE(compiler," movdqa %%%s, %d(%%%s)\n", x86_get_regname_sse(reg1), offset,
- x86_get_regname_ptr(reg2));
+ ORC_ASM_CODE(compiler," movdqa %%%s, %d(%%%s)\n", orc_x86_get_regname_sse(reg1), offset,
+ orc_x86_get_regname_ptr(compiler, reg2));
*compiler->codeptr++ = 0x66;
- x86_emit_rex(compiler, 0, reg1, 0, reg2);
+ orc_x86_emit_rex(compiler, 0, reg1, 0, reg2);
*compiler->codeptr++ = 0x0f;
*compiler->codeptr++ = 0x7f;
}
} else {
- ORC_ASM_CODE(compiler," movdqu %%%s, %d(%%%s)\n", x86_get_regname_sse(reg1), offset,
- x86_get_regname_ptr(reg2));
+ ORC_ASM_CODE(compiler," movdqu %%%s, %d(%%%s)\n", orc_x86_get_regname_sse(reg1), offset,
+ orc_x86_get_regname_ptr(compiler, reg2));
*compiler->codeptr++ = 0xf3;
- x86_emit_rex(compiler, 0, reg1, 0, reg2);
+ orc_x86_emit_rex(compiler, 0, reg1, 0, reg2);
*compiler->codeptr++ = 0x0f;
*compiler->codeptr++ = 0x7f;
}
break;
}
- x86_emit_modrm_memoffset (compiler, reg1, offset, reg2);
+ orc_x86_emit_modrm_memoffset (compiler, reg1, offset, reg2);
}
void
-x86_emit_mov_imm_reg (OrcCompiler *compiler, int size, int value, int reg1)
+orc_x86_emit_mov_imm_reg (OrcCompiler *compiler, int size, int value, int reg1)
{
if (size == 2) {
- ORC_ASM_CODE(compiler," movw $%d, %%%s\n", value, x86_get_regname_16(reg1));
- x86_emit_rex(compiler, size, reg1, 0, 0);
+ ORC_ASM_CODE(compiler," movw $%d, %%%s\n", value, orc_x86_get_regname_16(reg1));
+ orc_x86_emit_rex(compiler, size, reg1, 0, 0);
*compiler->codeptr++ = 0x66;
- *compiler->codeptr++ = 0xb8 + x86_get_regnum(reg1);
+ *compiler->codeptr++ = 0xb8 + orc_x86_get_regnum(reg1);
*compiler->codeptr++ = (value & 0xff);
*compiler->codeptr++ = ((value>>8) & 0xff);
} else if (size == 4) {
- 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);
+ ORC_ASM_CODE(compiler," movl $%d, %%%s\n", value, orc_x86_get_regname(reg1));
+ orc_x86_emit_rex(compiler, size, reg1, 0, 0);
+ *compiler->codeptr++ = 0xb8 + orc_x86_get_regnum(reg1);
*compiler->codeptr++ = (value & 0xff);
*compiler->codeptr++ = ((value>>8) & 0xff);
*compiler->codeptr++ = ((value>>16) & 0xff);
}
-void x86_emit_mov_reg_reg (OrcCompiler *compiler, int size, int reg1, int reg2)
+void orc_x86_emit_mov_reg_reg (OrcCompiler *compiler, int size, int reg1, int reg2)
{
if (size == 2) {
- ORC_ASM_CODE(compiler," movw %%%s, %%%s\n", x86_get_regname_16(reg1),
- x86_get_regname_16(reg2));
+ ORC_ASM_CODE(compiler," movw %%%s, %%%s\n", orc_x86_get_regname_16(reg1),
+ orc_x86_get_regname_16(reg2));
*compiler->codeptr++ = 0x66;
} else if (size == 4) {
- ORC_ASM_CODE(compiler," movl %%%s, %%%s\n", x86_get_regname(reg1),
- x86_get_regname(reg2));
+ ORC_ASM_CODE(compiler," movl %%%s, %%%s\n", orc_x86_get_regname(reg1),
+ orc_x86_get_regname(reg2));
} else {
- ORC_ASM_CODE(compiler," mov %%%s, %%%s\n", x86_get_regname_64(reg1),
- x86_get_regname_64(reg2));
+ ORC_ASM_CODE(compiler," mov %%%s, %%%s\n", orc_x86_get_regname_64(reg1),
+ orc_x86_get_regname_64(reg2));
}
- x86_emit_rex(compiler, size, reg2, 0, reg1);
+ orc_x86_emit_rex(compiler, size, reg2, 0, reg1);
*compiler->codeptr++ = 0x89;
- x86_emit_modrm_reg (compiler, reg2, reg1);
+ orc_x86_emit_modrm_reg (compiler, reg2, reg1);
}
-void x86_emit_mov_sse_reg_reg (OrcCompiler *compiler, int reg1, int reg2)
+void orc_x86_emit_mov_sse_reg_reg (OrcCompiler *compiler, int reg1, int reg2)
{
- ORC_ASM_CODE(compiler," movdqa %%%s, %%%s\n", x86_get_regname_sse(reg1),
- x86_get_regname_sse(reg2));
+ ORC_ASM_CODE(compiler," movdqa %%%s, %%%s\n", orc_x86_get_regname_sse(reg1),
+ orc_x86_get_regname_sse(reg2));
*compiler->codeptr++ = 0x66;
- x86_emit_rex(compiler, 0, reg1, 0, reg2);
+ orc_x86_emit_rex(compiler, 0, reg1, 0, reg2);
*compiler->codeptr++ = 0x0f;
*compiler->codeptr++ = 0x6f;
- x86_emit_modrm_reg (compiler, reg1, reg2);
+ orc_x86_emit_modrm_reg (compiler, reg1, reg2);
}
-void x86_emit_mov_mmx_reg_reg (OrcCompiler *compiler, int reg1, int reg2)
+void orc_x86_emit_mov_mmx_reg_reg (OrcCompiler *compiler, int reg1, int reg2)
{
- ORC_ASM_CODE(compiler," movq %%%s, %%%s\n", x86_get_regname_mmx(reg1),
- x86_get_regname_mmx(reg2));
+ ORC_ASM_CODE(compiler," movq %%%s, %%%s\n", orc_x86_get_regname_mmx(reg1),
+ orc_x86_get_regname_mmx(reg2));
- x86_emit_rex(compiler, 0, reg1, 0, reg2);
+ orc_x86_emit_rex(compiler, 0, reg1, 0, reg2);
*compiler->codeptr++ = 0x0f;
*compiler->codeptr++ = 0x6f;
- x86_emit_modrm_reg (compiler, reg1, reg2);
+ orc_x86_emit_modrm_reg (compiler, reg1, reg2);
}
-void x86_emit_mov_reg_mmx (OrcCompiler *compiler, int reg1, int reg2)
+void orc_x86_emit_mov_reg_mmx (OrcCompiler *compiler, int reg1, int reg2)
{
/* FIXME */
- ORC_ASM_CODE(compiler," movd %%%s, %%%s\n", x86_get_regname(reg1),
- x86_get_regname_mmx(reg2));
- x86_emit_rex(compiler, 0, reg1, 0, reg2);
+ ORC_ASM_CODE(compiler," movd %%%s, %%%s\n", orc_x86_get_regname(reg1),
+ orc_x86_get_regname_mmx(reg2));
+ orc_x86_emit_rex(compiler, 0, reg1, 0, reg2);
*compiler->codeptr++ = 0x0f;
*compiler->codeptr++ = 0x6e;
- x86_emit_modrm_reg (compiler, reg1, reg2);
+ orc_x86_emit_modrm_reg (compiler, reg1, reg2);
}
-void x86_emit_mov_mmx_reg (OrcCompiler *compiler, int reg1, int reg2)
+void orc_x86_emit_mov_mmx_reg (OrcCompiler *compiler, int reg1, int reg2)
{
/* FIXME */
- ORC_ASM_CODE(compiler," movd %%%s, %%%s\n", x86_get_regname_mmx(reg1),
- x86_get_regname(reg2));
- x86_emit_rex(compiler, 0, reg2, 0, reg1);
+ ORC_ASM_CODE(compiler," movd %%%s, %%%s\n", orc_x86_get_regname_mmx(reg1),
+ orc_x86_get_regname(reg2));
+ orc_x86_emit_rex(compiler, 0, reg2, 0, reg1);
*compiler->codeptr++ = 0x0f;
*compiler->codeptr++ = 0x7e;
- x86_emit_modrm_reg (compiler, reg2, reg1);
+ orc_x86_emit_modrm_reg (compiler, reg2, reg1);
}
-void x86_emit_mov_reg_sse (OrcCompiler *compiler, int reg1, int reg2)
+void orc_x86_emit_mov_reg_sse (OrcCompiler *compiler, int reg1, int reg2)
{
- ORC_ASM_CODE(compiler," movd %%%s, %%%s\n", x86_get_regname(reg1),
- x86_get_regname_sse(reg2));
+ ORC_ASM_CODE(compiler," movd %%%s, %%%s\n", orc_x86_get_regname(reg1),
+ orc_x86_get_regname_sse(reg2));
*compiler->codeptr++ = 0x66;
- x86_emit_rex(compiler, 0, reg2, 0, reg1);
+ orc_x86_emit_rex(compiler, 0, reg2, 0, reg1);
*compiler->codeptr++ = 0x0f;
*compiler->codeptr++ = 0x6e;
- x86_emit_modrm_reg (compiler, reg1, reg2);
+ orc_x86_emit_modrm_reg (compiler, reg1, reg2);
}
-void x86_emit_mov_sse_reg (OrcCompiler *compiler, int reg1, int reg2)
+void orc_x86_emit_mov_sse_reg (OrcCompiler *compiler, int reg1, int reg2)
{
- ORC_ASM_CODE(compiler," movd %%%s, %%%s\n", x86_get_regname_sse(reg1),
- x86_get_regname(reg2));
+ ORC_ASM_CODE(compiler," movd %%%s, %%%s\n", orc_x86_get_regname_sse(reg1),
+ orc_x86_get_regname(reg2));
*compiler->codeptr++ = 0x66;
- x86_emit_rex(compiler, 0, reg1, 0, reg2);
+ orc_x86_emit_rex(compiler, 0, reg1, 0, reg2);
*compiler->codeptr++ = 0x0f;
*compiler->codeptr++ = 0x7e;
- x86_emit_modrm_reg (compiler, reg2, reg1);
+ orc_x86_emit_modrm_reg (compiler, reg2, reg1);
}
void
-x86_emit_test_reg_reg (OrcCompiler *compiler, int size, int reg1, int reg2)
+orc_x86_emit_test_reg_reg (OrcCompiler *compiler, int size, int reg1, int reg2)
{
if (size == 2) {
- ORC_ASM_CODE(compiler," testw %%%s, %%%s\n", x86_get_regname_16(reg1),
- x86_get_regname_16(reg2));
+ ORC_ASM_CODE(compiler," testw %%%s, %%%s\n", orc_x86_get_regname_16(reg1),
+ orc_x86_get_regname_16(reg2));
*compiler->codeptr++ = 0x66;
} else if (size == 4) {
- ORC_ASM_CODE(compiler," testl %%%s, %%%s\n", x86_get_regname(reg1),
- x86_get_regname(reg2));
+ ORC_ASM_CODE(compiler," testl %%%s, %%%s\n", orc_x86_get_regname(reg1),
+ orc_x86_get_regname(reg2));
} else {
- ORC_ASM_CODE(compiler," test %%%s, %%%s\n", x86_get_regname(reg1),
- x86_get_regname(reg2));
+ ORC_ASM_CODE(compiler," test %%%s, %%%s\n", orc_x86_get_regname(reg1),
+ orc_x86_get_regname(reg2));
}
- x86_emit_rex(compiler, size, reg2, 0, reg1);
+ orc_x86_emit_rex(compiler, size, reg2, 0, reg1);
*compiler->codeptr++ = 0x85;
- x86_emit_modrm_reg (compiler, reg2, reg1);
+ orc_x86_emit_modrm_reg (compiler, reg2, reg1);
}
void
-x86_emit_sar_imm_reg (OrcCompiler *compiler, int size, int value, int reg)
+orc_x86_emit_sar_imm_reg (OrcCompiler *compiler, int size, int value, int reg)
{
if (size == 2) {
- ORC_ASM_CODE(compiler," sarw $%d, %%%s\n", value, x86_get_regname_16(reg));
+ ORC_ASM_CODE(compiler," sarw $%d, %%%s\n", value, orc_x86_get_regname_16(reg));
} else if (size == 4) {
- ORC_ASM_CODE(compiler," sarl $%d, %%%s\n", value, x86_get_regname(reg));
+ ORC_ASM_CODE(compiler," sarl $%d, %%%s\n", value, orc_x86_get_regname(reg));
} else {
- ORC_ASM_CODE(compiler," sar $%d, %%%s\n", value, x86_get_regname_64(reg));
+ ORC_ASM_CODE(compiler," sar $%d, %%%s\n", value, orc_x86_get_regname_64(reg));
}
- x86_emit_rex(compiler, size, reg, 0, 0);
+ orc_x86_emit_rex(compiler, size, reg, 0, 0);
if (value == 1) {
*compiler->codeptr++ = 0xd1;
- x86_emit_modrm_reg (compiler, reg, 7);
+ orc_x86_emit_modrm_reg (compiler, reg, 7);
} else {
*compiler->codeptr++ = 0xc1;
- x86_emit_modrm_reg (compiler, reg, 7);
+ orc_x86_emit_modrm_reg (compiler, reg, 7);
*compiler->codeptr++ = value;
}
}
void
-x86_emit_and_imm_memoffset (OrcCompiler *compiler, int size, int value,
+orc_x86_emit_and_imm_memoffset (OrcCompiler *compiler, int size, int value,
int offset, int reg)
{
if (size == 2) {
ORC_ASM_CODE(compiler," andw $%d, %d(%%%s)\n", value, offset,
- x86_get_regname_ptr(reg));
+ orc_x86_get_regname_ptr(compiler, reg));
*compiler->codeptr++ = 0x66;
} else if (size == 4) {
ORC_ASM_CODE(compiler," andl $%d, %d(%%%s)\n", value, offset,
- x86_get_regname_ptr(reg));
+ orc_x86_get_regname_ptr(compiler, reg));
} else {
ORC_ASM_CODE(compiler," and $%d, %d(%%%s)\n", value, offset,
- x86_get_regname_ptr(reg));
+ orc_x86_get_regname_ptr(compiler, reg));
}
- x86_emit_rex(compiler, size, 0, 0, reg);
+ orc_x86_emit_rex(compiler, size, 0, 0, reg);
if (value >= -128 && value < 128) {
*compiler->codeptr++ = 0x83;
/* FIXME */
- x86_emit_modrm_memoffset (compiler, 0, offset, reg);
+ orc_x86_emit_modrm_memoffset (compiler, 0, offset, reg);
*compiler->codeptr++ = (value & 0xff);
} else {
*compiler->codeptr++ = 0x81;
/* FIXME */
- x86_emit_modrm_memoffset (compiler, 0, offset, reg);
+ orc_x86_emit_modrm_memoffset (compiler, 0, offset, reg);
*compiler->codeptr++ = (value & 0xff);
*compiler->codeptr++ = ((value>>8) & 0xff);
if (size == 4) {
}
void
-x86_emit_and_imm_reg (OrcCompiler *compiler, int size, int value, int reg)
+orc_x86_emit_and_imm_reg (OrcCompiler *compiler, int size, int value, int reg)
{
if (size == 2) {
- ORC_ASM_CODE(compiler," andw $%d, %%%s\n", value, x86_get_regname_16(reg));
+ ORC_ASM_CODE(compiler," andw $%d, %%%s\n", value, orc_x86_get_regname_16(reg));
*compiler->codeptr++ = 0x66;
} else if (size == 4) {
- ORC_ASM_CODE(compiler," andl $%d, %%%s\n", value, x86_get_regname(reg));
+ ORC_ASM_CODE(compiler," andl $%d, %%%s\n", value, orc_x86_get_regname(reg));
} else {
- ORC_ASM_CODE(compiler," and $%d, %%%s\n", value, x86_get_regname_64(reg));
+ ORC_ASM_CODE(compiler," and $%d, %%%s\n", value, orc_x86_get_regname_64(reg));
}
- x86_emit_rex(compiler, size, 0, 0, reg);
+ orc_x86_emit_rex(compiler, size, 0, 0, reg);
if (value >= -128 && value < 128) {
*compiler->codeptr++ = 0x83;
- x86_emit_modrm_reg (compiler, reg, 4);
+ orc_x86_emit_modrm_reg (compiler, reg, 4);
*compiler->codeptr++ = (value & 0xff);
} else {
*compiler->codeptr++ = 0x81;
- x86_emit_modrm_reg (compiler, reg, 4);
+ orc_x86_emit_modrm_reg (compiler, reg, 4);
*compiler->codeptr++ = (value & 0xff);
*compiler->codeptr++ = ((value>>8) & 0xff);
if (size == 4) {
}
void
-x86_emit_add_imm_memoffset (OrcCompiler *compiler, int size, int value,
+orc_x86_emit_add_imm_memoffset (OrcCompiler *compiler, int size, int value,
int offset, int reg)
{
if (size == 2) {
ORC_ASM_CODE(compiler," addw $%d, %d(%%%s)\n", value, offset,
- x86_get_regname_ptr(reg));
+ orc_x86_get_regname_ptr(compiler, reg));
*compiler->codeptr++ = 0x66;
} else if (size == 4) {
ORC_ASM_CODE(compiler," addl $%d, %d(%%%s)\n", value, offset,
- x86_get_regname_ptr(reg));
+ orc_x86_get_regname_ptr(compiler, reg));
} else {
ORC_ASM_CODE(compiler," add $%d, %d(%%%s)\n", value, offset,
- x86_get_regname_ptr(reg));
+ orc_x86_get_regname_ptr(compiler, reg));
}
- x86_emit_rex(compiler, size, 0, 0, reg);
+ orc_x86_emit_rex(compiler, size, 0, 0, reg);
if (value >= -128 && value < 128) {
*compiler->codeptr++ = 0x83;
- x86_emit_modrm_memoffset (compiler, 0, offset, reg);
+ orc_x86_emit_modrm_memoffset (compiler, 0, offset, reg);
*compiler->codeptr++ = (value & 0xff);
} else {
*compiler->codeptr++ = 0x81;
- x86_emit_modrm_memoffset (compiler, 0, offset, reg);
+ orc_x86_emit_modrm_memoffset (compiler, 0, offset, reg);
*compiler->codeptr++ = (value & 0xff);
*compiler->codeptr++ = ((value>>8) & 0xff);
if (size == 4) {
}
void
-x86_emit_add_reg_memoffset (OrcCompiler *compiler, int size, int reg1,
+orc_x86_emit_add_reg_memoffset (OrcCompiler *compiler, int size, int reg1,
int offset, int reg)
{
if (size == 2) {
ORC_ASM_CODE(compiler," addw %%%s, %d(%%%s)\n",
- x86_get_regname_ptr(reg1), offset,
- x86_get_regname_ptr(reg));
+ orc_x86_get_regname_ptr(compiler, reg1), offset,
+ orc_x86_get_regname_ptr(compiler, reg));
*compiler->codeptr++ = 0x66;
} else if (size == 4) {
ORC_ASM_CODE(compiler," addl %%%s, %d(%%%s)\n",
- x86_get_regname_ptr(reg1), offset,
- x86_get_regname_ptr(reg));
+ orc_x86_get_regname_ptr(compiler, reg1), offset,
+ orc_x86_get_regname_ptr(compiler, reg));
} else {
ORC_ASM_CODE(compiler," add %%%s, %d(%%%s)\n",
- x86_get_regname_ptr(reg1), offset,
- x86_get_regname_ptr(reg));
+ orc_x86_get_regname_ptr(compiler, reg1), offset,
+ orc_x86_get_regname_ptr(compiler, reg));
}
- x86_emit_rex(compiler, size, 0, 0, reg);
+ orc_x86_emit_rex(compiler, size, 0, 0, reg);
*compiler->codeptr++ = 0x01;
- x86_emit_modrm_memoffset (compiler, reg1, offset, reg);
+ orc_x86_emit_modrm_memoffset (compiler, reg1, offset, reg);
}
void
-x86_emit_add_imm_reg (OrcCompiler *compiler, int size, int value, int reg)
+orc_x86_emit_add_imm_reg (OrcCompiler *compiler, int size, int value, int reg)
{
if (size == 2) {
- ORC_ASM_CODE(compiler," addw $%d, %%%s\n", value, x86_get_regname_16(reg));
+ ORC_ASM_CODE(compiler," addw $%d, %%%s\n", value, orc_x86_get_regname_16(reg));
*compiler->codeptr++ = 0x66;
} else if (size == 4) {
- ORC_ASM_CODE(compiler," addl $%d, %%%s\n", value, x86_get_regname(reg));
+ ORC_ASM_CODE(compiler," addl $%d, %%%s\n", value, orc_x86_get_regname(reg));
} else {
- ORC_ASM_CODE(compiler," add $%d, %%%s\n", value, x86_get_regname_64(reg));
+ ORC_ASM_CODE(compiler," add $%d, %%%s\n", value, orc_x86_get_regname_64(reg));
}
- x86_emit_rex(compiler, size, 0, 0, reg);
+ orc_x86_emit_rex(compiler, size, 0, 0, reg);
if (value >= -128 && value < 128) {
*compiler->codeptr++ = 0x83;
- x86_emit_modrm_reg (compiler, reg, 0);
+ orc_x86_emit_modrm_reg (compiler, reg, 0);
*compiler->codeptr++ = (value & 0xff);
} else {
*compiler->codeptr++ = 0x81;
- x86_emit_modrm_reg (compiler, reg, 0);
+ orc_x86_emit_modrm_reg (compiler, reg, 0);
*compiler->codeptr++ = (value & 0xff);
*compiler->codeptr++ = ((value>>8) & 0xff);
if (size == 4) {
}
void
-x86_emit_sub_reg_reg (OrcCompiler *compiler, int size, int reg1, int reg2)
+orc_x86_emit_sub_reg_reg (OrcCompiler *compiler, int size, int reg1, int reg2)
{
if (size == 2) {
- ORC_ASM_CODE(compiler," subw %%%s, %%%s\n", x86_get_regname_16(reg1),
- x86_get_regname_16(reg2));
+ ORC_ASM_CODE(compiler," subw %%%s, %%%s\n", orc_x86_get_regname_16(reg1),
+ orc_x86_get_regname_16(reg2));
*compiler->codeptr++ = 0x66;
} else if (size == 4) {
- ORC_ASM_CODE(compiler," subl %%%s, %%%s\n", x86_get_regname(reg1),
- x86_get_regname(reg2));
+ ORC_ASM_CODE(compiler," subl %%%s, %%%s\n", orc_x86_get_regname(reg1),
+ orc_x86_get_regname(reg2));
} else {
- ORC_ASM_CODE(compiler," sub %%%s, %%%s\n", x86_get_regname_64(reg1),
- x86_get_regname_64(reg2));
+ ORC_ASM_CODE(compiler," sub %%%s, %%%s\n", orc_x86_get_regname_64(reg1),
+ orc_x86_get_regname_64(reg2));
}
- x86_emit_rex(compiler, size, reg2, 0, reg1);
+ orc_x86_emit_rex(compiler, size, reg2, 0, reg1);
*compiler->codeptr++ = 0x29;
- x86_emit_modrm_reg (compiler, reg2, reg1);
+ orc_x86_emit_modrm_reg (compiler, reg2, reg1);
}
void
-x86_emit_sub_memoffset_reg (OrcCompiler *compiler, int size,
+orc_x86_emit_sub_memoffset_reg (OrcCompiler *compiler, int size,
int offset, int reg, int destreg)
{
if (size == 2) {
ORC_ASM_CODE(compiler," subw %d(%%%s), %%%s\n", offset,
- x86_get_regname_ptr(reg),
- x86_get_regname_16(destreg));
+ orc_x86_get_regname_ptr(compiler, reg),
+ orc_x86_get_regname_16(destreg));
*compiler->codeptr++ = 0x66;
} else if (size == 4) {
ORC_ASM_CODE(compiler," subl %d(%%%s), %%%s\n", offset,
- x86_get_regname_ptr(reg),
- x86_get_regname(destreg));
+ orc_x86_get_regname_ptr(compiler, reg),
+ orc_x86_get_regname(destreg));
} else {
ORC_ASM_CODE(compiler," sub %d(%%%s), %%%s\n", offset,
- x86_get_regname_ptr(reg),
- x86_get_regname_64(destreg));
+ orc_x86_get_regname_ptr(compiler, reg),
+ orc_x86_get_regname_64(destreg));
}
- x86_emit_rex(compiler, size, 0, 0, reg);
+ orc_x86_emit_rex(compiler, size, 0, 0, reg);
*compiler->codeptr++ = 0x2b;
- x86_emit_modrm_memoffset (compiler, destreg, offset, reg);
+ orc_x86_emit_modrm_memoffset (compiler, destreg, offset, reg);
}
void
-x86_emit_cmp_reg_memoffset (OrcCompiler *compiler, int size, int reg1,
+orc_x86_emit_cmp_reg_memoffset (OrcCompiler *compiler, int size, int reg1,
int offset, int reg)
{
if (size == 2) {
- ORC_ASM_CODE(compiler," cmpw %%%s, %d(%%%s)\n", x86_get_regname_16(reg1), offset,
- x86_get_regname_ptr(reg));
+ ORC_ASM_CODE(compiler," cmpw %%%s, %d(%%%s)\n", orc_x86_get_regname_16(reg1), offset,
+ orc_x86_get_regname_ptr(compiler, reg));
*compiler->codeptr++ = 0x66;
} else if (size == 4) {
- ORC_ASM_CODE(compiler," cmpl %%%s, %d(%%%s)\n", x86_get_regname(reg1), offset,
- x86_get_regname_ptr(reg));
+ ORC_ASM_CODE(compiler," cmpl %%%s, %d(%%%s)\n", orc_x86_get_regname(reg1), offset,
+ orc_x86_get_regname_ptr(compiler, reg));
} else {
- ORC_ASM_CODE(compiler," cmp %%%s, %d(%%%s)\n", x86_get_regname_64(reg1), offset,
- x86_get_regname_ptr(reg));
+ ORC_ASM_CODE(compiler," cmp %%%s, %d(%%%s)\n", orc_x86_get_regname_64(reg1), offset,
+ orc_x86_get_regname_ptr(compiler, reg));
}
- x86_emit_rex(compiler, size, 0, 0, reg);
+ orc_x86_emit_rex(compiler, size, 0, 0, reg);
*compiler->codeptr++ = 0x39;
- x86_emit_modrm_memoffset (compiler, reg1, offset, reg);
+ orc_x86_emit_modrm_memoffset (compiler, reg1, offset, reg);
}
void
-x86_emit_cmp_imm_memoffset (OrcCompiler *compiler, int size, int value,
+orc_x86_emit_cmp_imm_memoffset (OrcCompiler *compiler, int size, int value,
int offset, int reg)
{
if (size == 2) {
ORC_ASM_CODE(compiler," cmpw $%d, %d(%%%s)\n", value, offset,
- x86_get_regname_ptr(reg));
+ orc_x86_get_regname_ptr(compiler, reg));
*compiler->codeptr++ = 0x66;
} else if (size == 4) {
ORC_ASM_CODE(compiler," cmpl $%d, %d(%%%s)\n", value, offset,
- x86_get_regname_ptr(reg));
+ orc_x86_get_regname_ptr(compiler, reg));
} else {
ORC_ASM_CODE(compiler," cmp $%d, %d(%%%s)\n", value, offset,
- x86_get_regname_ptr(reg));
+ orc_x86_get_regname_ptr(compiler, reg));
}
- x86_emit_rex(compiler, size, 0, 0, reg);
+ orc_x86_emit_rex(compiler, size, 0, 0, reg);
if (value >= -128 && value < 128) {
*compiler->codeptr++ = 0x83;
- x86_emit_modrm_memoffset (compiler, 7, offset, reg);
+ orc_x86_emit_modrm_memoffset (compiler, 7, offset, reg);
*compiler->codeptr++ = (value & 0xff);
} else {
*compiler->codeptr++ = 0x81;
- x86_emit_modrm_memoffset (compiler, 7, offset, reg);
+ orc_x86_emit_modrm_memoffset (compiler, 7, offset, reg);
*compiler->codeptr++ = (value & 0xff);
*compiler->codeptr++ = ((value>>8) & 0xff);
if (size == 4) {
}
void
-x86_emit_dec_memoffset (OrcCompiler *compiler, int size,
+orc_x86_emit_dec_memoffset (OrcCompiler *compiler, int size,
int offset, int reg)
{
if (size == 2) {
- ORC_ASM_CODE(compiler," decw %d(%%%s)\n", offset, x86_get_regname_ptr(reg));
+ ORC_ASM_CODE(compiler," decw %d(%%%s)\n", offset, orc_x86_get_regname_ptr(compiler, reg));
*compiler->codeptr++ = 0x66;
} else if (size == 4) {
- ORC_ASM_CODE(compiler," decl %d(%%%s)\n", offset, x86_get_regname_ptr(reg));
+ ORC_ASM_CODE(compiler," decl %d(%%%s)\n", offset, orc_x86_get_regname_ptr(compiler, reg));
} else {
- ORC_ASM_CODE(compiler," dec %d(%%%s)\n", offset, x86_get_regname_ptr(reg));
+ ORC_ASM_CODE(compiler," dec %d(%%%s)\n", offset, orc_x86_get_regname_ptr(compiler, reg));
}
- x86_emit_rex(compiler, size, 0, 0, reg);
+ orc_x86_emit_rex(compiler, size, 0, 0, reg);
*compiler->codeptr++ = 0xff;
- x86_emit_modrm_memoffset (compiler, 1, offset, reg);
+ orc_x86_emit_modrm_memoffset (compiler, 1, offset, reg);
}
-void x86_emit_ret (OrcCompiler *compiler)
+void orc_x86_emit_ret (OrcCompiler *compiler)
{
- if (x86_64) {
+ if (compiler->is_64bit) {
ORC_ASM_CODE(compiler," retq\n");
} else {
ORC_ASM_CODE(compiler," ret\n");
*compiler->codeptr++ = 0xc3;
}
-void x86_emit_emms (OrcCompiler *compiler)
+void orc_x86_emit_emms (OrcCompiler *compiler)
{
ORC_ASM_CODE(compiler," emms\n");
*compiler->codeptr++ = 0x0f;
compiler->labels[label] = ptr;
}
-void x86_emit_jmp (OrcCompiler *compiler, int label)
+void orc_x86_emit_jmp (OrcCompiler *compiler, int label)
{
ORC_ASM_CODE(compiler," jmp %d%c\n", label,
(compiler->labels[label]!=NULL) ? 'b' : 'f');
}
}
-void x86_emit_jle (OrcCompiler *compiler, int label)
+void orc_x86_emit_jle (OrcCompiler *compiler, int label)
{
ORC_ASM_CODE(compiler," jle %d%c\n", label,
(compiler->labels[label]!=NULL) ? 'b' : 'f');
}
}
-void x86_emit_je (OrcCompiler *compiler, int label)
+void orc_x86_emit_je (OrcCompiler *compiler, int label)
{
ORC_ASM_CODE(compiler," je %d%c\n", label,
(compiler->labels[label]!=NULL) ? 'b' : 'f');
}
}
-void x86_emit_jne (OrcCompiler *compiler, int label)
+void orc_x86_emit_jne (OrcCompiler *compiler, int label)
{
ORC_ASM_CODE(compiler," jne %d%c\n", label,
(compiler->labels[label]!=NULL) ? 'b' : 'f');
}
}
-void x86_emit_label (OrcCompiler *compiler, int label)
+void orc_x86_emit_label (OrcCompiler *compiler, int label)
{
ORC_ASM_CODE(compiler,"%d:\n", label);
}
void
-x86_emit_prologue (OrcCompiler *compiler)
+orc_x86_emit_prologue (OrcCompiler *compiler)
{
orc_compiler_append_code(compiler,".global %s\n", compiler->program->name);
orc_compiler_append_code(compiler,".p2align 4\n");
orc_compiler_append_code(compiler,"%s:\n", compiler->program->name);
- if (x86_64) {
+ if (compiler->is_64bit) {
int i;
for(i=0;i<16;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);
+ orc_x86_emit_push (compiler, 8, ORC_GP_REG_BASE+i);
}
}
} else {
- x86_emit_push (compiler, 4, X86_EBP);
- x86_emit_mov_memoffset_reg (compiler, 4, 8, X86_ESP, X86_EBP);
+ orc_x86_emit_push (compiler, 4, X86_EBP);
+ orc_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);
+ orc_x86_emit_push (compiler, 4, X86_EDI);
}
if (compiler->used_regs[X86_ESI]) {
- x86_emit_push (compiler, 4, X86_ESI);
+ orc_x86_emit_push (compiler, 4, X86_ESI);
}
if (compiler->used_regs[X86_EBX]) {
- x86_emit_push (compiler, 4, X86_EBX);
+ orc_x86_emit_push (compiler, 4, X86_EBX);
}
}
}
void
-x86_emit_epilogue (OrcCompiler *compiler)
+orc_x86_emit_epilogue (OrcCompiler *compiler)
{
- if (x86_64) {
+ if (compiler->is_64bit) {
int i;
for(i=15;i>=0;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);
+ orc_x86_emit_push (compiler, 8, ORC_GP_REG_BASE+i);
}
}
} else {
if (compiler->used_regs[X86_EBX]) {
- x86_emit_pop (compiler, 4, X86_EBX);
+ orc_x86_emit_pop (compiler, 4, X86_EBX);
}
if (compiler->used_regs[X86_ESI]) {
- x86_emit_pop (compiler, 4, X86_ESI);
+ orc_x86_emit_pop (compiler, 4, X86_ESI);
}
if (compiler->used_regs[X86_EDI]) {
- x86_emit_pop (compiler, 4, X86_EDI);
+ orc_x86_emit_pop (compiler, 4, X86_EDI);
}
- x86_emit_pop (compiler, 4, X86_EBP);
+ orc_x86_emit_pop (compiler, 4, X86_EBP);
}
- x86_emit_ret (compiler);
+ orc_x86_emit_ret (compiler);
}
void
-x86_emit_align (OrcCompiler *compiler)
+orc_x86_emit_align (OrcCompiler *compiler)
{
int diff;
int align_shift = 4;
for(size=2;size<=4;size+=2) {
for(i=0;i<8;i++){
reg = ORC_GP_REG_BASE + i;
- 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);
+ orc_x86_emit_push (compiler, size, reg);
+ orc_x86_emit_pop (compiler, size, reg);
+ orc_x86_emit_mov_imm_reg (compiler, size, 0, reg);
+ orc_x86_emit_mov_imm_reg (compiler, size, 1, reg);
+ orc_x86_emit_mov_imm_reg (compiler, size, 256, reg);
+ orc_x86_emit_dec_memoffset (compiler, size, 0, reg);
+ orc_x86_emit_dec_memoffset (compiler, size, 1, reg);
+ orc_x86_emit_dec_memoffset (compiler, size, 256, reg);
+ orc_x86_emit_add_imm_memoffset (compiler, size, 1, 0, reg);
+ orc_x86_emit_add_imm_memoffset (compiler, size, 1, 1, reg);
+ orc_x86_emit_add_imm_memoffset (compiler, size, 1, 256, reg);
+ orc_x86_emit_add_imm_memoffset (compiler, size, 256, 0, reg);
+ orc_x86_emit_add_imm_memoffset (compiler, size, 256, 1, reg);
+ orc_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 (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);
+ orc_x86_emit_mov_reg_reg (compiler, size, reg, reg2);
+ orc_x86_emit_mov_memoffset_reg (compiler, size, 0, reg, reg2);
+ orc_x86_emit_mov_memoffset_reg (compiler, size, 1, reg, reg2);
+ orc_x86_emit_mov_memoffset_reg (compiler, size, 256, reg, reg2);
+ orc_x86_emit_mov_reg_memoffset (compiler, size, reg, 0, reg2);
+ orc_x86_emit_mov_reg_memoffset (compiler, size, reg, 1, reg2);
+ orc_x86_emit_mov_reg_memoffset (compiler, size, reg, 256, reg2);
}
}
}
#include <unistd.h>
-extern int x86_64;
-extern int x86_exec_ptr;
-extern int x86_ptr_size;
-
-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,
+void orc_x86_emit_push (OrcCompiler *compiler, int size, int reg);
+void orc_x86_emit_pop (OrcCompiler *compiler, int size, int reg);
+void orc_x86_emit_mov_memoffset_reg (OrcCompiler *compiler, int size, int offset, int reg1, int reg2);
+void orc_x86_emit_mov_memoffset_mmx (OrcCompiler *compiler, int size, int offset,
int reg1, int reg2);
-void x86_emit_mov_memoffset_sse (OrcCompiler *compiler, int size, int offset,
+void orc_x86_emit_mov_memoffset_sse (OrcCompiler *compiler, int size, int offset,
int reg1, int reg2, int is_aligned);
-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,
+void orc_x86_emit_mov_reg_memoffset (OrcCompiler *compiler, int size, int reg1, int offset, int reg2);
+void orc_x86_emit_mov_mmx_memoffset (OrcCompiler *compiler, int size, int reg1, int offset,
int reg2);
-void x86_emit_mov_sse_memoffset (OrcCompiler *compiler, int size, int reg1, int offset,
+void orc_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 (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_add_reg_memoffset (OrcCompiler *compiler, int size, int reg1, 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,
+void orc_x86_emit_mov_imm_reg (OrcCompiler *compiler, int size, int value, int reg1);
+void orc_x86_emit_mov_reg_reg (OrcCompiler *compiler, int size, int reg1, int reg2);
+void orc_x86_emit_mov_sse_reg_reg (OrcCompiler *compiler, int reg1, int reg2);
+void orc_x86_emit_mov_mmx_reg_reg (OrcCompiler *compiler, int reg1, int reg2);
+void orc_x86_emit_mov_reg_mmx (OrcCompiler *compiler, int reg1, int reg2);
+void orc_x86_emit_mov_mmx_reg (OrcCompiler *compiler, int reg1, int reg2);
+void orc_x86_emit_mov_reg_sse (OrcCompiler *compiler, int reg1, int reg2);
+void orc_x86_emit_mov_sse_reg (OrcCompiler *compiler, int reg1, int reg2);
+void orc_x86_emit_test_reg_reg (OrcCompiler *compiler, int size, int reg1, int reg2);
+void orc_x86_emit_sar_imm_reg (OrcCompiler *compiler, int size, int value, int reg);
+void orc_x86_emit_dec_memoffset (OrcCompiler *compiler, int size, int offset, int reg);
+void orc_x86_emit_add_imm_memoffset (OrcCompiler *compiler, int size, int value, int offset, int reg);
+void orc_x86_emit_add_reg_memoffset (OrcCompiler *compiler, int size, int reg1, int offset, int reg);
+void orc_x86_emit_and_imm_memoffset (OrcCompiler *compiler, int size, int value, int offset, int reg);
+void orc_x86_emit_add_imm_reg (OrcCompiler *compiler, int size, int value, int reg);
+void orc_x86_emit_and_imm_reg (OrcCompiler *compiler, int size, int value, int reg);
+void orc_x86_emit_sub_reg_reg (OrcCompiler *compiler, int size, int reg1, int reg2);
+void orc_x86_emit_sub_memoffset_reg (OrcCompiler *compiler, int size,
int offset, int reg, int destreg);
-void x86_emit_cmp_reg_memoffset (OrcCompiler *compiler, int size, int reg1,
+void orc_x86_emit_cmp_reg_memoffset (OrcCompiler *compiler, int size, int reg1,
int offset, int reg);
-void x86_emit_cmp_imm_memoffset (OrcCompiler *compiler, int size, int value,
+void orc_x86_emit_cmp_imm_memoffset (OrcCompiler *compiler, int size, int value,
int offset, int reg);
-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 orc_x86_emit_emms (OrcCompiler *compiler);
+void orc_x86_emit_ret (OrcCompiler *compiler);
+void orc_x86_emit_jle (OrcCompiler *compiler, int label);
+void orc_x86_emit_je (OrcCompiler *compiler, int label);
+void orc_x86_emit_jne (OrcCompiler *compiler, int label);
+void orc_x86_emit_jmp (OrcCompiler *compiler, int label);
+void orc_x86_emit_label (OrcCompiler *compiler, int label);
+void orc_x86_emit_align (OrcCompiler *compiler);
void x86_do_fixups (OrcCompiler *compiler);
-void x86_emit_prologue (OrcCompiler *compiler);
-void x86_emit_epilogue (OrcCompiler *compiler);
+void orc_x86_emit_prologue (OrcCompiler *compiler);
+void orc_x86_emit_epilogue (OrcCompiler *compiler);
-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 orc_x86_emit_rex (OrcCompiler *compiler, int size, int reg1, int reg2, int reg3);
+void orc_x86_emit_modrm_memoffset (OrcCompiler *compiler, int reg1, int offset, int reg2);
+void orc_x86_emit_modrm_reg (OrcCompiler *compiler, int reg1, int reg2);
void x86_test (OrcCompiler *compiler);
-void mmx_emit_loadiw (OrcCompiler *p, int reg, int value);
+void orc_mmx_emit_loadiw (OrcCompiler *p, int reg, int value);
-void sse_emit_loadib (OrcCompiler *p, int reg, int value);
-void sse_emit_loadiw (OrcCompiler *p, int reg, int value);
-void sse_emit_loadil (OrcCompiler *p, int reg, int value);
-void sse_emit_loadpb (OrcCompiler *p, int reg, int value);
-void sse_emit_loadpw (OrcCompiler *p, int reg, int value);
-void sse_emit_loadpl (OrcCompiler *p, int reg, int value);
-void sse_emit_loadpq (OrcCompiler *p, int reg, int value);
+void orc_sse_emit_loadib (OrcCompiler *p, int reg, int value);
+void orc_sse_emit_loadiw (OrcCompiler *p, int reg, int value);
+void orc_sse_emit_loadil (OrcCompiler *p, int reg, int value);
+void orc_sse_emit_loadpb (OrcCompiler *p, int reg, int value);
+void orc_sse_emit_loadpw (OrcCompiler *p, int reg, int value);
+void orc_sse_emit_loadpl (OrcCompiler *p, int reg, int value);
+void orc_sse_emit_loadpq (OrcCompiler *p, int reg, int value);
-void sse_emit_660f (OrcCompiler *p, const char *insn_name, int code,
+void orc_sse_emit_660f (OrcCompiler *p, const char *insn_name, int code,
+ int src, int dest);
+void orc_sse_emit_f20f (OrcCompiler *p, const char *insn_name, int code,
+ int src, int dest);
+void orc_sse_emit_f30f (OrcCompiler *p, const char *insn_name, int code,
int src, int dest);
-void sse_emit_f20f (OrcCompiler *p, const char *insn_name, int code,
+void orc_sse_emit_0f (OrcCompiler *p, const char *insn_name, int code,
int src, int dest);
-void sse_emit_660f38 (OrcCompiler *p, const char *insn_name, int code,
+void orc_sse_emit_660f38 (OrcCompiler *p, const char *insn_name, int code,
int src, int dest);
enum {
X86_XMM15
};
-const char * x86_get_regname(int i);
-int x86_get_regnum(int i);
-const char * x86_get_regname_16(int i);
-const char * x86_get_regname_64(int i);
-const char * x86_get_regname_ptr(int i);
-const char * x86_get_regname_mmx(int i);
-const char * x86_get_regname_sse(int i);
+const char * orc_x86_get_regname(int i);
+int orc_x86_get_regnum(int i);
+const char * orc_x86_get_regname_16(int i);
+const char * orc_x86_get_regname_64(int i);
+const char * orc_x86_get_regname_ptr(OrcCompiler *compiler, int i);
+const char * orc_x86_get_regname_mmx(int i);
+const char * orc_x86_get_regname_sse(int i);
#endif
projects / platform / upstream / orc.git / commitdiff