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
174
lib/jit_ia64.c
174
lib/jit_ia64.c
|
|
@ -277,6 +277,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;
|
||||
|
|
@ -301,6 +305,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);
|
||||
}
|
||||
|
||||
|
|
@ -309,75 +317,86 @@ _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, -16);
|
||||
|
||||
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);
|
||||
jit_movr(JIT_RET, u);
|
||||
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);
|
||||
jit_movr_f(JIT_FRET, u);
|
||||
jit_ret();
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
void
|
||||
_jit_reti_f(jit_state_t *_jit, jit_float32_t u)
|
||||
{
|
||||
jit_inc_synth_f(reti_f, u);
|
||||
jit_movi_f(JIT_FRET, 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);
|
||||
jit_movr_d(JIT_FRET, u);
|
||||
jit_ret();
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
void
|
||||
_jit_reti_d(jit_state_t *_jit, jit_float64_t u)
|
||||
{
|
||||
jit_inc_synth_d(reti_d, u);
|
||||
jit_movi_d(JIT_FRET, u);
|
||||
jit_ret();
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
void
|
||||
|
|
@ -400,11 +419,14 @@ _jit_arg_register_p(jit_state_t *_jit, jit_node_t *u)
|
|||
void
|
||||
_jit_ellipsis(jit_state_t *_jit)
|
||||
{
|
||||
jit_inc_synth(ellipsis);
|
||||
if (_jitc->prepare) {
|
||||
jit_link_prepare();
|
||||
assert(!(_jitc->function->call.call & jit_call_varargs));
|
||||
_jitc->function->call.call |= jit_call_varargs;
|
||||
}
|
||||
else {
|
||||
jit_link_prolog();
|
||||
assert(!(_jitc->function->self.call & jit_call_varargs));
|
||||
_jitc->function->self.call |= jit_call_varargs;
|
||||
|
||||
|
|
@ -413,13 +435,14 @@ _jit_ellipsis(jit_state_t *_jit)
|
|||
|
||||
_jitc->function->vagp = _jitc->function->self.argi;
|
||||
}
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
jit_node_t *
|
||||
_jit_arg(jit_state_t *_jit)
|
||||
{
|
||||
jit_int32_t offset;
|
||||
|
||||
jit_node_t *node;
|
||||
jit_int32_t offset;
|
||||
assert(_jitc->function);
|
||||
if (jit_arg_reg_p(_jitc->function->self.argi))
|
||||
offset = _jitc->function->self.argi++;
|
||||
|
|
@ -427,14 +450,17 @@ _jit_arg(jit_state_t *_jit)
|
|||
offset = _jitc->function->self.size;
|
||||
_jitc->function->self.size += sizeof(jit_word_t);
|
||||
}
|
||||
return (jit_new_node_w(jit_code_arg, offset));
|
||||
node = jit_new_node_ww(jit_code_arg, offset,
|
||||
++_jitc->function->self.argn);
|
||||
jit_link_prolog();
|
||||
return (node);
|
||||
}
|
||||
|
||||
jit_node_t *
|
||||
_jit_arg_f(jit_state_t *_jit)
|
||||
{
|
||||
jit_int32_t offset;
|
||||
|
||||
jit_node_t *node;
|
||||
jit_int32_t offset;
|
||||
assert(_jitc->function);
|
||||
if (jit_arg_reg_p(_jitc->function->self.argi))
|
||||
offset = _jitc->function->self.argi++;
|
||||
|
|
@ -442,14 +468,17 @@ _jit_arg_f(jit_state_t *_jit)
|
|||
offset = _jitc->function->self.size;
|
||||
_jitc->function->self.size += sizeof(jit_word_t);
|
||||
}
|
||||
return (jit_new_node_w(jit_code_arg_f, offset));
|
||||
node = jit_new_node_ww(jit_code_arg_f, offset,
|
||||
++_jitc->function->self.argn);
|
||||
jit_link_prolog();
|
||||
return (node);
|
||||
}
|
||||
|
||||
jit_node_t *
|
||||
_jit_arg_d(jit_state_t *_jit)
|
||||
{
|
||||
jit_int32_t offset;
|
||||
|
||||
jit_node_t *node;
|
||||
jit_int32_t offset;
|
||||
assert(_jitc->function);
|
||||
if (jit_arg_reg_p(_jitc->function->self.argi))
|
||||
offset = _jitc->function->self.argi++;
|
||||
|
|
@ -457,87 +486,106 @@ _jit_arg_d(jit_state_t *_jit)
|
|||
offset = _jitc->function->self.size;
|
||||
_jitc->function->self.size += sizeof(jit_word_t);
|
||||
}
|
||||
return (jit_new_node_w(jit_code_arg_d, offset));
|
||||
node = jit_new_node_ww(jit_code_arg_d, offset,
|
||||
++_jitc->function->self.argn);
|
||||
jit_link_prolog();
|
||||
return (node);
|
||||
}
|
||||
|
||||
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_arg_reg_p(v->u.w))
|
||||
jit_extr_c(u, _R32 + v->u.w);
|
||||
else
|
||||
jit_ldxi_c(u, JIT_FP, v->u.w + C_DISP);
|
||||
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_arg_reg_p(v->u.w))
|
||||
jit_extr_uc(u, _R32 + v->u.w);
|
||||
else
|
||||
jit_ldxi_uc(u, JIT_FP, v->u.w + C_DISP);
|
||||
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_arg_reg_p(v->u.w))
|
||||
jit_extr_s(u, _R32 + v->u.w);
|
||||
else
|
||||
jit_ldxi_s(u, JIT_FP, v->u.w + S_DISP);
|
||||
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_arg_reg_p(v->u.w))
|
||||
jit_extr_us(u, _R32 + v->u.w);
|
||||
else
|
||||
jit_ldxi_us(u, JIT_FP, v->u.w + S_DISP);
|
||||
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_arg_reg_p(v->u.w))
|
||||
jit_extr_i(u, _R32 + v->u.w);
|
||||
else
|
||||
jit_ldxi_i(u, JIT_FP, v->u.w + I_DISP);
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
void
|
||||
_jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
||||
{
|
||||
assert(v->code == jit_code_arg);
|
||||
jit_inc_synth_wp(getarg_ui, u, v);
|
||||
if (jit_arg_reg_p(v->u.w))
|
||||
jit_extr_ui(u, _R32 + v->u.w);
|
||||
else
|
||||
jit_ldxi_ui(u, JIT_FP, v->u.w + I_DISP);
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
void
|
||||
_jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
||||
{
|
||||
assert(v->code == jit_code_arg);
|
||||
jit_inc_synth_wp(getarg_l, u, v);
|
||||
if (jit_arg_reg_p(v->u.w))
|
||||
jit_movr(u, _R32 + v->u.w);
|
||||
else
|
||||
jit_ldxi(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_arg_reg_p(v->u.w))
|
||||
jit_movr(_R32 + v->u.w, u);
|
||||
else
|
||||
jit_stxi(v->u.w, JIT_FP, u);
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
void
|
||||
|
|
@ -545,6 +593,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_arg_reg_p(v->u.w))
|
||||
jit_movi(_R32 + v->u.w, u);
|
||||
else {
|
||||
|
|
@ -553,26 +602,31 @@ _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);
|
||||
jit_inc_synth_wp(getarg_f, u, v);
|
||||
if (jit_arg_reg_p(v->u.w))
|
||||
jit_movr_f(u, _F8 + v->u.w);
|
||||
else
|
||||
jit_ldxi_f(u, JIT_FP, v->u.w + F_DISP);
|
||||
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_arg_reg_p(v->u.w))
|
||||
jit_movr_f(_F8 + v->u.w, u);
|
||||
else
|
||||
jit_stxi_f(v->u.w, JIT_FP, u + F_DISP);
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
void
|
||||
|
|
@ -580,6 +634,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_arg_reg_p(v->u.w))
|
||||
jit_movi_f(_F8 + v->u.w, u);
|
||||
else {
|
||||
|
|
@ -588,26 +643,31 @@ _jit_putargi_f(jit_state_t *_jit, jit_float32_t u, jit_node_t *v)
|
|||
jit_stxi_f(v->u.w, JIT_FP, regno + F_DISP);
|
||||
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);
|
||||
jit_inc_synth_wp(getarg_d, u, v);
|
||||
if (jit_arg_reg_p(v->u.w))
|
||||
jit_movr_d(u, _F8 + v->u.w);
|
||||
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_arg_reg_p(v->u.w))
|
||||
jit_movr_d(_F8 + v->u.w, u);
|
||||
else
|
||||
jit_stxi_d(v->u.w, JIT_FP, u);
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
void
|
||||
|
|
@ -615,6 +675,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_arg_reg_p(v->u.w))
|
||||
jit_movi_d(_F8 + v->u.w, u);
|
||||
else {
|
||||
|
|
@ -623,12 +684,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(_OUT0 + _jitc->function->call.argi, u);
|
||||
++_jitc->function->call.argi;
|
||||
|
|
@ -637,6 +701,7 @@ _jit_pushargr(jit_state_t *_jit, jit_int32_t u)
|
|||
jit_stxi(_jitc->function->call.size + params_offset, JIT_SP, u);
|
||||
_jitc->function->call.size += sizeof(jit_word_t);
|
||||
}
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
void
|
||||
|
|
@ -644,6 +709,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(_OUT0 + _jitc->function->call.argi, u);
|
||||
++_jitc->function->call.argi;
|
||||
|
|
@ -655,12 +722,15 @@ _jit_pushargi(jit_state_t *_jit, jit_word_t u)
|
|||
_jitc->function->call.size += sizeof(jit_word_t);
|
||||
jit_unget_reg(regno);
|
||||
}
|
||||
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_arg_reg_p(_jitc->function->call.argi)) {
|
||||
if (!(_jitc->function->call.call & jit_call_varargs))
|
||||
jit_movr_f(_F8 + _jitc->function->call.argi, u);
|
||||
|
|
@ -673,6 +743,7 @@ _jit_pushargr_f(jit_state_t *_jit, jit_int32_t u)
|
|||
JIT_SP, u);
|
||||
_jitc->function->call.size += sizeof(jit_word_t);
|
||||
}
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
void
|
||||
|
|
@ -680,6 +751,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_arg_reg_p(_jitc->function->call.argi)) {
|
||||
if (!(_jitc->function->call.call & jit_call_varargs))
|
||||
jit_movi_f(_F8 + _jitc->function->call.argi, u);
|
||||
|
|
@ -695,12 +768,15 @@ _jit_pushargi_f(jit_state_t *_jit, jit_float32_t u)
|
|||
_jitc->function->call.size += sizeof(jit_word_t);
|
||||
jit_unget_reg(regno);
|
||||
}
|
||||
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_arg_reg_p(_jitc->function->call.argi)) {
|
||||
if (!(_jitc->function->call.call & jit_call_varargs))
|
||||
jit_movr_d(_F8 + _jitc->function->call.argi, u);
|
||||
|
|
@ -712,6 +788,7 @@ _jit_pushargr_d(jit_state_t *_jit, jit_int32_t u)
|
|||
jit_stxi_d(_jitc->function->call.size + params_offset, JIT_SP, u);
|
||||
_jitc->function->call.size += sizeof(jit_word_t);
|
||||
}
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
void
|
||||
|
|
@ -719,6 +796,8 @@ _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_arg_reg_p(_jitc->function->call.argi)) {
|
||||
if (!(_jitc->function->call.call & jit_call_varargs))
|
||||
jit_movi_d(_F8 + _jitc->function->call.argi, u);
|
||||
|
|
@ -733,6 +812,7 @@ _jit_pushargi_d(jit_state_t *_jit, jit_float64_t u)
|
|||
_jitc->function->call.size += sizeof(jit_word_t);
|
||||
jit_unget_reg(regno);
|
||||
}
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
jit_bool_t
|
||||
|
|
@ -747,6 +827,7 @@ _jit_finishr(jit_state_t *_jit, jit_int32_t r0)
|
|||
{
|
||||
jit_node_t *call;
|
||||
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;
|
||||
call = jit_callr(r0);
|
||||
|
|
@ -755,6 +836,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 *
|
||||
|
|
@ -762,6 +844,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);
|
||||
|
|
@ -770,61 +853,80 @@ _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);
|
||||
jit_extr_i(r0, JIT_RET);
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
void
|
||||
_jit_retval_ui(jit_state_t *_jit, jit_int32_t r0)
|
||||
{
|
||||
jit_inc_synth_w(retval_ui, r0);
|
||||
jit_extr_ui(r0, JIT_RET);
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
void
|
||||
_jit_retval_l(jit_state_t *_jit, jit_int32_t r0)
|
||||
{
|
||||
jit_inc_synth_w(retval_l, r0);
|
||||
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_l, r0);
|
||||
jit_movr_f(r0, JIT_FRET);
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
void
|
||||
_jit_retval_d(jit_state_t *_jit, jit_int32_t r0)
|
||||
{
|
||||
jit_inc_synth_w(retval_d, r0);
|
||||
jit_movr_d(r0, JIT_FRET);
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
jit_pointer_t
|
||||
|
|
@ -838,9 +940,15 @@ _emit_code(jit_state_t *_jit)
|
|||
struct {
|
||||
jit_node_t *node;
|
||||
jit_word_t word;
|
||||
#if DEVEL_DISASSEMBLER
|
||||
jit_word_t prevw;
|
||||
#endif
|
||||
jit_int32_t patch_offset;
|
||||
jit_word_t prolog_offset;
|
||||
} undo;
|
||||
#if DEVEL_DISASSEMBLER
|
||||
jit_word_t prevw;
|
||||
#endif
|
||||
|
||||
_jitc->function = NULL;
|
||||
|
||||
|
|
@ -855,6 +963,9 @@ _emit_code(jit_state_t *_jit)
|
|||
undo.node = NULL;
|
||||
undo.patch_offset = 0;
|
||||
|
||||
#if DEVEL_DISASSEMBLER
|
||||
prevw = _jit->pc.w;
|
||||
#endif
|
||||
undo.prolog_offset = 0;
|
||||
for (node = _jitc->head; node; node = node->next)
|
||||
if (node->code != jit_code_label &&
|
||||
|
|
@ -961,7 +1072,8 @@ _emit_code(jit_state_t *_jit)
|
|||
#endif
|
||||
#if DEVEL_DISASSEMBLER
|
||||
sync();
|
||||
node->offset = _jit->pc.w;
|
||||
node->offset = (jit_uword_t)_jit->pc.w - (jit_uword_t)prevw;
|
||||
prevw = _jit->pc.w;
|
||||
#endif
|
||||
jit_regarg_set(node, value);
|
||||
switch (node->code) {
|
||||
|
|
@ -1368,6 +1480,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.patch_offset = _jitc->patches.offset;
|
||||
undo.prolog_offset = _jitc->prolog.offset;
|
||||
restart_function:
|
||||
|
|
@ -1403,6 +1518,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
|
||||
_jitc->patches.offset = undo.patch_offset;
|
||||
_jitc->prolog.offset = undo.prolog_offset;
|
||||
_jitc->ioff = 0;
|
||||
|
|
@ -1429,9 +1547,32 @@ _emit_code(jit_state_t *_jit)
|
|||
vaarg_d(rn(node->u.w), rn(node->v.w));
|
||||
break;
|
||||
case jit_code_live:
|
||||
case jit_code_arg:
|
||||
case jit_code_arg: case jit_code_ellipsis:
|
||||
case jit_code_allocai: case jit_code_allocar:
|
||||
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_ui:
|
||||
case jit_code_getarg_l:
|
||||
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_ui: case jit_code_retval_l:
|
||||
case jit_code_retval_f: case jit_code_retval_d:
|
||||
case jit_code_prepare:
|
||||
case jit_code_finishr: case jit_code_finishi:
|
||||
break;
|
||||
case jit_code_movr_f_w:
|
||||
movr_f_w(rn(node->u.w), rn(node->v.w));
|
||||
|
|
@ -1472,6 +1613,7 @@ _emit_code(jit_state_t *_jit)
|
|||
assert(jit_regset_scan1(&_jitc->regarg, 0) == jit_carry);
|
||||
assert(jit_regset_scan1(&_jitc->regarg, jit_carry + 1) == ULONG_MAX);
|
||||
}
|
||||
assert(_jitc->synth == 0);
|
||||
/* update register live state */
|
||||
jit_reglive(node);
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue