mirror of
https://git.savannah.gnu.org/git/guile.git
synced 2025-05-08 10:50:21 +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
313
lib/jit_mips.c
313
lib/jit_mips.c
|
|
@ -53,17 +53,22 @@
|
|||
/*
|
||||
* Types
|
||||
*/
|
||||
typedef struct jit_va_list {
|
||||
jit_pointer_t stack;
|
||||
} jit_va_list_t;
|
||||
typedef struct jit_pointer_t jit_va_list_t;
|
||||
|
||||
/*
|
||||
* Prototypes
|
||||
*/
|
||||
# define patch(instr, node) _patch(_jit, instr, node)
|
||||
#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 patch(instr, node) _patch(_jit, instr, node)
|
||||
static void _patch(jit_state_t*,jit_word_t,jit_node_t*);
|
||||
|
||||
#define PROTO 1
|
||||
# include "jit_rewind.c"
|
||||
# include "jit_mips-cpu.c"
|
||||
# include "jit_mips-fpu.c"
|
||||
#undef PROTO
|
||||
|
|
@ -189,6 +194,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;
|
||||
|
|
@ -213,6 +222,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);
|
||||
}
|
||||
|
||||
|
|
@ -221,6 +234,7 @@ _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;
|
||||
|
|
@ -233,69 +247,82 @@ _jit_allocar(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
|
|||
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_FRET != u)
|
||||
jit_movr_f(JIT_FRET, u);
|
||||
else
|
||||
jit_live(JIT_FRET);
|
||||
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);
|
||||
if (JIT_FRET != u)
|
||||
jit_movr_d(JIT_FRET, u);
|
||||
else
|
||||
jit_live(JIT_FRET);
|
||||
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
|
||||
|
|
@ -320,29 +347,10 @@ _jit_arg_register_p(jit_state_t *_jit, jit_node_t *u)
|
|||
#endif
|
||||
}
|
||||
|
||||
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;
|
||||
|
||||
/* Allocate va_list like object in the stack. */
|
||||
_jitc->function->vaoff = jit_allocai(sizeof(jit_va_list_t));
|
||||
|
||||
_jitc->function->vagp = _jitc->function->self.argi;
|
||||
}
|
||||
}
|
||||
|
||||
jit_node_t *
|
||||
_jit_arg(jit_state_t *_jit)
|
||||
{
|
||||
jit_int32_t offset;
|
||||
assert(_jitc->function);
|
||||
jit_int32_t offset;
|
||||
#if NEW_ABI
|
||||
if (jit_arg_reg_p(_jitc->function->self.argi))
|
||||
offset = _jitc->function->self.argi++;
|
||||
|
|
@ -357,14 +365,20 @@ _jit_arg(jit_state_t *_jit)
|
|||
offset = _jitc->function->self.size;
|
||||
_jitc->function->self.size += STACK_SLOT;
|
||||
#endif
|
||||
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)
|
||||
static jit_node_t *
|
||||
_jit_make_arg_f(jit_state_t *_jit, jit_node_t *node)
|
||||
{
|
||||
jit_int32_t offset;
|
||||
assert(_jitc->function);
|
||||
jit_int32_t offset;
|
||||
#if NEW_ABI
|
||||
if (jit_arg_reg_p(_jitc->function->self.argi))
|
||||
offset = _jitc->function->self.argi++;
|
||||
|
|
@ -375,27 +389,36 @@ _jit_arg_f(jit_state_t *_jit)
|
|||
#else
|
||||
offset = (_jitc->function->self.size - stack_framesize) >> STACK_SHIFT;
|
||||
if (offset < NUM_WORD_ARGS) {
|
||||
if (!_jitc->function->self.argi) {
|
||||
if (!_jitc->function->self.argi &&
|
||||
!(_jitc->function->self.call & jit_call_varargs)) {
|
||||
if (offset == 0)
|
||||
offset = 4;
|
||||
else {
|
||||
offset = 6;
|
||||
_jitc->function->self.argi = 1;
|
||||
}
|
||||
/* Use as flag to rewind in case of varargs function */
|
||||
++_jitc->function->self.argf;
|
||||
}
|
||||
}
|
||||
else
|
||||
offset = _jitc->function->self.size;
|
||||
_jitc->function->self.size += STACK_SLOT;
|
||||
#endif
|
||||
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)
|
||||
static jit_node_t *
|
||||
_jit_make_arg_d(jit_state_t *_jit, jit_node_t *node)
|
||||
{
|
||||
jit_int32_t offset;
|
||||
assert(_jitc->function);
|
||||
jit_int32_t offset;
|
||||
#if NEW_ABI
|
||||
if (jit_arg_reg_p(_jitc->function->self.argi))
|
||||
offset = _jitc->function->self.argi++;
|
||||
|
|
@ -410,60 +433,124 @@ _jit_arg_d(jit_state_t *_jit)
|
|||
}
|
||||
offset = (_jitc->function->self.size - stack_framesize) >> STACK_SHIFT;
|
||||
if (offset < NUM_WORD_ARGS) {
|
||||
if (!_jitc->function->self.argi)
|
||||
if (!_jitc->function->self.argi &&
|
||||
!(_jitc->function->self.call & jit_call_varargs)) {
|
||||
offset += 4;
|
||||
/* Use as flag to rewind in case of varargs function */
|
||||
++_jitc->function->self.argf;
|
||||
}
|
||||
}
|
||||
else
|
||||
offset = _jitc->function->self.size;
|
||||
_jitc->function->self.size += sizeof(jit_float64_t);
|
||||
#endif
|
||||
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 (_jitc->function->call.argf)
|
||||
rewind_prepare();
|
||||
}
|
||||
else {
|
||||
assert(!(_jitc->function->self.call & jit_call_varargs));
|
||||
_jitc->function->self.call |= jit_call_varargs;
|
||||
if (_jitc->function->self.argf)
|
||||
rewind_prolog();
|
||||
}
|
||||
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_arg_reg_p(v->u.w))
|
||||
jit_extr_c(u, _A0 - v->u.w);
|
||||
else
|
||||
jit_ldxi_c(u, _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, _A0 - v->u.w);
|
||||
else
|
||||
jit_ldxi_uc(u, _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, _A0 - v->u.w);
|
||||
else
|
||||
jit_ldxi_s(u, _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, _A0 - v->u.w);
|
||||
else
|
||||
jit_ldxi_us(u, _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)) {
|
||||
#if __WORDSIZE == 64
|
||||
jit_extr_i(u, _A0 - v->u.w);
|
||||
|
|
@ -473,6 +560,7 @@ _jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
|||
}
|
||||
else
|
||||
jit_ldxi_i(u, _FP, v->u.w + I_DISP);
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
#if __WORDSIZE == 64
|
||||
|
|
@ -480,31 +568,37 @@ 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, _A0 - v->u.w);
|
||||
else
|
||||
jit_ldxi_ui(u, _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, _A0 - v->u.w);
|
||||
else
|
||||
jit_ldxi_l(u, _FP, v->u.w);
|
||||
jit_dec_synth();
|
||||
}
|
||||
#endif
|
||||
|
||||
void
|
||||
_jit_putargr(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
||||
{
|
||||
jit_inc_synth_wp(putargr, u, v);
|
||||
assert(v->code == jit_code_arg);
|
||||
if (jit_arg_reg_p(v->u.w))
|
||||
jit_movr(_A0 - v->u.w, u);
|
||||
else
|
||||
jit_stxi(v->u.w, _FP, u);
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
void
|
||||
|
|
@ -512,6 +606,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(_A0 - v->u.w, u);
|
||||
else {
|
||||
|
|
@ -520,12 +615,14 @@ _jit_putargi(jit_state_t *_jit, jit_word_t u, jit_node_t *v)
|
|||
jit_stxi(v->u.w, _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 NEW_ABI
|
||||
if (jit_arg_reg_p(v->u.w))
|
||||
jit_movr_f(u, _F12 - v->u.w);
|
||||
|
|
@ -537,12 +634,14 @@ _jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
|||
#endif
|
||||
else
|
||||
jit_ldxi_f(u, _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 NEW_ABI
|
||||
if (jit_arg_reg_p(v->u.w))
|
||||
jit_movr_f(_F12 - v->u.w, u);
|
||||
|
|
@ -554,6 +653,7 @@ _jit_putargr_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
|||
#endif
|
||||
else
|
||||
jit_stxi_f(v->u.w, _FP, u);
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
void
|
||||
|
|
@ -561,6 +661,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 NEW_ABI
|
||||
if (jit_arg_reg_p(v->u.w))
|
||||
jit_movi_f(_F12 - v->u.w, u);
|
||||
|
|
@ -580,12 +681,14 @@ _jit_putargi_f(jit_state_t *_jit, jit_float32_t u, jit_node_t *v)
|
|||
jit_stxi_f(v->u.w, _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);
|
||||
jit_inc_synth_wp(getarg_d, u, v);
|
||||
#if NEW_ABI
|
||||
if (jit_arg_reg_p(v->u.w))
|
||||
jit_movr_d(u, _F12 - v->u.w);
|
||||
|
|
@ -597,12 +700,14 @@ _jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
|||
#endif
|
||||
else
|
||||
jit_ldxi_d(u, _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 NEW_ABI
|
||||
if (jit_arg_reg_p(v->u.w))
|
||||
jit_movr_d(_F12 - v->u.w, u);
|
||||
|
|
@ -614,6 +719,7 @@ _jit_putargr_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
|||
#endif
|
||||
else
|
||||
jit_stxi_d(v->u.w, _FP, u);
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
void
|
||||
|
|
@ -621,6 +727,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 NEW_ABI
|
||||
if (jit_arg_reg_p(v->u.w))
|
||||
jit_movi_d(_F12 - v->u.w, u);
|
||||
|
|
@ -640,11 +747,14 @@ _jit_putargi_d(jit_state_t *_jit, jit_float64_t u, jit_node_t *v)
|
|||
jit_stxi_d(v->u.w, _FP, regno);
|
||||
jit_unget_reg(regno);
|
||||
}
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
void
|
||||
_jit_pushargr(jit_state_t *_jit, jit_int32_t u)
|
||||
{
|
||||
jit_inc_synth_w(pushargr, u);
|
||||
jit_link_prepare();
|
||||
#if NEW_ABI
|
||||
assert(_jitc->function);
|
||||
if (jit_arg_reg_p(_jitc->function->call.argi)) {
|
||||
|
|
@ -666,14 +776,20 @@ _jit_pushargr(jit_state_t *_jit, jit_int32_t u)
|
|||
jit_stxi(_jitc->function->call.size, JIT_SP, u);
|
||||
_jitc->function->call.size += STACK_SLOT;
|
||||
#endif
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
void
|
||||
_jit_pushargi(jit_state_t *_jit, jit_word_t u)
|
||||
{
|
||||
#if NEW_ABI
|
||||
jit_int32_t regno;
|
||||
#if !NEW_ABI
|
||||
jit_word_t offset;
|
||||
#endif
|
||||
assert(_jitc->function);
|
||||
jit_inc_synth_w(pushargi, u);
|
||||
jit_link_prepare();
|
||||
#if NEW_ABI
|
||||
if (jit_arg_reg_p(_jitc->function->call.argi)) {
|
||||
jit_movi(_A0 - _jitc->function->call.argi, u);
|
||||
++_jitc->function->call.argi;
|
||||
|
|
@ -686,9 +802,6 @@ _jit_pushargi(jit_state_t *_jit, jit_word_t u)
|
|||
jit_unget_reg(regno);
|
||||
}
|
||||
#else
|
||||
jit_int32_t regno;
|
||||
jit_word_t offset;
|
||||
assert(_jitc->function);
|
||||
offset = _jitc->function->call.size >> STACK_SHIFT;
|
||||
++_jitc->function->call.argi;
|
||||
if (jit_arg_reg_p(offset))
|
||||
|
|
@ -701,13 +814,19 @@ _jit_pushargi(jit_state_t *_jit, jit_word_t u)
|
|||
}
|
||||
_jitc->function->call.size += STACK_SLOT;
|
||||
#endif
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
void
|
||||
_jit_pushargr_f(jit_state_t *_jit, jit_int32_t u)
|
||||
{
|
||||
#if NEW_ABI
|
||||
#if !NEW_ABI
|
||||
jit_word_t offset;
|
||||
#endif
|
||||
assert(_jitc->function);
|
||||
jit_inc_synth_w(pushargr_f, u);
|
||||
jit_link_prepare();
|
||||
#if NEW_ABI
|
||||
if (jit_arg_reg_p(_jitc->function->call.argi)) {
|
||||
if (!(_jitc->function->call.call & jit_call_varargs))
|
||||
jit_movr_f(_F12 - _jitc->function->call.argi, u);
|
||||
|
|
@ -720,10 +839,9 @@ _jit_pushargr_f(jit_state_t *_jit, jit_int32_t u)
|
|||
_jitc->function->call.size += STACK_SLOT;
|
||||
}
|
||||
#else
|
||||
jit_word_t offset;
|
||||
assert(_jitc->function);
|
||||
offset = _jitc->function->call.size >> STACK_SHIFT;
|
||||
if (offset < 2 && !_jitc->function->call.argi) {
|
||||
if (offset < 2 && !_jitc->function->call.argi &&
|
||||
!(_jitc->function->call.call & jit_call_varargs)) {
|
||||
++_jitc->function->call.argf;
|
||||
jit_movr_f(_F12 - offset, u);
|
||||
}
|
||||
|
|
@ -735,14 +853,20 @@ _jit_pushargr_f(jit_state_t *_jit, jit_int32_t u)
|
|||
jit_stxi_f(_jitc->function->call.size, JIT_SP, u);
|
||||
_jitc->function->call.size += STACK_SLOT;
|
||||
#endif
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
void
|
||||
_jit_pushargi_f(jit_state_t *_jit, jit_float32_t u)
|
||||
{
|
||||
jit_int32_t regno;
|
||||
#if NEW_ABI
|
||||
#if !NEW_ABI
|
||||
jit_word_t offset;
|
||||
#endif
|
||||
assert(_jitc->function);
|
||||
jit_inc_synth_f(pushargi_f, u);
|
||||
jit_link_prepare();
|
||||
#if NEW_ABI
|
||||
if (jit_arg_reg_p(_jitc->function->call.argi)) {
|
||||
if (!(_jitc->function->call.call & jit_call_varargs))
|
||||
jit_movi_f(_F12 - _jitc->function->call.argi, u);
|
||||
|
|
@ -758,10 +882,9 @@ _jit_pushargi_f(jit_state_t *_jit, jit_float32_t u)
|
|||
jit_unget_reg(regno);
|
||||
}
|
||||
#else
|
||||
jit_word_t offset;
|
||||
assert(_jitc->function);
|
||||
offset = _jitc->function->call.size >> STACK_SHIFT;
|
||||
if (offset < 2 && !_jitc->function->call.argi) {
|
||||
if (offset < 2 && !_jitc->function->call.argi &&
|
||||
!(_jitc->function->call.call & jit_call_varargs)) {
|
||||
++_jitc->function->call.argf;
|
||||
jit_movi_f(_F12 - offset, u);
|
||||
}
|
||||
|
|
@ -777,13 +900,20 @@ _jit_pushargi_f(jit_state_t *_jit, jit_float32_t u)
|
|||
}
|
||||
_jitc->function->call.size += STACK_SLOT;
|
||||
#endif
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
void
|
||||
_jit_pushargr_d(jit_state_t *_jit, jit_int32_t u)
|
||||
{
|
||||
#if NEW_ABI
|
||||
#if !NEW_ABI
|
||||
jit_bool_t adjust;
|
||||
jit_word_t offset;
|
||||
#endif
|
||||
assert(_jitc->function);
|
||||
jit_inc_synth_w(pushargr_d, u);
|
||||
jit_link_prepare();
|
||||
#if NEW_ABI
|
||||
if (jit_arg_reg_p(_jitc->function->call.argi)) {
|
||||
if (!(_jitc->function->call.call & jit_call_varargs))
|
||||
jit_movr_d(_F12 - _jitc->function->call.argi, u);
|
||||
|
|
@ -796,9 +926,6 @@ _jit_pushargr_d(jit_state_t *_jit, jit_int32_t u)
|
|||
_jitc->function->call.size += STACK_SLOT;
|
||||
}
|
||||
#else
|
||||
jit_bool_t adjust;
|
||||
jit_word_t offset;
|
||||
assert(_jitc->function);
|
||||
adjust = !!_jitc->function->call.argi;
|
||||
if (_jitc->function->call.size & 7) {
|
||||
_jitc->function->call.size += 4;
|
||||
|
|
@ -806,7 +933,7 @@ _jit_pushargr_d(jit_state_t *_jit, jit_int32_t u)
|
|||
}
|
||||
offset = _jitc->function->call.size >> STACK_SHIFT;
|
||||
if (offset < 3) {
|
||||
if (adjust) {
|
||||
if (adjust || (_jitc->function->call.call & jit_call_varargs)) {
|
||||
jit_movr_d_ww(_A0 - offset, _A0 - (offset + 1), u);
|
||||
_jitc->function->call.argi += 2;
|
||||
}
|
||||
|
|
@ -819,14 +946,21 @@ _jit_pushargr_d(jit_state_t *_jit, jit_int32_t u)
|
|||
jit_stxi_d(_jitc->function->call.size, JIT_SP, u);
|
||||
_jitc->function->call.size += sizeof(jit_float64_t);
|
||||
#endif
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
void
|
||||
_jit_pushargi_d(jit_state_t *_jit, jit_float64_t u)
|
||||
{
|
||||
jit_int32_t regno;
|
||||
#if NEW_ABI
|
||||
#if !NEW_ABI
|
||||
jit_bool_t adjust;
|
||||
jit_word_t offset;
|
||||
#endif
|
||||
assert(_jitc->function);
|
||||
jit_inc_synth_d(pushargi_d, u);
|
||||
jit_link_prepare();
|
||||
#if NEW_ABI
|
||||
if (jit_arg_reg_p(_jitc->function->call.argi)) {
|
||||
if (!(_jitc->function->call.call & jit_call_varargs))
|
||||
jit_movi_d(_F12 - _jitc->function->call.argi, u);
|
||||
|
|
@ -842,9 +976,6 @@ _jit_pushargi_d(jit_state_t *_jit, jit_float64_t u)
|
|||
jit_unget_reg(regno);
|
||||
}
|
||||
#else
|
||||
jit_bool_t adjust;
|
||||
jit_word_t offset;
|
||||
assert(_jitc->function);
|
||||
adjust = !!_jitc->function->call.argi;
|
||||
if (_jitc->function->call.size & 7) {
|
||||
_jitc->function->call.size += 4;
|
||||
|
|
@ -852,7 +983,7 @@ _jit_pushargi_d(jit_state_t *_jit, jit_float64_t u)
|
|||
}
|
||||
offset = _jitc->function->call.size >> STACK_SHIFT;
|
||||
if (offset < 3) {
|
||||
if (adjust) {
|
||||
if (adjust || (_jitc->function->call.call & jit_call_varargs)) {
|
||||
jit_movi_d_ww(_A0 - offset, _A0 - (offset + 1), u);
|
||||
_jitc->function->call.argi += 2;
|
||||
}
|
||||
|
|
@ -869,6 +1000,7 @@ _jit_pushargi_d(jit_state_t *_jit, jit_float64_t u)
|
|||
}
|
||||
_jitc->function->call.size += sizeof(jit_float64_t);
|
||||
#endif
|
||||
jit_dec_synth();
|
||||
}
|
||||
|
||||
jit_bool_t
|
||||
|
|
@ -897,8 +1029,8 @@ void
|
|||
_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;
|
||||
jit_movr(_T9, r0);
|
||||
|
|
@ -912,6 +1044,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 *
|
||||
|
|
@ -919,8 +1052,8 @@ _jit_finishi(jit_state_t *_jit, jit_pointer_t i0)
|
|||
{
|
||||
jit_node_t *call;
|
||||
jit_node_t *node;
|
||||
|
||||
assert(_jitc->function);
|
||||
jit_inc_synth_w(finishr, (jit_word_t)i0);
|
||||
if (_jitc->function->self.alen < _jitc->function->call.size)
|
||||
_jitc->function->self.alen = _jitc->function->call.size;
|
||||
node = jit_movi(_T9, (jit_word_t)i0);
|
||||
|
|
@ -934,6 +1067,7 @@ _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);
|
||||
}
|
||||
|
||||
|
|
@ -1012,8 +1146,14 @@ _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;
|
||||
} undo;
|
||||
#if DEVEL_DISASSEMBLER
|
||||
jit_word_t prevw;
|
||||
#endif
|
||||
|
||||
_jitc->function = NULL;
|
||||
|
||||
|
|
@ -1105,12 +1245,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);
|
||||
|
|
@ -1527,6 +1671,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;
|
||||
restart_function:
|
||||
_jitc->again = 0;
|
||||
|
|
@ -1544,6 +1691,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;
|
||||
goto restart_function;
|
||||
}
|
||||
|
|
@ -1596,9 +1746,36 @@ _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:
|
||||
#if __WORDSIZE == 64
|
||||
case jit_code_getarg_ui: case jit_code_getarg_l:
|
||||
#endif
|
||||
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:
|
||||
#if __WORDSIZE == 64
|
||||
case jit_code_retval_ui: case jit_code_retval_l:
|
||||
#endif
|
||||
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();
|
||||
|
|
@ -1619,6 +1796,7 @@ _emit_code(jit_state_t *_jit)
|
|||
}
|
||||
jit_regarg_clr(node, value);
|
||||
assert(_jitc->regarg == jit_carry == _NOREG ? 0 : (1 << jit_carry));
|
||||
assert(_jitc->synth == 0);
|
||||
/* update register live state */
|
||||
jit_reglive(node);
|
||||
}
|
||||
|
|
@ -1645,6 +1823,7 @@ _emit_code(jit_state_t *_jit)
|
|||
}
|
||||
|
||||
#define CODE 1
|
||||
# include "jit_rewind.c"
|
||||
# include "jit_mips-cpu.c"
|
||||
# include "jit_mips-fpu.c"
|
||||
#undef CODE
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue