mirror of
https://git.savannah.gnu.org/git/guile.git
synced 2025-05-08 22:50:27 +02:00
Implement new synthesized IR codes sequences
* lib/jit_rewind.c: New file implementing generic functions to "rewind", or rewrite IR code sequences. * include/lightning.h: Add several new codes, that previously were a function call, that would synthesize the operation. Now, there is a code for the operation, and a new flag to know an operation is synthesized. * include/lightning/jit_private.h: Add several new macros to help construct synthesized IR code sequences. * lib/Makefile.am: Update for lib/jit_rewind.c. * lib/jit_disasm.c: Update for a small rework on jit_node_t, so that --enable-devel-disassembler does not need a change in the layout of jit_node_t. * lib/jit_names.c: Update for the new codes. * lib/jit_print.c: Update to print more readable output, and flag synthesized IR code sequences. * lib/jit_aarch64-sz.c, lib/jit_aarch64.c, lib/jit_arm-sz.c, lib/jit_arm.c, lib/jit_x86-sz.c, lib/jit_x86.c: Update for new synthesized IR code sequences. * lib/jit_ppc-cpu.c, lib/jit_ppc-fpu., lib/jit_ppc-sz.c, lib/jit_ppc.c, lib/jit_mips-cpu.c, lib/jit_mips-fpu.c, lib/jit_mips-sz.c, lib/jit_mips.c, lib/jit_s390-fpu.c, lib/jit_s390-sz.c, lib/jit_s390.c: Update for new synthesized IR code sequences and correct bugs in the initial varargs implementation support. * lib/jit_alpha-sz.c, lib/jit_alpha.c, lib/jit_hppa-sz.c, lib/jit_hppa.c, lib/jit_ia64-sz.c, lib/jit_ia64.c, lib/jit_sparc-sz.c, lib/jit_sparc.c: Add generic, untested support for the new synthesized IR code sequences. Known most likely broken right now, and should be corrected once access to these hosts is available. * lib/lightning.c: Update for new IR codes, and add support for not yet existing instructions that change third argument. * size.c: Change to use different tables for LE and BE PowerPC. Correct a wrong endif for x32.
This commit is contained in:
pcpa
parent
7f1e0dfb34
commit
d0a5bd8d3d
35 changed files with 4397 additions and 1152 deletions
281
lib/jit_arm.c
281
lib/jit_arm.c
|
|
@ -59,6 +59,12 @@ typedef jit_pointer_t jit_va_list;
|
|||
/*
|
||||
* Prototypes
|
||||
*/
|
||||
#define jit_make_arg(node) _jit_make_arg(_jit,node)
|
||||
static jit_node_t *_jit_make_arg(jit_state_t*,jit_node_t*);
|
||||
#define jit_make_arg_f(node) _jit_make_arg_f(_jit,node)
|
||||
static jit_node_t *_jit_make_arg_f(jit_state_t*,jit_node_t*);
|
||||
#define jit_make_arg_d(node) _jit_make_arg_d(_jit,node)
|
||||
static jit_node_t *_jit_make_arg_d(jit_state_t*,jit_node_t*);
|
||||
#define jit_get_reg_pair() _jit_get_reg_pair(_jit)
|
||||
static jit_int32_t _jit_get_reg_pair(jit_state_t*);
|
||||
#define jit_unget_reg_pair(rn) _jit_unget_reg_pair(_jit,rn)
|
||||
|
|
@ -80,6 +86,7 @@ extern void __clear_cache(void *, void *);
|
|||
#endif
|
||||
|
||||
#define PROTO 1
|
||||
# include "jit_rewind.c"
|
||||
# include "jit_arm-cpu.c"
|
||||
# include "jit_arm-swf.c"
|
||||
# include "jit_arm-vfp.c"
|
||||
|
|
@ -250,6 +257,10 @@ _jit_prolog(jit_state_t *_jit)
|
|||
jit_alloc((jit_pointer_t *)&_jitc->function->regoff,
|
||||
_jitc->reglen * sizeof(jit_int32_t));
|
||||
|
||||
/* _no_link here does not mean the jit_link() call can be removed
|
||||
* by rewriting as:
|
||||
* _jitc->function->prolog = jit_new_node(jit_code_prolog);
|
||||
*/
|
||||
_jitc->function->prolog = jit_new_node_no_link(jit_code_prolog);
|
||||
jit_link(_jitc->function->prolog);
|
||||
_jitc->function->prolog->w.w = offset;
|
||||
|
|
@ -274,6 +285,10 @@ _jit_allocai(jit_state_t *_jit, jit_int32_t length)
|
|||
default: _jitc->function->self.aoff &= -8; break;
|
||||
}
|
||||
_jitc->function->self.aoff -= length;
|
||||
if (!_jitc->realize) {
|
||||
jit_inc_synth_ww(allocai, _jitc->function->self.aoff, length);
|
||||
jit_dec_synth();
|
||||
}
|
||||
return (_jitc->function->self.aoff);
|
||||
}
|
||||
|
||||
|
|
@ -282,55 +297,59 @@ _jit_allocar(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
|
|||
{
|
||||
jit_int32_t reg;
|
||||
assert(_jitc->function);
|
||||
jit_inc_synth_ww(allocar, u, v);
|
||||
if (!_jitc->function->allocar) {
|
||||
_jitc->function->aoffoff = jit_allocai(sizeof(jit_int32_t));
|
||||
_jitc->function->allocar = 1;
|
||||
}
|
||||
|
||||
reg = jit_get_reg(jit_class_gpr);
|
||||
jit_negr(reg, v);
|
||||
jit_andi(reg, reg, -8);
|
||||
|
||||
jit_ldxi_i(u, JIT_FP, _jitc->function->aoffoff);
|
||||
jit_addr(u, u, reg);
|
||||
jit_addr(JIT_SP, JIT_SP, reg);
|
||||
|
||||
jit_stxi_i(_jitc->function->aoffoff, JIT_FP, u);
|
||||
jit_unget_reg(reg);
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
void
|
||||
_jit_ret(jit_state_t *_jit)
|
||||
{
|
||||
jit_node_t *instr;
|
||||
|
||||
assert(_jitc->function);
|
||||
|
||||
jit_inc_synth(ret);
|
||||
/* jump to epilog */
|
||||
instr = jit_jmpi();
|
||||
jit_patch_at(instr, _jitc->function->epilog);
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
void
|
||||
_jit_retr(jit_state_t *_jit, jit_int32_t u)
|
||||
{
|
||||
jit_inc_synth_w(retr, u);
|
||||
if (JIT_RET != u)
|
||||
jit_movr(JIT_RET, u);
|
||||
else
|
||||
jit_live(JIT_RET);
|
||||
jit_ret();
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
void
|
||||
_jit_reti(jit_state_t *_jit, jit_word_t u)
|
||||
{
|
||||
jit_inc_synth_w(reti, u);
|
||||
jit_movi(JIT_RET, u);
|
||||
jit_ret();
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
void
|
||||
_jit_retr_f(jit_state_t *_jit, jit_int32_t u)
|
||||
{
|
||||
jit_inc_synth_w(retr_f, u);
|
||||
if (jit_cpu.abi) {
|
||||
if (u != JIT_FRET)
|
||||
jit_movr_f(JIT_FRET, u);
|
||||
|
|
@ -344,21 +363,25 @@ _jit_retr_f(jit_state_t *_jit, jit_int32_t u)
|
|||
jit_live(JIT_RET);
|
||||
}
|
||||
jit_ret();
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
void
|
||||
_jit_reti_f(jit_state_t *_jit, jit_float32_t u)
|
||||
{
|
||||
jit_inc_synth_f(reti_f, u);
|
||||
if (jit_cpu.abi)
|
||||
jit_movi_f(JIT_FRET, u);
|
||||
else
|
||||
jit_movi_f_w(JIT_RET, u);
|
||||
jit_ret();
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
void
|
||||
_jit_retr_d(jit_state_t *_jit, jit_int32_t u)
|
||||
{
|
||||
jit_inc_synth_w(retr_d, u);
|
||||
if (jit_cpu.abi) {
|
||||
if (u != JIT_FRET)
|
||||
jit_movr_d(JIT_FRET, u);
|
||||
|
|
@ -372,16 +395,19 @@ _jit_retr_d(jit_state_t *_jit, jit_int32_t u)
|
|||
jit_live(JIT_RET);
|
||||
}
|
||||
jit_ret();
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
void
|
||||
_jit_reti_d(jit_state_t *_jit, jit_float64_t u)
|
||||
{
|
||||
jit_inc_synth_d(reti_d, u);
|
||||
if (jit_cpu.abi)
|
||||
jit_movi_d(JIT_FRET, u);
|
||||
else
|
||||
jit_movi_d_ww(JIT_RET, _R1, u);
|
||||
jit_ret();
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
void
|
||||
|
|
@ -410,44 +436,30 @@ _jit_arg_register_p(jit_state_t *_jit, jit_node_t *u)
|
|||
return (jit_arg_reg_p(u->u.w));
|
||||
}
|
||||
|
||||
void
|
||||
_jit_ellipsis(jit_state_t *_jit)
|
||||
static jit_node_t *
|
||||
_jit_make_arg(jit_state_t *_jit, jit_node_t *node)
|
||||
{
|
||||
if (_jitc->prepare) {
|
||||
assert(!(_jitc->function->call.call & jit_call_varargs));
|
||||
_jitc->function->call.call |= jit_call_varargs;
|
||||
}
|
||||
else {
|
||||
assert(!(_jitc->function->self.call & jit_call_varargs));
|
||||
_jitc->function->self.call |= jit_call_varargs;
|
||||
|
||||
/* First 4 stack addresses are always spilled r0-r3 */
|
||||
if (jit_arg_reg_p(_jitc->function->self.argi))
|
||||
_jitc->function->vagp = _jitc->function->self.argi * 4;
|
||||
else
|
||||
_jitc->function->vagp = 16;
|
||||
}
|
||||
}
|
||||
|
||||
jit_node_t *
|
||||
_jit_arg(jit_state_t *_jit)
|
||||
{
|
||||
jit_int32_t offset;
|
||||
assert(_jitc->function);
|
||||
jit_int32_t offset;
|
||||
if (jit_arg_reg_p(_jitc->function->self.argi))
|
||||
offset = _jitc->function->self.argi++;
|
||||
else {
|
||||
offset = _jitc->function->self.size;
|
||||
_jitc->function->self.size += sizeof(jit_word_t);
|
||||
}
|
||||
return (jit_new_node_w(jit_code_arg, offset));
|
||||
if (node == (jit_node_t *)0)
|
||||
node = jit_new_node(jit_code_arg);
|
||||
else
|
||||
link_node(node);
|
||||
node->u.w = offset;
|
||||
node->v.w = ++_jitc->function->self.argn;
|
||||
jit_link_prolog();
|
||||
return (node);
|
||||
}
|
||||
|
||||
jit_node_t *
|
||||
_jit_arg_f(jit_state_t *_jit)
|
||||
_jit_make_arg_f(jit_state_t *_jit, jit_node_t *node)
|
||||
{
|
||||
jit_int32_t offset;
|
||||
assert(_jitc->function);
|
||||
jit_int32_t offset;
|
||||
if (jit_cpu.abi && !(_jitc->function->self.call & jit_call_varargs)) {
|
||||
if (jit_arg_f_reg_p(_jitc->function->self.argf)) {
|
||||
offset = _jitc->function->self.argf++;
|
||||
|
|
@ -463,14 +475,20 @@ _jit_arg_f(jit_state_t *_jit)
|
|||
offset = _jitc->function->self.size;
|
||||
_jitc->function->self.size += sizeof(jit_float32_t);
|
||||
done:
|
||||
return (jit_new_node_w(jit_code_arg_f, offset));
|
||||
if (node == (jit_node_t *)0)
|
||||
node = jit_new_node(jit_code_arg_f);
|
||||
else
|
||||
link_node(node);
|
||||
node->u.w = offset;
|
||||
node->v.w = ++_jitc->function->self.argn;
|
||||
jit_link_prolog();
|
||||
return (node);
|
||||
}
|
||||
|
||||
jit_node_t *
|
||||
_jit_arg_d(jit_state_t *_jit)
|
||||
_jit_make_arg_d(jit_state_t *_jit, jit_node_t *node)
|
||||
{
|
||||
jit_int32_t offset;
|
||||
assert(_jitc->function);
|
||||
jit_int32_t offset;
|
||||
if (jit_cpu.abi && !(_jitc->function->self.call & jit_call_varargs)) {
|
||||
if (jit_arg_d_reg_p(_jitc->function->self.argf)) {
|
||||
if (_jitc->function->self.argf & 1)
|
||||
|
|
@ -494,79 +512,147 @@ _jit_arg_d(jit_state_t *_jit)
|
|||
offset = _jitc->function->self.size;
|
||||
_jitc->function->self.size += sizeof(jit_float64_t);
|
||||
done:
|
||||
return (jit_new_node_w(jit_code_arg_d, offset));
|
||||
if (node == (jit_node_t *)0)
|
||||
node = jit_new_node(jit_code_arg_d);
|
||||
else
|
||||
link_node(node);
|
||||
node->u.w = offset;
|
||||
node->v.w = ++_jitc->function->self.argn;
|
||||
jit_link_prolog();
|
||||
return (node);
|
||||
}
|
||||
|
||||
void
|
||||
_jit_ellipsis(jit_state_t *_jit)
|
||||
{
|
||||
if (_jitc->prepare) {
|
||||
assert(!(_jitc->function->call.call & jit_call_varargs));
|
||||
_jitc->function->call.call |= jit_call_varargs;
|
||||
if (jit_cpu.abi && _jitc->function->call.argf)
|
||||
rewind_prepare();
|
||||
}
|
||||
else {
|
||||
assert(!(_jitc->function->self.call & jit_call_varargs));
|
||||
_jitc->function->self.call |= jit_call_varargs;
|
||||
if (jit_cpu.abi && _jitc->function->self.argf)
|
||||
rewind_prolog();
|
||||
/* First 4 stack addresses are always spilled r0-r3 */
|
||||
if (jit_arg_reg_p(_jitc->function->self.argi))
|
||||
_jitc->function->vagp = _jitc->function->self.argi * 4;
|
||||
else
|
||||
_jitc->function->vagp = 16;
|
||||
}
|
||||
jit_inc_synth(ellipsis);
|
||||
if (_jitc->prepare)
|
||||
jit_link_prepare();
|
||||
else
|
||||
jit_link_prolog();
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
jit_node_t *
|
||||
_jit_arg(jit_state_t *_jit)
|
||||
{
|
||||
assert(_jitc->function);
|
||||
return (jit_make_arg((jit_node_t*)0));
|
||||
}
|
||||
|
||||
jit_node_t *
|
||||
_jit_arg_f(jit_state_t *_jit)
|
||||
{
|
||||
assert(_jitc->function);
|
||||
return (jit_make_arg_f((jit_node_t*)0));
|
||||
}
|
||||
|
||||
jit_node_t *
|
||||
_jit_arg_d(jit_state_t *_jit)
|
||||
{
|
||||
assert(_jitc->function);
|
||||
return (jit_make_arg_d((jit_node_t*)0));
|
||||
}
|
||||
|
||||
void
|
||||
_jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
||||
{
|
||||
assert(v->code == jit_code_arg);
|
||||
jit_inc_synth_wp(getarg_c, u, v);
|
||||
if (jit_swf_p())
|
||||
jit_ldxi_c(u, JIT_FP, arg_offset(v->u.w));
|
||||
else if (jit_arg_reg_p(v->u.w))
|
||||
jit_extr_c(u, JIT_RA0 - v->u.w);
|
||||
else
|
||||
jit_ldxi_c(u, JIT_FP, v->u.w);
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
void
|
||||
_jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
||||
{
|
||||
assert(v->code == jit_code_arg);
|
||||
jit_inc_synth_wp(getarg_uc, u, v);
|
||||
if (jit_swf_p())
|
||||
jit_ldxi_uc(u, JIT_FP, arg_offset(v->u.w));
|
||||
else if (jit_arg_reg_p(v->u.w))
|
||||
jit_extr_uc(u, JIT_RA0 - v->u.w);
|
||||
else
|
||||
jit_ldxi_uc(u, JIT_FP, v->u.w);
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
void
|
||||
_jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
||||
{
|
||||
assert(v->code == jit_code_arg);
|
||||
jit_inc_synth_wp(getarg_s, u, v);
|
||||
if (jit_swf_p())
|
||||
jit_ldxi_s(u, JIT_FP, arg_offset(v->u.w));
|
||||
else if (jit_arg_reg_p(v->u.w))
|
||||
jit_extr_s(u, JIT_RA0 - v->u.w);
|
||||
else
|
||||
jit_ldxi_s(u, JIT_FP, v->u.w);
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
void
|
||||
_jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
||||
{
|
||||
assert(v->code == jit_code_arg);
|
||||
jit_inc_synth_wp(getarg_us, u, v);
|
||||
if (jit_swf_p())
|
||||
jit_ldxi_us(u, JIT_FP, arg_offset(v->u.w));
|
||||
else if (jit_arg_reg_p(v->u.w))
|
||||
jit_extr_us(u, JIT_RA0 - v->u.w);
|
||||
else
|
||||
jit_ldxi_us(u, JIT_FP, v->u.w);
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
void
|
||||
_jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
||||
{
|
||||
assert(v->code == jit_code_arg);
|
||||
jit_inc_synth_wp(getarg_i, u, v);
|
||||
if (jit_swf_p())
|
||||
jit_ldxi_i(u, JIT_FP, arg_offset(v->u.w));
|
||||
else if (jit_arg_reg_p(v->u.w))
|
||||
jit_movr(u, JIT_RA0 - v->u.w);
|
||||
else
|
||||
jit_ldxi_i(u, JIT_FP, v->u.w);
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
void
|
||||
_jit_putargr(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
||||
{
|
||||
assert(v->code == jit_code_arg);
|
||||
jit_inc_synth_wp(putargr, u, v);
|
||||
if (jit_swf_p())
|
||||
jit_stxi(arg_offset(v->u.w), JIT_FP, u);
|
||||
else if (jit_arg_reg_p(v->u.w))
|
||||
jit_movr(JIT_RA0 - v->u.w, u);
|
||||
else
|
||||
jit_stxi(v->u.w, JIT_FP, u);
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
void
|
||||
|
|
@ -574,6 +660,7 @@ _jit_putargi(jit_state_t *_jit, jit_word_t u, jit_node_t *v)
|
|||
{
|
||||
jit_int32_t regno;
|
||||
assert(v->code == jit_code_arg);
|
||||
jit_inc_synth_wp(putargi, u, v);
|
||||
if (jit_swf_p()) {
|
||||
regno = jit_get_reg(jit_class_gpr);
|
||||
jit_movi(regno, u);
|
||||
|
|
@ -588,13 +675,15 @@ _jit_putargi(jit_state_t *_jit, jit_word_t u, jit_node_t *v)
|
|||
jit_stxi(v->u.w, JIT_FP, regno);
|
||||
jit_unget_reg(regno);
|
||||
}
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
void
|
||||
_jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
||||
{
|
||||
assert(v->code == jit_code_arg_f);
|
||||
if (jit_cpu.abi) {
|
||||
jit_inc_synth_wp(getarg_f, u, v);
|
||||
if (jit_cpu.abi && !(_jitc->function->self.call & jit_call_varargs)) {
|
||||
if (jit_arg_f_reg_p(v->u.w))
|
||||
jit_movr_f(u, JIT_FA0 - v->u.w);
|
||||
else
|
||||
|
|
@ -608,12 +697,14 @@ _jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
|||
else
|
||||
jit_ldxi_f(u, JIT_FP, v->u.w);
|
||||
}
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
void
|
||||
_jit_putargr_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
||||
{
|
||||
assert(v->code == jit_code_arg_f);
|
||||
jit_inc_synth_wp(putargr_f, u, v);
|
||||
if (jit_cpu.abi) {
|
||||
if (jit_arg_f_reg_p(v->u.w))
|
||||
jit_movr_f(JIT_FA0 - v->u.w, u);
|
||||
|
|
@ -628,6 +719,7 @@ _jit_putargr_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
|||
else
|
||||
jit_stxi_f(v->u.w, JIT_FP, u);
|
||||
}
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
void
|
||||
|
|
@ -635,6 +727,7 @@ _jit_putargi_f(jit_state_t *_jit, jit_float32_t u, jit_node_t *v)
|
|||
{
|
||||
jit_int32_t regno;
|
||||
assert(v->code == jit_code_arg_f);
|
||||
jit_inc_synth_fp(putargi_f, u, v);
|
||||
if (jit_cpu.abi) {
|
||||
if (jit_arg_f_reg_p(v->u.w))
|
||||
jit_movi_f(JIT_FA0 - v->u.w, u);
|
||||
|
|
@ -660,13 +753,15 @@ _jit_putargi_f(jit_state_t *_jit, jit_float32_t u, jit_node_t *v)
|
|||
jit_stxi_f(v->u.w, JIT_FP, regno);
|
||||
jit_unget_reg(regno);
|
||||
}
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
void
|
||||
_jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
||||
{
|
||||
assert(v->code == jit_code_arg_d);
|
||||
if (jit_cpu.abi) {
|
||||
jit_inc_synth_wp(getarg_d, u, v);
|
||||
if (jit_cpu.abi && !(_jitc->function->self.call & jit_call_varargs)) {
|
||||
if (jit_arg_f_reg_p(v->u.w))
|
||||
jit_movr_d(u, JIT_FA0 - v->u.w);
|
||||
else
|
||||
|
|
@ -680,12 +775,14 @@ _jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
|||
else
|
||||
jit_ldxi_d(u, JIT_FP, v->u.w);
|
||||
}
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
void
|
||||
_jit_putargr_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
||||
{
|
||||
assert(v->code == jit_code_arg_d);
|
||||
jit_inc_synth_wp(putargr_d, u, v);
|
||||
if (jit_cpu.abi) {
|
||||
if (jit_arg_f_reg_p(v->u.w))
|
||||
jit_movr_d(JIT_FA0 - v->u.w, u);
|
||||
|
|
@ -700,6 +797,7 @@ _jit_putargr_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
|||
else
|
||||
jit_stxi_d(v->u.w, JIT_FP, u);
|
||||
}
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
void
|
||||
|
|
@ -707,6 +805,7 @@ _jit_putargi_d(jit_state_t *_jit, jit_float64_t u, jit_node_t *v)
|
|||
{
|
||||
jit_int32_t regno;
|
||||
assert(v->code == jit_code_arg_d);
|
||||
jit_inc_synth_dp(putargi_d, u, v);
|
||||
if (jit_cpu.abi) {
|
||||
if (jit_arg_f_reg_p(v->u.w))
|
||||
jit_movi_d(JIT_FA0 - v->u.w, u);
|
||||
|
|
@ -732,12 +831,15 @@ _jit_putargi_d(jit_state_t *_jit, jit_float64_t u, jit_node_t *v)
|
|||
jit_stxi_d(v->u.w, JIT_FP, regno);
|
||||
jit_unget_reg(regno);
|
||||
}
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
void
|
||||
_jit_pushargr(jit_state_t *_jit, jit_int32_t u)
|
||||
{
|
||||
assert(_jitc->function);
|
||||
jit_inc_synth_w(pushargr, u);
|
||||
jit_link_prepare();
|
||||
if (jit_arg_reg_p(_jitc->function->call.argi)) {
|
||||
jit_movr(JIT_RA0 - _jitc->function->call.argi, u);
|
||||
++_jitc->function->call.argi;
|
||||
|
|
@ -746,6 +848,7 @@ _jit_pushargr(jit_state_t *_jit, jit_int32_t u)
|
|||
jit_stxi(_jitc->function->call.size, JIT_SP, u);
|
||||
_jitc->function->call.size += sizeof(jit_word_t);
|
||||
}
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
void
|
||||
|
|
@ -753,6 +856,8 @@ _jit_pushargi(jit_state_t *_jit, jit_word_t u)
|
|||
{
|
||||
jit_int32_t regno;
|
||||
assert(_jitc->function);
|
||||
jit_inc_synth_w(pushargi, u);
|
||||
jit_link_prepare();
|
||||
if (jit_arg_reg_p(_jitc->function->call.argi)) {
|
||||
jit_movi(JIT_RA0 - _jitc->function->call.argi, u);
|
||||
++_jitc->function->call.argi;
|
||||
|
|
@ -764,28 +869,33 @@ _jit_pushargi(jit_state_t *_jit, jit_word_t u)
|
|||
jit_unget_reg(regno);
|
||||
_jitc->function->call.size += sizeof(jit_word_t);
|
||||
}
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
void
|
||||
_jit_pushargr_f(jit_state_t *_jit, jit_int32_t u)
|
||||
{
|
||||
assert(_jitc->function);
|
||||
jit_inc_synth_w(pushargr_f, u);
|
||||
jit_link_prepare();
|
||||
if (jit_cpu.abi && !(_jitc->function->call.call & jit_call_varargs)) {
|
||||
if (jit_arg_f_reg_p(_jitc->function->call.argf)) {
|
||||
jit_movr_f(JIT_FA0 - _jitc->function->call.argf, u);
|
||||
++_jitc->function->call.argf;
|
||||
return;
|
||||
goto done;
|
||||
}
|
||||
}
|
||||
else {
|
||||
if (jit_arg_reg_p(_jitc->function->call.argi)) {
|
||||
jit_movr_f_w(JIT_RA0 - _jitc->function->call.argi, u);
|
||||
++_jitc->function->call.argi;
|
||||
return;
|
||||
goto done;
|
||||
}
|
||||
}
|
||||
jit_stxi_f(_jitc->function->call.size, JIT_SP, u);
|
||||
_jitc->function->call.size += sizeof(jit_word_t);
|
||||
done:
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
void
|
||||
|
|
@ -793,6 +903,8 @@ _jit_pushargi_f(jit_state_t *_jit, jit_float32_t u)
|
|||
{
|
||||
jit_int32_t regno;
|
||||
assert(_jitc->function);
|
||||
jit_inc_synth_f(pushargi_f, u);
|
||||
jit_link_prepare();
|
||||
if (jit_cpu.abi && !(_jitc->function->call.call & jit_call_varargs)) {
|
||||
if (jit_arg_f_reg_p(_jitc->function->call.argf)) {
|
||||
/* cannot jit_movi_f in the argument register because
|
||||
|
|
@ -804,14 +916,14 @@ _jit_pushargi_f(jit_state_t *_jit, jit_float32_t u)
|
|||
jit_movr_f(JIT_FA0 - _jitc->function->call.argf, regno);
|
||||
jit_unget_reg(regno);
|
||||
++_jitc->function->call.argf;
|
||||
return;
|
||||
goto done;
|
||||
}
|
||||
}
|
||||
else {
|
||||
if (jit_arg_reg_p(_jitc->function->call.argi)) {
|
||||
jit_movi_f_w(JIT_RA0 - _jitc->function->call.argi, u);
|
||||
++_jitc->function->call.argi;
|
||||
return;
|
||||
goto done;
|
||||
}
|
||||
}
|
||||
regno = jit_get_reg(jit_class_fpr);
|
||||
|
|
@ -819,19 +931,23 @@ _jit_pushargi_f(jit_state_t *_jit, jit_float32_t u)
|
|||
jit_stxi_f(_jitc->function->call.size, JIT_SP, regno);
|
||||
jit_unget_reg(regno);
|
||||
_jitc->function->call.size += sizeof(jit_word_t);
|
||||
done:
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
void
|
||||
_jit_pushargr_d(jit_state_t *_jit, jit_int32_t u)
|
||||
{
|
||||
assert(_jitc->function);
|
||||
jit_inc_synth_w(pushargr_d, u);
|
||||
jit_link_prepare();
|
||||
if (jit_cpu.abi && !(_jitc->function->call.call & jit_call_varargs)) {
|
||||
if (jit_arg_d_reg_p(_jitc->function->call.argf)) {
|
||||
if (_jitc->function->call.argf & 1)
|
||||
++_jitc->function->call.argf;
|
||||
jit_movr_d(JIT_FA0 - _jitc->function->call.argf, u);
|
||||
_jitc->function->call.argf += 2;
|
||||
return;
|
||||
goto done;
|
||||
}
|
||||
}
|
||||
else {
|
||||
|
|
@ -842,13 +958,15 @@ _jit_pushargr_d(jit_state_t *_jit, jit_int32_t u)
|
|||
JIT_RA0 - (_jitc->function->call.argi + 1),
|
||||
u);
|
||||
_jitc->function->call.argi += 2;
|
||||
return;
|
||||
goto done;
|
||||
}
|
||||
}
|
||||
if (_jitc->function->call.size & 7)
|
||||
_jitc->function->call.size += 4;
|
||||
jit_stxi_d(_jitc->function->call.size, JIT_SP, u);
|
||||
_jitc->function->call.size += sizeof(jit_float64_t);
|
||||
done:
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
void
|
||||
|
|
@ -856,13 +974,15 @@ _jit_pushargi_d(jit_state_t *_jit, jit_float64_t u)
|
|||
{
|
||||
jit_int32_t regno;
|
||||
assert(_jitc->function);
|
||||
jit_inc_synth_d(pushargi_d, u);
|
||||
jit_link_prepare();
|
||||
if (jit_cpu.abi && !(_jitc->function->call.call & jit_call_varargs)) {
|
||||
if (jit_arg_d_reg_p(_jitc->function->call.argf)) {
|
||||
if (_jitc->function->call.argf & 1)
|
||||
++_jitc->function->call.argf;
|
||||
jit_movi_d(JIT_FA0 - _jitc->function->call.argf, u);
|
||||
_jitc->function->call.argf += 2;
|
||||
return;
|
||||
goto done;
|
||||
}
|
||||
}
|
||||
else {
|
||||
|
|
@ -873,7 +993,7 @@ _jit_pushargi_d(jit_state_t *_jit, jit_float64_t u)
|
|||
JIT_RA0 - (_jitc->function->call.argi + 1),
|
||||
u);
|
||||
_jitc->function->call.argi += 2;
|
||||
return;
|
||||
goto done;
|
||||
}
|
||||
}
|
||||
if (_jitc->function->call.size & 7)
|
||||
|
|
@ -883,6 +1003,8 @@ _jit_pushargi_d(jit_state_t *_jit, jit_float64_t u)
|
|||
jit_stxi_d(_jitc->function->call.size, JIT_SP, regno);
|
||||
jit_unget_reg(regno);
|
||||
_jitc->function->call.size += sizeof(jit_float64_t);
|
||||
done:
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
jit_bool_t
|
||||
|
|
@ -909,6 +1031,7 @@ _jit_finishr(jit_state_t *_jit, jit_int32_t r0)
|
|||
{
|
||||
jit_node_t *node;
|
||||
assert(_jitc->function);
|
||||
jit_inc_synth_w(finishr, r0);
|
||||
if (_jitc->function->self.alen < _jitc->function->call.size)
|
||||
_jitc->function->self.alen = _jitc->function->call.size;
|
||||
node = jit_callr(r0);
|
||||
|
|
@ -917,6 +1040,7 @@ _jit_finishr(jit_state_t *_jit, jit_int32_t r0)
|
|||
_jitc->function->call.argi = _jitc->function->call.argf =
|
||||
_jitc->function->call.size = 0;
|
||||
_jitc->prepare = 0;
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
jit_node_t *
|
||||
|
|
@ -924,6 +1048,7 @@ _jit_finishi(jit_state_t *_jit, jit_pointer_t i0)
|
|||
{
|
||||
jit_node_t *node;
|
||||
assert(_jitc->function);
|
||||
jit_inc_synth_w(finishi, (jit_word_t)i0);
|
||||
if (_jitc->function->self.alen < _jitc->function->call.size)
|
||||
_jitc->function->self.alen = _jitc->function->call.size;
|
||||
node = jit_calli(i0);
|
||||
|
|
@ -932,60 +1057,75 @@ _jit_finishi(jit_state_t *_jit, jit_pointer_t i0)
|
|||
_jitc->function->call.argi = _jitc->function->call.argf =
|
||||
_jitc->function->call.size = 0;
|
||||
_jitc->prepare = 0;
|
||||
jit_dec_synth();
|
||||
return (node);
|
||||
}
|
||||
|
||||
void
|
||||
_jit_retval_c(jit_state_t *_jit, jit_int32_t r0)
|
||||
{
|
||||
jit_inc_synth_w(retval_c, r0);
|
||||
jit_extr_c(r0, JIT_RET);
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
void
|
||||
_jit_retval_uc(jit_state_t *_jit, jit_int32_t r0)
|
||||
{
|
||||
jit_inc_synth_w(retval_uc, r0);
|
||||
jit_extr_uc(r0, JIT_RET);
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
void
|
||||
_jit_retval_s(jit_state_t *_jit, jit_int32_t r0)
|
||||
{
|
||||
jit_inc_synth_w(retval_s, r0);
|
||||
jit_extr_s(r0, JIT_RET);
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
void
|
||||
_jit_retval_us(jit_state_t *_jit, jit_int32_t r0)
|
||||
{
|
||||
jit_inc_synth_w(retval_us, r0);
|
||||
jit_extr_us(r0, JIT_RET);
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
void
|
||||
_jit_retval_i(jit_state_t *_jit, jit_int32_t r0)
|
||||
{
|
||||
jit_inc_synth_w(retval_i, r0);
|
||||
if (r0 != JIT_RET)
|
||||
jit_movr(r0, JIT_RET);
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
void
|
||||
_jit_retval_f(jit_state_t *_jit, jit_int32_t r0)
|
||||
{
|
||||
jit_inc_synth_w(retval_f, r0);
|
||||
if (jit_cpu.abi) {
|
||||
if (r0 != JIT_FRET)
|
||||
jit_movr_f(r0, JIT_FRET);
|
||||
}
|
||||
else if (r0 != JIT_RET)
|
||||
jit_movr_w_f(r0, JIT_RET);
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
void
|
||||
_jit_retval_d(jit_state_t *_jit, jit_int32_t r0)
|
||||
{
|
||||
jit_inc_synth_w(retval_d, r0);
|
||||
if (jit_cpu.abi) {
|
||||
if (r0 != JIT_FRET)
|
||||
jit_movr_d(r0, JIT_FRET);
|
||||
}
|
||||
else if (r0 != JIT_RET)
|
||||
jit_movr_ww_d(r0, JIT_RET, _R1);
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
jit_pointer_t
|
||||
|
|
@ -1000,6 +1140,9 @@ _emit_code(jit_state_t *_jit)
|
|||
jit_node_t *node;
|
||||
jit_uint8_t *data;
|
||||
jit_word_t word;
|
||||
#if DEVEL_DISASSEMBLER
|
||||
jit_word_t prevw;
|
||||
#endif
|
||||
jit_uword_t thumb;
|
||||
#if DISASSEMBLER
|
||||
jit_int32_t info_offset;
|
||||
|
|
@ -1007,12 +1150,18 @@ _emit_code(jit_state_t *_jit)
|
|||
jit_int32_t const_offset;
|
||||
jit_int32_t patch_offset;
|
||||
} undo;
|
||||
#if DEVEL_DISASSEMBLER
|
||||
jit_word_t prevw;
|
||||
#endif
|
||||
|
||||
_jitc->function = NULL;
|
||||
_jitc->thumb = 0;
|
||||
|
||||
jit_reglive_setup();
|
||||
|
||||
_jitc->consts.data = NULL;
|
||||
_jitc->consts.offset = _jitc->consts.length = 0;
|
||||
|
||||
undo.word = 0;
|
||||
undo.node = NULL;
|
||||
undo.data = NULL;
|
||||
|
|
@ -1228,12 +1377,16 @@ _emit_code(jit_state_t *_jit)
|
|||
patch(word, node); \
|
||||
} \
|
||||
break
|
||||
#if DEVEL_DISASSEMBLER
|
||||
prevw = _jit->pc.w;
|
||||
#endif
|
||||
for (node = _jitc->head; node; node = node->next) {
|
||||
if (_jit->pc.uc >= _jitc->code.end)
|
||||
return (NULL);
|
||||
|
||||
#if DEVEL_DISASSEMBLER
|
||||
node->offset = _jit->pc.w;
|
||||
node->offset = (jit_uword_t)_jit->pc.w - (jit_uword_t)prevw;
|
||||
prevw = _jit->pc.w;
|
||||
#endif
|
||||
value = jit_classify(node->code);
|
||||
jit_regarg_set(node, value);
|
||||
|
|
@ -1634,6 +1787,9 @@ _emit_code(jit_state_t *_jit)
|
|||
_jitc->function = _jitc->functions.ptr + node->w.w;
|
||||
undo.node = node;
|
||||
undo.word = _jit->pc.w;
|
||||
#if DEVEL_DISASSEMBLER
|
||||
undo.prevw = prevw;
|
||||
#endif
|
||||
undo.data = _jitc->consts.data;
|
||||
undo.thumb = _jitc->thumb;
|
||||
undo.const_offset = _jitc->consts.offset;
|
||||
|
|
@ -1658,6 +1814,9 @@ _emit_code(jit_state_t *_jit)
|
|||
temp->flag &= ~jit_flag_patch;
|
||||
node = undo.node;
|
||||
_jit->pc.w = undo.word;
|
||||
#if DEVEL_DISASSEMBLER
|
||||
prevw = undo.prevw;
|
||||
#endif
|
||||
invalidate_consts();
|
||||
_jitc->consts.data = undo.data;
|
||||
_jitc->thumb = undo.thumb;
|
||||
|
|
@ -1726,16 +1885,37 @@ _emit_code(jit_state_t *_jit)
|
|||
else
|
||||
vfp_vaarg_d(rn(node->u.w), rn(node->v.w));
|
||||
break;
|
||||
case jit_code_live:
|
||||
case jit_code_live: case jit_code_ellipsis:
|
||||
case jit_code_allocai: case jit_code_allocar:
|
||||
case jit_code_arg:
|
||||
case jit_code_arg_f: case jit_code_arg_d:
|
||||
case jit_code_va_end:
|
||||
case jit_code_ret:
|
||||
case jit_code_retr: case jit_code_reti:
|
||||
case jit_code_retr_f: case jit_code_reti_f:
|
||||
case jit_code_retr_d: case jit_code_reti_d:
|
||||
case jit_code_getarg_c: case jit_code_getarg_uc:
|
||||
case jit_code_getarg_s: case jit_code_getarg_us:
|
||||
case jit_code_getarg_i:
|
||||
case jit_code_getarg_f: case jit_code_getarg_d:
|
||||
case jit_code_putargr: case jit_code_putargi:
|
||||
case jit_code_putargr_f: case jit_code_putargi_f:
|
||||
case jit_code_putargr_d: case jit_code_putargi_d:
|
||||
case jit_code_pushargr: case jit_code_pushargi:
|
||||
case jit_code_pushargr_f: case jit_code_pushargi_f:
|
||||
case jit_code_pushargr_d: case jit_code_pushargi_d:
|
||||
case jit_code_retval_c: case jit_code_retval_uc:
|
||||
case jit_code_retval_s: case jit_code_retval_us:
|
||||
case jit_code_retval_i:
|
||||
case jit_code_retval_f: case jit_code_retval_d:
|
||||
case jit_code_prepare:
|
||||
case jit_code_finishr: case jit_code_finishi:
|
||||
break;
|
||||
default:
|
||||
abort();
|
||||
}
|
||||
jit_regarg_clr(node, value);
|
||||
assert(_jitc->regarg == 0);
|
||||
assert(_jitc->regarg == 0 && _jitc->synth == 0);
|
||||
/* update register live state */
|
||||
jit_reglive(node);
|
||||
|
||||
|
|
@ -1807,6 +1987,7 @@ _emit_code(jit_state_t *_jit)
|
|||
}
|
||||
|
||||
#define CODE 1
|
||||
# include "jit_rewind.c"
|
||||
# include "jit_arm-cpu.c"
|
||||
# include "jit_arm-swf.c"
|
||||
# include "jit_arm-vfp.c"
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue