Alien-LibJIT
view release on metacpan or search on metacpan
libjit/jit/jit-rules-x86.c view on Meta::CPAN
offset = -(func->builder->frame_size);
for(reg = 0; reg <= 7; ++reg)
{
if(jit_reg_is_used(gen->touched, reg) &&
(_jit_reg_info[reg].flags & JIT_REG_CALL_USED) == 0)
{
offset -= sizeof(void *);
x86_mov_reg_membase(inst, _jit_reg_info[reg].cpu_reg,
X86_EBP, offset, sizeof(void *));
}
}
}
else
{
for(reg = 7; reg >= 0; --reg)
{
if(jit_reg_is_used(gen->touched, reg) &&
(_jit_reg_info[reg].flags & JIT_REG_CALL_USED) == 0)
{
x86_pop_reg(inst, _jit_reg_info[reg].cpu_reg);
}
}
}
/* Pop the stack frame and restore the saved copy of ebp */
if(gen->stack_changed || func->builder->frame_size > 0)
{
x86_mov_reg_reg(inst, X86_ESP, X86_EBP, sizeof(void *));
}
x86_pop_reg(inst, X86_EBP);
/* Return from the current function */
if(pop_bytes > 0)
{
x86_ret_imm(inst, pop_bytes);
}
else
{
x86_ret(inst);
}
gen->ptr = inst;
}
#if 0
/*
* The x86 backend does not need this function because it uses
* _jit_create_indirector() instead.
*/
void *_jit_gen_redirector(jit_gencode_t gen, jit_function_t func)
{
void *ptr, *entry;
_jit_gen_check_space(gen, 8);
ptr = (void *)&(func->entry_point);
entry = gen->ptr;
x86_jump_mem(gen->ptr, ptr);
return entry;
}
#endif
/*
* Setup or teardown the x86 code output process.
*/
#define jit_cache_setup_output(needed) \
unsigned char *inst = gen->ptr; \
_jit_gen_check_space(gen, (needed))
#define jit_cache_end_output() \
gen->ptr = inst
/*
* Get a temporary register that isn't one of the specified registers.
*/
static int get_temp_reg(int reg1, int reg2, int reg3)
{
if(reg1 != X86_EAX && reg2 != X86_EAX && reg3 != X86_EAX)
{
return X86_EAX;
}
if(reg1 != X86_EDX && reg2 != X86_EDX && reg3 != X86_EDX)
{
return X86_EDX;
}
if(reg1 != X86_ECX && reg2 != X86_ECX && reg3 != X86_ECX)
{
return X86_ECX;
}
if(reg1 != X86_EBX && reg2 != X86_EBX && reg3 != X86_EBX)
{
return X86_EBX;
}
if(reg1 != X86_ESI && reg2 != X86_ESI && reg3 != X86_ESI)
{
return X86_ESI;
}
return X86_EDI;
}
/*
* Store a byte value to a membase address.
*/
static unsigned char *mov_membase_reg_byte
(unsigned char *inst, int basereg, int offset, int srcreg)
{
if(srcreg == X86_EAX || srcreg == X86_EBX ||
srcreg == X86_ECX || srcreg == X86_EDX)
{
x86_mov_membase_reg(inst, basereg, offset, srcreg, 1);
}
else if(basereg != X86_EAX)
{
x86_push_reg(inst, X86_EAX);
x86_mov_reg_reg(inst, X86_EAX, srcreg, 4);
x86_mov_membase_reg(inst, basereg, offset, X86_EAX, 1);
x86_pop_reg(inst, X86_EAX);
}
else
{
x86_push_reg(inst, X86_EDX);
x86_mov_reg_reg(inst, X86_EDX, srcreg, 4);
x86_mov_membase_reg(inst, basereg, offset, X86_EDX, 1);
x86_pop_reg(inst, X86_EDX);
libjit/jit/jit-rules-x86.c view on Meta::CPAN
int offset;
/* Make sure that we have sufficient space */
jit_cache_setup_output(16);
/* If the value is associated with a global register, then copy to that */
if(value->has_global_register)
{
reg = _jit_reg_info[reg].cpu_reg;
other_reg = _jit_reg_info[value->global_reg].cpu_reg;
x86_mov_reg_reg(inst, other_reg, reg, sizeof(void *));
jit_cache_end_output();
return;
}
/* Fix the value in place within the local variable frame */
_jit_gen_fix_value(value);
/* Output an appropriate instruction to spill the value */
offset = (int)(value->frame_offset);
if(IS_WORD_REG(reg))
{
/* Spill a word register. If the value is smaller than a word,
then we write the entire word. The local stack frame is
allocated such that the extra bytes will be simply ignored */
reg = _jit_reg_info[reg].cpu_reg;
x86_mov_membase_reg(inst, X86_EBP, offset, reg, 4);
if(other_reg != -1)
{
/* Spill the other word register in a pair */
reg = _jit_reg_info[other_reg].cpu_reg;
offset += sizeof(void *);
x86_mov_membase_reg(inst, X86_EBP, offset, reg, 4);
}
}
else
{
/* Spill the top of the floating-point register stack */
switch(jit_type_normalize(value->type)->kind)
{
case JIT_TYPE_FLOAT32:
{
x86_fst_membase(inst, X86_EBP, offset, 0, 1);
}
break;
case JIT_TYPE_FLOAT64:
{
x86_fst_membase(inst, X86_EBP, offset, 1, 1);
}
break;
case JIT_TYPE_NFLOAT:
{
x86_fst80_membase(inst, X86_EBP, offset);
}
break;
}
}
/* End the code output process */
jit_cache_end_output();
}
void
_jit_gen_free_reg(jit_gencode_t gen, int reg, int other_reg, int value_used)
{
/* We only need to take explicit action if we are freeing a
floating-point register whose value hasn't been used yet */
if(!value_used && IS_FLOAT_REG(reg))
{
_jit_gen_check_space(gen, 2);
x86_fstp(gen->ptr, reg - X86_REG_ST0);
}
}
static int
fp_stack_index(jit_gencode_t gen, int reg)
{
return gen->reg_stack_top - reg - 1;
}
void
_jit_gen_exch_top(jit_gencode_t gen, int reg)
{
if(IS_FLOAT_REG(reg))
{
jit_cache_setup_output(2);
x86_fxch(inst, fp_stack_index(gen, reg));
jit_cache_end_output();
}
}
void
_jit_gen_move_top(jit_gencode_t gen, int reg)
{
if(IS_FLOAT_REG(reg))
{
jit_cache_setup_output(2);
x86_fstp(inst, fp_stack_index(gen, reg));
jit_cache_end_output();
}
}
void
_jit_gen_spill_top(jit_gencode_t gen, int reg, jit_value_t value, int pop)
{
int offset;
if(IS_FLOAT_REG(reg))
{
/* Make sure that we have sufficient space */
jit_cache_setup_output(16);
/* Fix the value in place within the local variable frame */
_jit_gen_fix_value(value);
/* Output an appropriate instruction to spill the value */
offset = (int)(value->frame_offset);
/* Spill the top of the floating-point register stack */
switch(jit_type_normalize(value->type)->kind)
{
case JIT_TYPE_FLOAT32:
{
x86_fst_membase(inst, X86_EBP, offset, 0, pop);
}
break;
case JIT_TYPE_FLOAT64:
{
x86_fst_membase(inst, X86_EBP, offset, 1, pop);
}
break;
case JIT_TYPE_NFLOAT:
{
x86_fst80_membase(inst, X86_EBP, offset);
if(!pop)
{
x86_fld80_membase(inst, X86_EBP, offset);
}
}
break;
}
/* End the code output process */
jit_cache_end_output();
}
}
void
_jit_gen_load_value(jit_gencode_t gen, int reg, int other_reg, jit_value_t value)
{
jit_type_t type;
int src_reg, other_src_reg;
void *ptr;
int offset;
/* Make sure that we have sufficient space */
jit_cache_setup_output(16);
type = jit_type_normalize(value->type);
/* Load zero */
if(value->is_constant)
{
switch(type->kind)
{
case JIT_TYPE_SBYTE:
case JIT_TYPE_UBYTE:
case JIT_TYPE_SHORT:
case JIT_TYPE_USHORT:
case JIT_TYPE_INT:
case JIT_TYPE_UINT:
{
if((jit_nint)(value->address) == 0)
{
x86_clear_reg(inst, _jit_reg_info[reg].cpu_reg);
}
else
{
x86_mov_reg_imm(inst, _jit_reg_info[reg].cpu_reg,
(jit_nint)(value->address));
}
}
break;
case JIT_TYPE_LONG:
case JIT_TYPE_ULONG:
{
jit_long long_value;
long_value = jit_value_get_long_constant(value);
if(long_value == 0)
{
#ifdef JIT_NATIVE_INT64
x86_clear_reg(inst, _jit_reg_info[reg].cpu_reg);
#else
x86_clear_reg(inst, _jit_reg_info[reg].cpu_reg);
x86_clear_reg(inst, _jit_reg_info[other_reg].cpu_reg);
#endif
}
else
{
#ifdef JIT_NATIVE_INT64
x86_mov_reg_imm(inst, _jit_reg_info[reg].cpu_reg,
(jit_nint)long_value);
libjit/jit/jit-rules-x86.c view on Meta::CPAN
x86_mov_reg_membase(inst, _jit_reg_info[reg].cpu_reg,
X86_EBP, offset, 4);
x86_mov_reg_membase(inst, _jit_reg_info[other_reg].cpu_reg,
X86_EBP, offset + 4, 4);
#endif
}
break;
case JIT_TYPE_FLOAT32:
{
if(IS_WORD_REG(reg))
{
x86_mov_reg_membase(inst, _jit_reg_info[reg].cpu_reg,
X86_EBP, offset, 4);
}
else
{
x86_fld_membase(inst, X86_EBP, offset, 0);
}
}
break;
case JIT_TYPE_FLOAT64:
{
if(IS_WORD_REG(reg))
{
x86_mov_reg_membase(inst, _jit_reg_info[reg].cpu_reg,
X86_EBP, offset, 4);
x86_mov_reg_membase(inst, _jit_reg_info[other_reg].cpu_reg,
X86_EBP, offset + 4, 4);
}
else
{
x86_fld_membase(inst, X86_EBP, offset, 1);
}
}
break;
case JIT_TYPE_NFLOAT:
{
if(IS_WORD_REG(reg) && sizeof(jit_nfloat) == sizeof(jit_float64))
{
x86_mov_reg_membase(inst, _jit_reg_info[reg].cpu_reg,
X86_EBP, offset, 4);
x86_mov_reg_membase(inst, _jit_reg_info[other_reg].cpu_reg,
X86_EBP, offset + 4, 4);
}
else if(sizeof(jit_nfloat) == sizeof(jit_float64))
{
x86_fld_membase(inst, X86_EBP, offset, 1);
}
else
{
x86_fld80_membase(inst, X86_EBP, offset);
}
}
break;
}
}
/* End the code output process */
jit_cache_end_output();
}
void _jit_gen_spill_global(jit_gencode_t gen, int reg, jit_value_t value)
{
jit_cache_setup_output(16);
if(value)
{
_jit_gen_fix_value(value);
x86_mov_membase_reg(inst,
X86_EBP, value->frame_offset,
_jit_reg_info[value->global_reg].cpu_reg, sizeof(void *));
}
else
{
x86_push_reg(inst, _jit_reg_info[reg].cpu_reg);
}
jit_cache_end_output();
}
void _jit_gen_load_global(jit_gencode_t gen, int reg, jit_value_t value)
{
jit_cache_setup_output(16);
if(value)
{
x86_mov_reg_membase(inst,
_jit_reg_info[value->global_reg].cpu_reg,
X86_EBP, value->frame_offset, sizeof(void *));
}
else
{
x86_pop_reg(inst, _jit_reg_info[reg].cpu_reg);
}
jit_cache_end_output();
}
void _jit_gen_fix_value(jit_value_t value)
{
if(!(value->has_frame_offset) && !(value->is_constant))
{
jit_nint size = (jit_nint)(ROUND_STACK(jit_type_get_size(value->type)));
value->block->func->builder->frame_size += size;
value->frame_offset = -(value->block->func->builder->frame_size);
value->has_frame_offset = 1;
}
}
/*
* Set a register value based on a condition code.
*/
static unsigned char *setcc_reg
(unsigned char *inst, int reg, int cond, int is_signed)
{
if(reg == X86_EAX || reg == X86_EBX || reg == X86_ECX || reg == X86_EDX)
{
/* Use a SETcc instruction if we have a basic register */
x86_set_reg(inst, cond, reg, is_signed);
x86_widen_reg(inst, reg, reg, 0, 0);
}
else
( run in 1.834 second using v1.01-cache-2.11-cpan-97f6503c9c8 )