mirror of
https://git.savannah.gnu.org/git/guile.git
synced 2025-06-29 06:20:30 +02:00
Change type of return of jit_arg* and argument to jit_getarg*
* check/lightning.c, include/lightning.h, lib/jit_arm.c,
lib/jit_mips.c, lib/jit_ppc.c, lib/jit_print.c, lib/jit_x86.c,
lib/lightning.c: Change return value of jit_arg{,_f,_d} to
a jit_node_t* object, that should be used as argument to
jit_getarg_{c,uc,s,us,i,ui,l,f,d}. This just requires changing
from jit_int32_t to jit_pointer_t (or jit_node_t*) the "handle"
for the getarg calls, with the benefit that it makes it easy
to implement patching of the stack address of non register
arguments, this way allowing to implement variable size stack
frames if applicable; useful if there are too many registers and
jit functions uses only a few callee save registers.
This commit is contained in:
pcpa
parent
1287a2d448
commit
2e6c680d70
9 changed files with 304 additions and 256 deletions
151
lib/jit_arm.c
151
lib/jit_arm.c
|
|
@ -327,7 +327,7 @@ _jit_epilog(jit_state_t *_jit)
|
|||
_jit->function = NULL;
|
||||
}
|
||||
|
||||
jit_int32_t
|
||||
jit_node_t *
|
||||
_jit_arg(jit_state_t *_jit)
|
||||
{
|
||||
jit_int32_t offset;
|
||||
|
|
@ -339,7 +339,7 @@ _jit_arg(jit_state_t *_jit)
|
|||
offset = _jit->function->self.size;
|
||||
_jit->function->self.size += sizeof(jit_word_t);
|
||||
}
|
||||
return (offset);
|
||||
return (jit_new_node_w(jit_code_arg, offset));
|
||||
}
|
||||
|
||||
jit_bool_t
|
||||
|
|
@ -348,10 +348,12 @@ _jit_arg_reg_p(jit_state_t *_jit, jit_int32_t offset)
|
|||
return (offset >= 0 && offset < 4);
|
||||
}
|
||||
|
||||
jit_int32_t
|
||||
jit_node_t *
|
||||
_jit_arg_f(jit_state_t *_jit)
|
||||
{
|
||||
jit_int32_t offset;
|
||||
|
||||
assert(_jit->function);
|
||||
if (jit_cpu.abi && !(_jit->function->self.call & jit_call_varargs)) {
|
||||
if (_jit->function->self.argf < 16)
|
||||
offset = _jit->function->self.argf++;
|
||||
|
|
@ -360,9 +362,15 @@ _jit_arg_f(jit_state_t *_jit)
|
|||
_jit->function->self.size += sizeof(jit_word_t);
|
||||
}
|
||||
}
|
||||
else
|
||||
offset = _jit_arg(_jit);
|
||||
return (offset);
|
||||
else {
|
||||
if (_jit->function->self.argi < 4)
|
||||
offset = _jit->function->self.argi++;
|
||||
else {
|
||||
offset = _jit->function->self.size;
|
||||
_jit->function->self.size += sizeof(jit_float32_t);
|
||||
}
|
||||
}
|
||||
return (jit_new_node_w(jit_code_arg_f, offset));
|
||||
}
|
||||
|
||||
jit_bool_t
|
||||
|
|
@ -371,17 +379,19 @@ _jit_arg_f_reg_p(jit_state_t *_jit, jit_int32_t offset)
|
|||
return (jit_arg_reg_p(offset));
|
||||
}
|
||||
|
||||
jit_int32_t
|
||||
jit_node_t *
|
||||
_jit_arg_d(jit_state_t *_jit)
|
||||
{
|
||||
jit_int32_t offset;
|
||||
|
||||
assert(_jit->function);
|
||||
if (jit_cpu.abi && !(_jit->function->self.call & jit_call_varargs)) {
|
||||
if (_jit->function->self.argf < 15) {
|
||||
if (_jit->function->self.argf & 1)
|
||||
++_jit->function->self.argf;
|
||||
offset = _jit->function->self.argf;
|
||||
_jit->function->self.argf += 2;
|
||||
return (offset);
|
||||
goto done;
|
||||
}
|
||||
}
|
||||
else {
|
||||
|
|
@ -390,14 +400,15 @@ _jit_arg_d(jit_state_t *_jit)
|
|||
++_jit->function->self.argi;
|
||||
offset = _jit->function->self.argi;
|
||||
_jit->function->self.argi += 2;
|
||||
return (offset);
|
||||
goto done;
|
||||
}
|
||||
}
|
||||
if (_jit->function->self.size & 7)
|
||||
_jit->function->self.size += 4;
|
||||
offset = _jit->function->self.size;
|
||||
_jit->function->self.size += sizeof(jit_float64_t);
|
||||
return (offset);
|
||||
done:
|
||||
return (jit_new_node_w(jit_code_arg_d, offset));
|
||||
}
|
||||
|
||||
jit_bool_t
|
||||
|
|
@ -407,116 +418,95 @@ _jit_arg_d_reg_p(jit_state_t *_jit, jit_int32_t offset)
|
|||
}
|
||||
|
||||
void
|
||||
_jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
|
||||
_jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
||||
{
|
||||
if (jit_swf_p()) {
|
||||
if (v < 4)
|
||||
v <<= 2;
|
||||
jit_ldxi_c(u, JIT_FP, v);
|
||||
}
|
||||
else if (v < 4)
|
||||
jit_extr_c(u, JIT_RA0 - v);
|
||||
if (jit_swf_p())
|
||||
jit_ldxi_c(u, JIT_FP, v->u.w < 4 ? v->u.w << 2 : v->u.w);
|
||||
else if (v->u.w < 4)
|
||||
jit_extr_c(u, JIT_RA0 - v->u.w);
|
||||
else
|
||||
jit_ldxi_c(u, JIT_FP, v);
|
||||
jit_ldxi_c(u, JIT_FP, v->u.w);
|
||||
}
|
||||
|
||||
void
|
||||
_jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
|
||||
_jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
||||
{
|
||||
if (jit_swf_p()) {
|
||||
if (v < 4)
|
||||
v <<= 2;
|
||||
jit_ldxi_uc(u, JIT_FP, v);
|
||||
}
|
||||
else if (v < 4)
|
||||
jit_extr_uc(u, JIT_RA0 - v);
|
||||
if (jit_swf_p())
|
||||
jit_ldxi_uc(u, JIT_FP, v->u.w < 4 ? v->u.w << 2 : v->u.w);
|
||||
else if (v->u.w < 4)
|
||||
jit_extr_uc(u, JIT_RA0 - v->u.w);
|
||||
else
|
||||
jit_ldxi_uc(u, JIT_FP, v);
|
||||
jit_ldxi_uc(u, JIT_FP, v->u.w);
|
||||
}
|
||||
|
||||
void
|
||||
_jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
|
||||
_jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
||||
{
|
||||
if (jit_swf_p()) {
|
||||
if (v < 4)
|
||||
v <<= 2;
|
||||
jit_ldxi_s(u, JIT_FP, v);
|
||||
}
|
||||
else if (v < 4)
|
||||
jit_extr_s(u, JIT_RA0 - v);
|
||||
if (jit_swf_p())
|
||||
jit_ldxi_s(u, JIT_FP, v->u.w < 4 ? v->u.w << 2 : v->u.w);
|
||||
else if (v->u.w < 4)
|
||||
jit_extr_s(u, JIT_RA0 - v->u.w);
|
||||
else
|
||||
jit_ldxi_s(u, JIT_FP, v);
|
||||
jit_ldxi_s(u, JIT_FP, v->u.w);
|
||||
}
|
||||
|
||||
void
|
||||
_jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
|
||||
_jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
||||
{
|
||||
if (jit_swf_p()) {
|
||||
if (v < 4)
|
||||
v <<= 2;
|
||||
jit_ldxi_us(u, JIT_FP, v);
|
||||
}
|
||||
else if (v < 4)
|
||||
jit_extr_us(u, JIT_RA0 - v);
|
||||
if (jit_swf_p())
|
||||
jit_ldxi_us(u, JIT_FP, v->u.w < 4 ? v->u.w << 2 : v->u.w);
|
||||
else if (v->u.w < 4)
|
||||
jit_extr_us(u, JIT_RA0 - v->u.w);
|
||||
else
|
||||
jit_ldxi_us(u, JIT_FP, v);
|
||||
jit_ldxi_us(u, JIT_FP, v->u.w);
|
||||
}
|
||||
|
||||
void
|
||||
_jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
|
||||
_jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
||||
{
|
||||
if (jit_swf_p()) {
|
||||
if (v < 4)
|
||||
v <<= 2;
|
||||
jit_ldxi_i(u, JIT_FP, v);
|
||||
}
|
||||
else if (v < 4)
|
||||
jit_movr(u, JIT_RA0 - v);
|
||||
if (jit_swf_p())
|
||||
jit_ldxi_i(u, JIT_FP, v->u.w < 4 ? v->u.w << 2 : v->u.w);
|
||||
else if (v->u.w < 4)
|
||||
jit_movr(u, JIT_RA0 - v->u.w);
|
||||
else
|
||||
jit_ldxi_i(u, JIT_FP, v);
|
||||
jit_ldxi_i(u, JIT_FP, v->u.w);
|
||||
}
|
||||
|
||||
void
|
||||
_jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
|
||||
_jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
||||
{
|
||||
if (jit_cpu.abi) {
|
||||
if (v < 16)
|
||||
jit_movr_f(u, JIT_FA0 - v);
|
||||
if (v->u.w < 16)
|
||||
jit_movr_f(u, JIT_FA0 - v->u.w);
|
||||
else
|
||||
jit_ldxi_f(u, JIT_FP, v);
|
||||
}
|
||||
else if (jit_swf_p()) {
|
||||
if (v < 4)
|
||||
v <<= 2;
|
||||
jit_ldxi_f(u, JIT_FP, v);
|
||||
jit_ldxi_f(u, JIT_FP, v->u.w);
|
||||
}
|
||||
else if (jit_swf_p())
|
||||
jit_ldxi_f(u, JIT_FP, v->u.w < 4 ? v->u.w << 2 : v->u.w);
|
||||
else {
|
||||
if (v < 4)
|
||||
jit_movr_f(u, JIT_RA0 - v);
|
||||
if (v->u.w < 4)
|
||||
jit_movr_f(u, JIT_RA0 - v->u.w);
|
||||
else
|
||||
jit_ldxi_f(u, JIT_FP, v);
|
||||
jit_ldxi_f(u, JIT_FP, v->u.w);
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
_jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
|
||||
_jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
||||
{
|
||||
if (jit_cpu.abi) {
|
||||
if (v < 16)
|
||||
jit_movr_d(u, JIT_FA0 - v);
|
||||
if (v->u.w < 16)
|
||||
jit_movr_d(u, JIT_FA0 - v->u.w);
|
||||
else
|
||||
jit_ldxi_d(u, JIT_FP, v);
|
||||
}
|
||||
else if (jit_swf_p()) {
|
||||
if (v < 4)
|
||||
v <<= 2;
|
||||
jit_ldxi_d(u, JIT_FP, v);
|
||||
jit_ldxi_d(u, JIT_FP, v->u.w);
|
||||
}
|
||||
else if (jit_swf_p())
|
||||
jit_ldxi_d(u, JIT_FP, v->u.w < 4 ? v->u.w << 2 : v->u.w);
|
||||
else {
|
||||
if (v < 4)
|
||||
jit_movr_d(u, JIT_RA0 - v);
|
||||
if (v->u.w < 4)
|
||||
jit_movr_d(u, JIT_RA0 - v->u.w);
|
||||
else
|
||||
jit_ldxi_d(u, JIT_FP, v);
|
||||
jit_ldxi_d(u, JIT_FP, v->u.w);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1420,6 +1410,9 @@ _jit_emit(jit_state_t *_jit)
|
|||
_jit->function = NULL;
|
||||
flush_consts();
|
||||
break;
|
||||
case jit_code_arg:
|
||||
case jit_code_arg_f: case jit_code_arg_d:
|
||||
break;
|
||||
default:
|
||||
abort();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -229,7 +229,7 @@ _jit_epilog(jit_state_t *_jit)
|
|||
_jit->function = NULL;
|
||||
}
|
||||
|
||||
jit_int32_t
|
||||
jit_node_t *
|
||||
_jit_arg(jit_state_t *_jit)
|
||||
{
|
||||
jit_int32_t offset;
|
||||
|
|
@ -244,7 +244,7 @@ _jit_arg(jit_state_t *_jit)
|
|||
else
|
||||
offset = _jit->function->self.size;
|
||||
_jit->function->self.size += sizeof(jit_word_t);
|
||||
return (offset);
|
||||
return (jit_new_node_w(jit_code_arg, offset));
|
||||
}
|
||||
|
||||
jit_bool_t
|
||||
|
|
@ -253,7 +253,7 @@ _jit_arg_reg_p(jit_state_t *_jit, jit_int32_t offset)
|
|||
return (offset >= 0 && offset < 4);
|
||||
}
|
||||
|
||||
jit_int32_t
|
||||
jit_node_t *
|
||||
_jit_arg_f(jit_state_t *_jit)
|
||||
{
|
||||
jit_int32_t offset;
|
||||
|
|
@ -278,7 +278,7 @@ _jit_arg_f(jit_state_t *_jit)
|
|||
else
|
||||
offset = _jit->function->self.size;
|
||||
_jit->function->self.size += sizeof(jit_float32_t);
|
||||
return (offset);
|
||||
return (jit_new_node_w(jit_code_arg_f, offset));
|
||||
}
|
||||
|
||||
jit_bool_t
|
||||
|
|
@ -288,7 +288,7 @@ _jit_arg_f_reg_p(jit_state_t *_jit, jit_int32_t offset)
|
|||
return (offset >= 0 && offset < 8);
|
||||
}
|
||||
|
||||
jit_int32_t
|
||||
jit_node_t *
|
||||
_jit_arg_d(jit_state_t *_jit)
|
||||
{
|
||||
jit_int32_t offset;
|
||||
|
|
@ -313,7 +313,7 @@ _jit_arg_d(jit_state_t *_jit)
|
|||
else
|
||||
offset = _jit->function->self.size;
|
||||
_jit->function->self.size += sizeof(jit_float64_t);
|
||||
return (offset);
|
||||
return (jit_new_node_w(jit_code_arg_d, offset));
|
||||
}
|
||||
|
||||
jit_bool_t
|
||||
|
|
@ -323,95 +323,95 @@ _jit_arg_d_reg_p(jit_state_t *_jit, jit_int32_t offset)
|
|||
}
|
||||
|
||||
void
|
||||
_jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
|
||||
_jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
||||
{
|
||||
if (v < 4)
|
||||
jit_extr_c(u, _A0 - v);
|
||||
if (v->u.w < 4)
|
||||
jit_extr_c(u, _A0 - v->u.w);
|
||||
else
|
||||
jit_ldxi_c(u, _FP, v);
|
||||
jit_ldxi_c(u, _FP, v->u.w);
|
||||
}
|
||||
|
||||
void
|
||||
_jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
|
||||
_jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
||||
{
|
||||
if (v < 4)
|
||||
jit_extr_uc(u, _A0 - v);
|
||||
if (v->u.w < 4)
|
||||
jit_extr_uc(u, _A0 - v->u.w);
|
||||
else
|
||||
jit_ldxi_uc(u, _FP, v);
|
||||
jit_ldxi_uc(u, _FP, v->u.w);
|
||||
}
|
||||
|
||||
void
|
||||
_jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
|
||||
_jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
||||
{
|
||||
if (v < 4)
|
||||
jit_extr_s(u, _A0 - v);
|
||||
if (v->u.w < 4)
|
||||
jit_extr_s(u, _A0 - v->u.w);
|
||||
else
|
||||
jit_ldxi_s(u, _FP, v);
|
||||
jit_ldxi_s(u, _FP, v->u.w);
|
||||
}
|
||||
|
||||
void
|
||||
_jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
|
||||
_jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
||||
{
|
||||
if (v < 4)
|
||||
jit_extr_us(u, _A0 - v);
|
||||
if (v->u.w < 4)
|
||||
jit_extr_us(u, _A0 - v->u.w);
|
||||
else
|
||||
jit_ldxi_us(u, _FP, v);
|
||||
jit_ldxi_us(u, _FP, v->u.w);
|
||||
}
|
||||
|
||||
void
|
||||
_jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
|
||||
_jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
||||
{
|
||||
if (v < 4) {
|
||||
if (v->u.w < 4) {
|
||||
#if __WORDSIZE == 64
|
||||
jit_extr_i(u, _A0 - v);
|
||||
jit_extr_i(u, _A0 - v->u.w);
|
||||
#else
|
||||
jit_movr(u, _A0 - v);
|
||||
jit_movr(u, _A0 - v->u.w);
|
||||
#endif
|
||||
}
|
||||
else
|
||||
jit_ldxi_i(u, _FP, v);
|
||||
jit_ldxi_i(u, _FP, v->u.w);
|
||||
}
|
||||
|
||||
#if __WORDSIZE == 64
|
||||
void
|
||||
_jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
|
||||
_jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
||||
{
|
||||
if (v < 4)
|
||||
jit_extr_ui(u, _A0 - v);
|
||||
if (v->u.w < 4)
|
||||
jit_extr_ui(u, _A0 - v->u.w);
|
||||
else
|
||||
jit_ldxi_ui(u, _FP, v);
|
||||
jit_ldxi_ui(u, _FP, v->u.w);
|
||||
}
|
||||
|
||||
void
|
||||
_jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
|
||||
_jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
||||
{
|
||||
if (v < 4)
|
||||
jit_movr(u, _A0 - v);
|
||||
if (v->u.w < 4)
|
||||
jit_movr(u, _A0 - v->u.w);
|
||||
else
|
||||
jit_ldxi_l(u, _FP, v);
|
||||
jit_ldxi_l(u, _FP, v->u.w);
|
||||
}
|
||||
#endif
|
||||
|
||||
void
|
||||
_jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
|
||||
_jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
||||
{
|
||||
if (v < 4)
|
||||
jit_new_node_ww(jit_code_getarg_f, u, _A0 - v);
|
||||
else if (v < 8)
|
||||
jit_movr_f(u, _F12 - ((v - 4) >> 1));
|
||||
if (v->u.w < 4)
|
||||
jit_new_node_ww(jit_code_getarg_f, u, _A0 - v->u.w);
|
||||
else if (v->u.w < 8)
|
||||
jit_movr_f(u, _F12 - ((v->u.w - 4) >> 1));
|
||||
else
|
||||
jit_ldxi_f(u, _FP, v);
|
||||
jit_ldxi_f(u, _FP, v->u.w);
|
||||
}
|
||||
|
||||
void
|
||||
_jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
|
||||
_jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
||||
{
|
||||
if (v < 4)
|
||||
jit_new_node_ww(jit_code_getarg_d, u, _A0 - v);
|
||||
else if (v < 8)
|
||||
jit_movr_d(u, _F12 - ((v - 4) >> 1));
|
||||
if (v->u.w < 4)
|
||||
jit_new_node_ww(jit_code_getarg_d, u, _A0 - v->u.w);
|
||||
else if (v->u.w < 8)
|
||||
jit_movr_d(u, _F12 - ((v->u.w - 4) >> 1));
|
||||
else
|
||||
jit_ldxi_d(u, _FP, v);
|
||||
jit_ldxi_d(u, _FP, v->u.w);
|
||||
}
|
||||
|
||||
void
|
||||
|
|
@ -1232,6 +1232,9 @@ _jit_emit(jit_state_t *_jit)
|
|||
assert(node->flag & jit_flag_data);
|
||||
pushargi_d(rn(node->u.w), (jit_float64_t *)node->v.n->u.w);
|
||||
break;
|
||||
case jit_code_arg:
|
||||
case jit_code_arg_f: case jit_code_arg_d:
|
||||
break;
|
||||
default:
|
||||
abort();
|
||||
}
|
||||
|
|
|
|||
107
lib/jit_ppc.c
107
lib/jit_ppc.c
|
|
@ -235,16 +235,18 @@ _jit_epilog(jit_state_t *_jit)
|
|||
_jit->function = NULL;
|
||||
}
|
||||
|
||||
jit_int32_t
|
||||
jit_node_t *
|
||||
_jit_arg(jit_state_t *_jit)
|
||||
{
|
||||
jit_int32_t offset;
|
||||
assert(_jit->function);
|
||||
if (_jit->function->self.argi < 8)
|
||||
return (_jit->function->self.argi++);
|
||||
offset = _jit->function->self.size;
|
||||
_jit->function->self.size += sizeof(jit_word_t);
|
||||
return (offset);
|
||||
offset = _jit->function->self.argi++;
|
||||
else {
|
||||
offset = _jit->function->self.size;
|
||||
_jit->function->self.size += sizeof(jit_word_t);
|
||||
}
|
||||
return (jit_new_node_w(jit_code_arg, offset));
|
||||
}
|
||||
|
||||
jit_bool_t
|
||||
|
|
@ -253,10 +255,18 @@ _jit_arg_reg_p(jit_state_t *_jit, jit_int32_t offset)
|
|||
return (offset >= 0 && offset < 8);
|
||||
}
|
||||
|
||||
jit_int32_t
|
||||
jit_node_t *
|
||||
_jit_arg_f(jit_state_t *_jit)
|
||||
{
|
||||
return (jit_arg_d());
|
||||
jit_int32_t offset;
|
||||
assert(_jit->function);
|
||||
if (_jit->function->self.argf < 8)
|
||||
offset = _jit->function->self.argf++;
|
||||
else {
|
||||
offset = _jit->function->self.size;
|
||||
_jit->function->self.size += sizeof(jit_float64_t);
|
||||
}
|
||||
return (jit_new_node_w(jit_code_arg_f, offset));
|
||||
}
|
||||
|
||||
jit_bool_t
|
||||
|
|
@ -265,16 +275,18 @@ _jit_arg_f_reg_p(jit_state_t *_jit, jit_int32_t offset)
|
|||
return (jit_arg_d_reg_p(offset));
|
||||
}
|
||||
|
||||
jit_int32_t
|
||||
jit_node_t *
|
||||
_jit_arg_d(jit_state_t *_jit)
|
||||
{
|
||||
jit_int32_t offset;
|
||||
assert(_jit->function);
|
||||
if (_jit->function->self.argf < 8)
|
||||
return (_jit->function->self.argf++);
|
||||
offset = _jit->function->self.size;
|
||||
_jit->function->self.size += sizeof(jit_float64_t);
|
||||
return (offset);
|
||||
offset = _jit->function->self.argf++;
|
||||
else {
|
||||
offset = _jit->function->self.size;
|
||||
_jit->function->self.size += sizeof(jit_float64_t);
|
||||
}
|
||||
return (jit_new_node_w(jit_code_arg_d, offset));
|
||||
}
|
||||
|
||||
jit_bool_t
|
||||
|
|
@ -284,83 +296,83 @@ _jit_arg_d_reg_p(jit_state_t *_jit, jit_int32_t offset)
|
|||
}
|
||||
|
||||
void
|
||||
_jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
|
||||
_jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
||||
{
|
||||
if (v < 8)
|
||||
jit_extr_c(u, JIT_RA0 - v);
|
||||
if (v->u.w < 8)
|
||||
jit_extr_c(u, JIT_RA0 - v->u.w);
|
||||
else
|
||||
jit_ldxi_c(u, JIT_FP, v);
|
||||
jit_ldxi_c(u, JIT_FP, v->u.w);
|
||||
}
|
||||
|
||||
void
|
||||
_jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
|
||||
_jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
||||
{
|
||||
if (v < 8)
|
||||
jit_extr_uc(u, JIT_RA0 - v);
|
||||
if (v->u.w < 8)
|
||||
jit_extr_uc(u, JIT_RA0 - v->u.w);
|
||||
else
|
||||
jit_ldxi_uc(u, JIT_FP, v);
|
||||
jit_ldxi_uc(u, JIT_FP, v->u.w);
|
||||
}
|
||||
|
||||
void
|
||||
_jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
|
||||
_jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
||||
{
|
||||
if (v < 8)
|
||||
jit_extr_s(u, JIT_RA0 - v);
|
||||
if (v->u.w < 8)
|
||||
jit_extr_s(u, JIT_RA0 - v->u.w);
|
||||
else
|
||||
jit_ldxi_s(u, JIT_FP, v);
|
||||
jit_ldxi_s(u, JIT_FP, v->u.w);
|
||||
}
|
||||
|
||||
void
|
||||
_jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
|
||||
_jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
||||
{
|
||||
if (v < 8)
|
||||
jit_extr_us(u, JIT_RA0 - v);
|
||||
if (v->u.w < 8)
|
||||
jit_extr_us(u, JIT_RA0 - v->u.w);
|
||||
else
|
||||
jit_ldxi_us(u, JIT_FP, v);
|
||||
jit_ldxi_us(u, JIT_FP, v->u.w);
|
||||
}
|
||||
|
||||
void
|
||||
_jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
|
||||
_jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
||||
{
|
||||
if (v < 8)
|
||||
jit_movr(u, JIT_RA0 - v);
|
||||
if (v->u.w < 8)
|
||||
jit_movr(u, JIT_RA0 - v->u.w);
|
||||
else
|
||||
jit_ldxi_i(u, JIT_FP, v);
|
||||
jit_ldxi_i(u, JIT_FP, v->u.w);
|
||||
}
|
||||
|
||||
#if __WORDSIZE == 64
|
||||
void
|
||||
_jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
|
||||
_jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
||||
{
|
||||
if (v < 8)
|
||||
jit_extr_ui(u, JIT_RA0 - v);
|
||||
if (v->u.w < 8)
|
||||
jit_extr_ui(u, JIT_RA0 - v->u.w);
|
||||
else
|
||||
jit_ldxi_ui(u, JIT_FP, v);
|
||||
jit_ldxi_ui(u, JIT_FP, v->u.w);
|
||||
}
|
||||
|
||||
void
|
||||
_jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
|
||||
_jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
||||
{
|
||||
if (v < 8)
|
||||
jit_movr(u, JIT_RA0 - v);
|
||||
if (v->u.w < 8)
|
||||
jit_movr(u, JIT_RA0 - v->u.w);
|
||||
else
|
||||
jit_ldxi_l(u, JIT_FP, v);
|
||||
jit_ldxi_l(u, JIT_FP, v->u.w);
|
||||
}
|
||||
#endif
|
||||
|
||||
void
|
||||
_jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
|
||||
_jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
||||
{
|
||||
jit_getarg_d(u, v);
|
||||
}
|
||||
|
||||
void
|
||||
_jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
|
||||
_jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
||||
{
|
||||
if (v < 8)
|
||||
jit_movr_d(u, JIT_FA0 - v);
|
||||
if (v->u.w < 8)
|
||||
jit_movr_d(u, JIT_FA0 - v->u.w);
|
||||
else
|
||||
jit_ldxi_d(u, JIT_FP, v);
|
||||
jit_ldxi_d(u, JIT_FP, v->u.w);
|
||||
}
|
||||
|
||||
void
|
||||
|
|
@ -1046,7 +1058,7 @@ _jit_emit(jit_state_t *_jit)
|
|||
temp = node->u.n;
|
||||
assert(temp->code == jit_code_label ||
|
||||
temp->code == jit_code_epilog);
|
||||
word = calli(temp->u.w);
|
||||
word = calli_p(temp->u.w);
|
||||
if (!(temp->flag & jit_flag_patch))
|
||||
patch(word, node);
|
||||
}
|
||||
|
|
@ -1082,6 +1094,9 @@ _jit_emit(jit_state_t *_jit)
|
|||
epilog(node);
|
||||
_jit->function = NULL;
|
||||
break;
|
||||
case jit_code_arg:
|
||||
case jit_code_arg_f: case jit_code_arg_d:
|
||||
break;
|
||||
default:
|
||||
abort();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -40,6 +40,7 @@ static char *code_name[] = {
|
|||
"#note",
|
||||
"label",
|
||||
"prolog",
|
||||
"arg",
|
||||
"addr", "addi",
|
||||
"addcr", "addci",
|
||||
"addxr", "addxi",
|
||||
|
|
@ -118,7 +119,7 @@ static char *code_name[] = {
|
|||
"jmpr", "jmpi",
|
||||
"callr", "calli",
|
||||
"epilog",
|
||||
"getarg_f",
|
||||
"arg_f", "getarg_f",
|
||||
"addr_f", "addi_f",
|
||||
"subr_f", "subi_f",
|
||||
"mulr_f", "muli_f",
|
||||
|
|
@ -162,7 +163,7 @@ static char *code_name[] = {
|
|||
"bunordr_f", "bunordi_f",
|
||||
"pushargr_f", "pushargi_f",
|
||||
"retval_f",
|
||||
"getarg_d",
|
||||
"arg_d", "getarg_d",
|
||||
"addr_d", "addi_d",
|
||||
"subr_d", "subi_d",
|
||||
"mulr_d", "muli_d",
|
||||
|
|
@ -258,6 +259,8 @@ _jit_print(jit_state_t *_jit)
|
|||
switch (node->code) {
|
||||
r:
|
||||
print_chr(' '); print_reg(node->u.w); continue;
|
||||
w:
|
||||
print_chr(' '); print_hex(node->u.w); continue;
|
||||
n:
|
||||
print_chr(' ');
|
||||
if (!(node->flag & jit_flag_node))
|
||||
|
|
@ -391,6 +394,8 @@ _jit_print(jit_state_t *_jit)
|
|||
case jit_cc_a0_reg|jit_cc_a0_chg:
|
||||
case jit_cc_a0_reg|jit_cc_a0_jmp:
|
||||
goto r;
|
||||
case jit_cc_a0_int:
|
||||
goto w;
|
||||
case jit_cc_a0_jmp:
|
||||
goto n;
|
||||
case jit_cc_a0_reg|jit_cc_a1_reg:
|
||||
|
|
|
|||
124
lib/jit_x86.c
124
lib/jit_x86.c
|
|
@ -407,7 +407,7 @@ _jit_epilog(jit_state_t *_jit)
|
|||
_jit->function = NULL;
|
||||
}
|
||||
|
||||
jit_int32_t
|
||||
jit_node_t *
|
||||
_jit_arg(jit_state_t *_jit)
|
||||
{
|
||||
jit_int32_t offset;
|
||||
|
|
@ -415,11 +415,14 @@ _jit_arg(jit_state_t *_jit)
|
|||
assert(_jit->function);
|
||||
#if __WORDSIZE == 64
|
||||
if (_jit->function->self.argi < 6)
|
||||
return (_jit->function->self.argi++);
|
||||
offset = _jit->function->self.argi++;
|
||||
else
|
||||
#endif
|
||||
offset = _jit->function->self.size;
|
||||
_jit->function->self.size += sizeof(jit_word_t);
|
||||
return (offset);
|
||||
{
|
||||
offset = _jit->function->self.size;
|
||||
_jit->function->self.size += sizeof(jit_word_t);
|
||||
}
|
||||
return (jit_new_node_w(jit_code_arg, offset));
|
||||
}
|
||||
|
||||
jit_bool_t
|
||||
|
|
@ -432,7 +435,7 @@ _jit_arg_reg_p(jit_state_t *_jit, jit_int32_t offset)
|
|||
#endif
|
||||
}
|
||||
|
||||
jit_int32_t
|
||||
jit_node_t *
|
||||
_jit_arg_f(jit_state_t *_jit)
|
||||
{
|
||||
jit_int32_t offset;
|
||||
|
|
@ -440,15 +443,18 @@ _jit_arg_f(jit_state_t *_jit)
|
|||
assert(_jit->function);
|
||||
#if __WORDSIZE == 64
|
||||
if (_jit->function->self.argf < 8)
|
||||
return (_jit->function->self.argf++);
|
||||
offset = _jit->function->self.argf++;
|
||||
else
|
||||
#endif
|
||||
offset = _jit->function->self.size;
|
||||
{
|
||||
offset = _jit->function->self.size;
|
||||
#if __WORDSIZE == 32
|
||||
_jit->function->self.size += sizeof(jit_float32_t);
|
||||
_jit->function->self.size += sizeof(jit_float32_t);
|
||||
#else
|
||||
_jit->function->self.size += sizeof(jit_float64_t);
|
||||
_jit->function->self.size += sizeof(jit_float64_t);
|
||||
#endif
|
||||
return (offset);
|
||||
}
|
||||
return (jit_new_node_w(jit_code_arg_f, offset));
|
||||
}
|
||||
|
||||
jit_bool_t
|
||||
|
|
@ -461,19 +467,26 @@ _jit_arg_f_reg_p(jit_state_t *_jit, jit_int32_t offset)
|
|||
#endif
|
||||
}
|
||||
|
||||
jit_int32_t
|
||||
jit_node_t *
|
||||
_jit_arg_d(jit_state_t *_jit)
|
||||
{
|
||||
#if __WORDSIZE == 64
|
||||
return (jit_arg_f());
|
||||
#else
|
||||
jit_int32_t offset;
|
||||
|
||||
assert(_jit->function);
|
||||
offset = _jit->function->self.size;
|
||||
_jit->function->self.size += sizeof(jit_float64_t);
|
||||
return (offset);
|
||||
#if __WORDSIZE == 64
|
||||
if (_jit->function->self.argf < 8)
|
||||
offset = _jit->function->self.argf++;
|
||||
else
|
||||
#endif
|
||||
{
|
||||
offset = _jit->function->self.size;
|
||||
#if __WORDSIZE == 32
|
||||
_jit->function->self.size += sizeof(jit_float32_t);
|
||||
#else
|
||||
_jit->function->self.size += sizeof(jit_float64_t);
|
||||
#endif
|
||||
}
|
||||
return (jit_new_node_w(jit_code_arg_d, offset));
|
||||
}
|
||||
|
||||
jit_bool_t
|
||||
|
|
@ -483,100 +496,100 @@ _jit_arg_d_reg_p(jit_state_t *_jit, jit_int32_t offset)
|
|||
}
|
||||
|
||||
void
|
||||
_jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
|
||||
_jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
||||
{
|
||||
#if __WORDSIZE == 64
|
||||
if (v < 6)
|
||||
jit_extr_c(u, _RDI - v);
|
||||
if (v->u.w < 6)
|
||||
jit_extr_c(u, _RDI - v->u.w);
|
||||
else
|
||||
#endif
|
||||
jit_ldxi_c(u, _RBP, v);
|
||||
jit_ldxi_c(u, _RBP, v->u.w);
|
||||
}
|
||||
|
||||
void
|
||||
_jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
|
||||
_jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
||||
{
|
||||
#if __WORDSIZE == 64
|
||||
if (v < 6)
|
||||
jit_extr_uc(u, _RDI - v);
|
||||
if (v->u.w < 6)
|
||||
jit_extr_uc(u, _RDI - v->u.w);
|
||||
else
|
||||
#endif
|
||||
jit_ldxi_uc(u, _RBP, v);
|
||||
jit_ldxi_uc(u, _RBP, v->u.w);
|
||||
}
|
||||
|
||||
void
|
||||
_jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
|
||||
_jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
||||
{
|
||||
#if __WORDSIZE == 64
|
||||
if (v < 6)
|
||||
jit_extr_s(u, _RDI - v);
|
||||
if (v->u.w < 6)
|
||||
jit_extr_s(u, _RDI - v->u.w);
|
||||
else
|
||||
#endif
|
||||
jit_ldxi_s(u, _RBP, v);
|
||||
jit_ldxi_s(u, _RBP, v->u.w);
|
||||
}
|
||||
|
||||
void
|
||||
_jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
|
||||
_jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
||||
{
|
||||
#if __WORDSIZE == 64
|
||||
if (v < 6)
|
||||
jit_extr_us(u, _RDI - v);
|
||||
if (v->u.w < 6)
|
||||
jit_extr_us(u, _RDI - v->u.w);
|
||||
else
|
||||
#endif
|
||||
jit_ldxi_us(u, _RBP, v);
|
||||
jit_ldxi_us(u, _RBP, v->u.w);
|
||||
}
|
||||
|
||||
void
|
||||
_jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
|
||||
_jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
||||
{
|
||||
#if __WORDSIZE == 64
|
||||
if (v < 6)
|
||||
jit_extr_i(u, _RDI - v);
|
||||
if (v->u.w < 6)
|
||||
jit_extr_i(u, _RDI - v->u.w);
|
||||
else
|
||||
#endif
|
||||
jit_ldxi_i(u, _RBP, v);
|
||||
jit_ldxi_i(u, _RBP, v->u.w);
|
||||
}
|
||||
|
||||
#if __WORDSIZE == 64
|
||||
void
|
||||
_jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
|
||||
_jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
||||
{
|
||||
if (v < 6)
|
||||
jit_extr_ui(u, _RDI - v);
|
||||
if (v->u.w < 6)
|
||||
jit_extr_ui(u, _RDI - v->u.w);
|
||||
else
|
||||
jit_ldxi_ui(u, _RBP, v);
|
||||
jit_ldxi_ui(u, _RBP, v->u.w);
|
||||
}
|
||||
|
||||
void
|
||||
_jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
|
||||
_jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
||||
{
|
||||
if (v < 6)
|
||||
jit_movr(u, _RDI - v);
|
||||
if (v->u.w < 6)
|
||||
jit_movr(u, _RDI - v->u.w);
|
||||
else
|
||||
jit_ldxi_l(u, _RBP, v);
|
||||
jit_ldxi_l(u, _RBP, v->u.w);
|
||||
}
|
||||
#endif
|
||||
|
||||
void
|
||||
_jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
|
||||
_jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
||||
{
|
||||
#if __WORDSIZE == 64
|
||||
if (v < 8)
|
||||
jit_movr_f(u, _XMM0 - v);
|
||||
if (v->u.w < 8)
|
||||
jit_movr_f(u, _XMM0 - v->u.w);
|
||||
else
|
||||
#endif
|
||||
jit_ldxi_f(u, _RBP, v);
|
||||
jit_ldxi_f(u, _RBP, v->u.w);
|
||||
}
|
||||
|
||||
void
|
||||
_jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
|
||||
_jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
||||
{
|
||||
#if __WORDSIZE == 64
|
||||
if (v < 8)
|
||||
jit_movr_d(u, _XMM0 - v);
|
||||
if (v->u.w < 8)
|
||||
jit_movr_d(u, _XMM0 - v->u.w);
|
||||
else
|
||||
#endif
|
||||
jit_ldxi_d(u, _RBP, v);
|
||||
jit_ldxi_d(u, _RBP, v->u.w);
|
||||
}
|
||||
|
||||
void
|
||||
|
|
@ -1582,6 +1595,9 @@ _jit_emit(jit_state_t *_jit)
|
|||
fstpr(rn(node->u.w) + 1);
|
||||
break;
|
||||
#endif
|
||||
case jit_code_arg:
|
||||
case jit_code_arg_f: case jit_code_arg_d:
|
||||
break;
|
||||
default:
|
||||
abort();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -777,6 +777,9 @@ _jit_classify(jit_state_t *_jit, jit_code_t code)
|
|||
case jit_code_epilog:
|
||||
mask = 0;
|
||||
break;
|
||||
case jit_code_arg: case jit_code_arg_f: case jit_code_arg_d:
|
||||
mask = jit_cc_a0_int;
|
||||
break;
|
||||
case jit_code_calli: case jit_code_jmpi:
|
||||
mask = jit_cc_a0_jmp;
|
||||
break;
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue