mirror of
https://git.savannah.gnu.org/git/guile.git
synced 2025-06-25 20:50:31 +02:00
Remove inconsistent, public jit_arg_reg_p macro
* include/lightning/jit_aarch64.h,
include/lightning/jit_alpha.h,
include/lightning/jit_arm.h,
include/lightning/jit_hppa.h,
include/lightning/jit_mips.h,
include/lightning/jit_ppc.h,
include/lightning/jit_s390.h,
include/lightning/jit_sparc.h,
include/lightning/jit_x86.h,
lib/jit_aarch64.c, lib/jit_alpha.c,
lib/jit_arm.c, lib/jit_hppa.c,
lib/jit_ia64.c, lib/jit_mips.c,
lib/jit_ppc.c, lib/jit_s390.c,
lib/jit_sparc.c, lib/jit_x86.c: Remove jit_arg_reg_p and
jit_arg_f_reg_p from a public header, and define it only
on port specific files where an integer offset is used
to qualify an argument identifier. Exported code expects
an opaque pointer (but of jit_node_t* type) to "qualify"
an argument identifier.
This patch, and the code review/simplification done during
it also corrected some bugs:
o Inconsistent jit_arg_d value of double argument after 3
integer arguments in arm for jit_functions; tested, C
functions were being properly called.
o Inconsistent use of getarg_{f,d} and putarg*_{f,d} on
s390 (32-bit) that happened to not have a proper test
case, as it would only happen for jit functions, and
tested, called C functions had proper arguments.
o Corrected a "last minute" correction that did not go
to the committed version, and would not compile on hppa,
due to bad _jit_putargi_d prototype definition.
This commit is contained in:
pcpa
parent
3695a2e99c
commit
73e520767f
20 changed files with 404 additions and 709 deletions
186
lib/jit_ppc.c
186
lib/jit_ppc.c
|
|
@ -19,6 +19,19 @@
|
|||
|
||||
#define rc(value) jit_class_##value
|
||||
#define rn(reg) (jit_regno(_rvs[jit_regno(reg)].spec))
|
||||
#define jit_arg_reg_p(i) ((i) >= 0 && (i) < 8)
|
||||
#define jit_arg_f_reg_p(i) ((i) >= 0 && (i) < 13)
|
||||
#if __BYTE_ORDER == __LITTLE_ENDIAN
|
||||
# define C_DISP 0
|
||||
# define S_DISP 0
|
||||
# define I_DISP 0
|
||||
# define F_DISP 0
|
||||
#else
|
||||
# define C_DISP (__WORDSIZE >> 3) - sizeof(jit_int8_t)
|
||||
# define S_DISP (__WORDSIZE >> 3) - sizeof(jit_int16_t)
|
||||
# define I_DISP (__WORDSIZE >> 3) - sizeof(jit_int32_t)
|
||||
# define F_DISP (__WORDSIZE >> 3) - sizeof(jit_float32_t)
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Prototypes
|
||||
|
|
@ -257,7 +270,7 @@ _jit_arg(jit_state_t *_jit)
|
|||
{
|
||||
jit_int32_t offset;
|
||||
assert(_jitc->function);
|
||||
if (_jitc->function->self.argi < 8)
|
||||
if (jit_arg_reg_p(_jitc->function->self.argi))
|
||||
offset = _jitc->function->self.argi++;
|
||||
else
|
||||
offset = _jitc->function->self.size;
|
||||
|
|
@ -265,27 +278,16 @@ _jit_arg(jit_state_t *_jit)
|
|||
return (jit_new_node_w(jit_code_arg, offset));
|
||||
}
|
||||
|
||||
jit_bool_t
|
||||
_jit_arg_reg_p(jit_state_t *_jit, jit_int32_t offset)
|
||||
{
|
||||
return (offset >= 0 && offset < 8);
|
||||
}
|
||||
|
||||
jit_node_t *
|
||||
_jit_arg_f(jit_state_t *_jit)
|
||||
{
|
||||
jit_int32_t offset;
|
||||
assert(_jitc->function);
|
||||
if (_jitc->function->self.argf < 13)
|
||||
if (jit_arg_f_reg_p(_jitc->function->self.argf))
|
||||
offset = _jitc->function->self.argf++;
|
||||
else {
|
||||
#if __WORDSIZE == 32 || __BYTE_ORDER == __LITTLE_ENDIAN
|
||||
offset = _jitc->function->self.size;
|
||||
#else
|
||||
offset = _jitc->function->self.size + 4;
|
||||
#endif
|
||||
}
|
||||
if (_jitc->function->self.argi < 8) {
|
||||
else
|
||||
offset = _jitc->function->self.size + F_DISP;
|
||||
if (jit_arg_reg_p(_jitc->function->self.argi)) {
|
||||
#if __WORDSIZE == 32
|
||||
_jitc->function->self.argi += 2;
|
||||
#else
|
||||
|
|
@ -296,22 +298,16 @@ _jit_arg_f(jit_state_t *_jit)
|
|||
return (jit_new_node_w(jit_code_arg_f, offset));
|
||||
}
|
||||
|
||||
jit_bool_t
|
||||
_jit_arg_f_reg_p(jit_state_t *_jit, jit_int32_t offset)
|
||||
{
|
||||
return (offset >= 0 && offset < 13);
|
||||
}
|
||||
|
||||
jit_node_t *
|
||||
_jit_arg_d(jit_state_t *_jit)
|
||||
{
|
||||
jit_int32_t offset;
|
||||
assert(_jitc->function);
|
||||
if (_jitc->function->self.argf < 13)
|
||||
if (jit_arg_f_reg_p(_jitc->function->self.argf))
|
||||
offset = _jitc->function->self.argf++;
|
||||
else
|
||||
offset = _jitc->function->self.size;
|
||||
if (_jitc->function->self.argi < 8) {
|
||||
if (jit_arg_reg_p(_jitc->function->self.argi)) {
|
||||
#if __WORDSIZE == 32
|
||||
_jitc->function->self.argi += 2;
|
||||
#else
|
||||
|
|
@ -322,95 +318,59 @@ _jit_arg_d(jit_state_t *_jit)
|
|||
return (jit_new_node_w(jit_code_arg_d, offset));
|
||||
}
|
||||
|
||||
jit_bool_t
|
||||
_jit_arg_d_reg_p(jit_state_t *_jit, jit_int32_t offset)
|
||||
{
|
||||
return (jit_arg_f_reg_p(offset));
|
||||
}
|
||||
|
||||
void
|
||||
_jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
||||
{
|
||||
assert(v->code == jit_code_arg);
|
||||
if (v->u.w < 8)
|
||||
if (jit_arg_reg_p(v->u.w))
|
||||
jit_extr_c(u, JIT_RA0 - v->u.w);
|
||||
else {
|
||||
#if __BYTE_ORDER == __LITTLE_ENDIAN
|
||||
jit_ldxi_c(u, JIT_FP, v->u.w);
|
||||
#else
|
||||
jit_ldxi_c(u, JIT_FP,
|
||||
v->u.w + (__WORDSIZE >> 3) - sizeof(jit_int8_t));
|
||||
#endif
|
||||
}
|
||||
else
|
||||
jit_ldxi_c(u, JIT_FP, v->u.w + C_DISP);
|
||||
}
|
||||
|
||||
void
|
||||
_jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
||||
{
|
||||
assert(v->code == jit_code_arg);
|
||||
if (v->u.w < 8)
|
||||
if (jit_arg_reg_p(v->u.w))
|
||||
jit_extr_uc(u, JIT_RA0 - v->u.w);
|
||||
else {
|
||||
#if __BYTE_ORDER == __LITTLE_ENDIAN
|
||||
jit_ldxi_uc(u, JIT_FP, v->u.w);
|
||||
#else
|
||||
jit_ldxi_uc(u, JIT_FP,
|
||||
v->u.w + (__WORDSIZE >> 3) - sizeof(jit_uint8_t));
|
||||
#endif
|
||||
}
|
||||
else
|
||||
jit_ldxi_uc(u, JIT_FP, v->u.w + C_DISP);
|
||||
}
|
||||
|
||||
void
|
||||
_jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
||||
{
|
||||
assert(v->code == jit_code_arg);
|
||||
if (v->u.w < 8)
|
||||
if (jit_arg_reg_p(v->u.w))
|
||||
jit_extr_s(u, JIT_RA0 - v->u.w);
|
||||
else {
|
||||
#if __BYTE_ORDER == __LITTLE_ENDIAN
|
||||
jit_ldxi_s(u, JIT_FP, v->u.w);
|
||||
#else
|
||||
jit_ldxi_s(u, JIT_FP,
|
||||
v->u.w + (__WORDSIZE >> 3) - sizeof(jit_int16_t));
|
||||
#endif
|
||||
}
|
||||
else
|
||||
jit_ldxi_s(u, JIT_FP, v->u.w + S_DISP);
|
||||
}
|
||||
|
||||
void
|
||||
_jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
||||
{
|
||||
assert(v->code == jit_code_arg);
|
||||
if (v->u.w < 8)
|
||||
if (jit_arg_reg_p(v->u.w))
|
||||
jit_extr_us(u, JIT_RA0 - v->u.w);
|
||||
else {
|
||||
#if __BYTE_ORDER == __LITTLE_ENDIAN
|
||||
jit_ldxi_us(u, JIT_FP, v->u.w);
|
||||
#else
|
||||
jit_ldxi_us(u, JIT_FP,
|
||||
v->u.w + (__WORDSIZE >> 3) - sizeof(jit_uint16_t));
|
||||
#endif
|
||||
}
|
||||
else
|
||||
jit_ldxi_us(u, JIT_FP, v->u.w + S_DISP);
|
||||
}
|
||||
|
||||
void
|
||||
_jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
||||
{
|
||||
assert(v->code == jit_code_arg);
|
||||
if (v->u.w < 8) {
|
||||
if (jit_arg_reg_p(v->u.w)) {
|
||||
#if __WORDSIZE == 32
|
||||
jit_movr(u, JIT_RA0 - v->u.w);
|
||||
#else
|
||||
jit_extr_i(u, JIT_RA0 - v->u.w);
|
||||
#endif
|
||||
}
|
||||
else {
|
||||
#if __BYTE_ORDER == __LITTLE_ENDIAN
|
||||
jit_ldxi_i(u, JIT_FP, v->u.w);
|
||||
#else
|
||||
jit_ldxi_i(u, JIT_FP,
|
||||
v->u.w + (__WORDSIZE >> 3) - sizeof(jit_int32_t));
|
||||
#endif
|
||||
}
|
||||
else
|
||||
jit_ldxi_i(u, JIT_FP, v->u.w + I_DISP);
|
||||
}
|
||||
|
||||
#if __WORDSIZE == 64
|
||||
|
|
@ -418,23 +378,17 @@ void
|
|||
_jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
||||
{
|
||||
assert(v->code == jit_code_arg);
|
||||
if (v->u.w < 8)
|
||||
if (jit_arg_reg_p(v->u.w))
|
||||
jit_extr_ui(u, JIT_RA0 - v->u.w);
|
||||
else {
|
||||
# if __BYTE_ORDER == __LITTLE_ENDIAN
|
||||
jit_ldxi_ui(u, JIT_FP, v->u.w);
|
||||
# else
|
||||
jit_ldxi_ui(u, JIT_FP,
|
||||
v->u.w + (__WORDSIZE >> 3) - sizeof(jit_uint32_t));
|
||||
# endif
|
||||
}
|
||||
else
|
||||
jit_ldxi_ui(u, JIT_FP, v->u.w + I_DISP);
|
||||
}
|
||||
|
||||
void
|
||||
_jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
||||
{
|
||||
assert(v->code == jit_code_arg);
|
||||
if (v->u.w < 8)
|
||||
if (jit_arg_reg_p(v->u.w))
|
||||
jit_movr(u, JIT_RA0 - v->u.w);
|
||||
else
|
||||
jit_ldxi_l(u, JIT_FP, v->u.w);
|
||||
|
|
@ -445,7 +399,7 @@ void
|
|||
_jit_putargr(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
||||
{
|
||||
assert(v->code == jit_code_arg);
|
||||
if (v->u.w < 8)
|
||||
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);
|
||||
|
|
@ -456,7 +410,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);
|
||||
if (v->u.w < 8)
|
||||
if (jit_arg_reg_p(v->u.w))
|
||||
jit_movi(JIT_RA0 - v->u.w, u);
|
||||
else {
|
||||
regno = jit_get_reg(jit_class_gpr);
|
||||
|
|
@ -470,7 +424,7 @@ void
|
|||
_jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
||||
{
|
||||
assert(v->code == jit_code_arg_f);
|
||||
if (v->u.w < 13)
|
||||
if (jit_arg_f_reg_p(v->u.w))
|
||||
jit_movr_d(u, JIT_FA0 - v->u.w);
|
||||
else
|
||||
jit_ldxi_f(u, JIT_FP, v->u.w);
|
||||
|
|
@ -480,7 +434,7 @@ void
|
|||
_jit_putargr_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
||||
{
|
||||
assert(v->code == jit_code_arg_f);
|
||||
if (v->u.w < 13)
|
||||
if (jit_arg_f_reg_p(v->u.w))
|
||||
jit_movr_d(JIT_FA0 - v->u.w, u);
|
||||
else
|
||||
jit_stxi_f(v->u.w, JIT_FP, u);
|
||||
|
|
@ -491,7 +445,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);
|
||||
if (v->u.w < 13)
|
||||
if (jit_arg_f_reg_p(v->u.w))
|
||||
jit_movi_d(JIT_FA0 - v->u.w, u);
|
||||
else {
|
||||
regno = jit_get_reg(jit_class_fpr);
|
||||
|
|
@ -505,7 +459,7 @@ void
|
|||
_jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
||||
{
|
||||
assert(v->code == jit_code_arg_d);
|
||||
if (v->u.w < 13)
|
||||
if (jit_arg_f_reg_p(v->u.w))
|
||||
jit_movr_d(u, JIT_FA0 - v->u.w);
|
||||
else
|
||||
jit_ldxi_d(u, JIT_FP, v->u.w);
|
||||
|
|
@ -515,7 +469,7 @@ void
|
|||
_jit_putargr_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
|
||||
{
|
||||
assert(v->code == jit_code_arg_d);
|
||||
if (v->u.w < 13)
|
||||
if (jit_arg_f_reg_p(v->u.w))
|
||||
jit_movr_d(JIT_FA0 - v->u.w, u);
|
||||
else
|
||||
jit_stxi_d(v->u.w, JIT_FP, u);
|
||||
|
|
@ -526,7 +480,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);
|
||||
if (v->u.w < 13)
|
||||
if (jit_arg_f_reg_p(v->u.w))
|
||||
jit_movi_d(JIT_FA0 - v->u.w, u);
|
||||
else {
|
||||
regno = jit_get_reg(jit_class_fpr);
|
||||
|
|
@ -540,7 +494,7 @@ void
|
|||
_jit_pushargr(jit_state_t *_jit, jit_int32_t u)
|
||||
{
|
||||
assert(_jitc->function);
|
||||
if (_jitc->function->call.argi < 8) {
|
||||
if (jit_arg_reg_p(_jitc->function->call.argi)) {
|
||||
jit_movr(JIT_RA0 - _jitc->function->call.argi, u);
|
||||
++_jitc->function->call.argi;
|
||||
}
|
||||
|
|
@ -554,7 +508,7 @@ _jit_pushargi(jit_state_t *_jit, jit_word_t u)
|
|||
{
|
||||
jit_int32_t regno;
|
||||
assert(_jitc->function);
|
||||
if (_jitc->function->call.argi < 8) {
|
||||
if (jit_arg_reg_p(_jitc->function->call.argi)) {
|
||||
jit_movi(JIT_RA0 - _jitc->function->call.argi, u);
|
||||
++_jitc->function->call.argi;
|
||||
}
|
||||
|
|
@ -571,12 +525,12 @@ void
|
|||
_jit_pushargr_f(jit_state_t *_jit, jit_int32_t u)
|
||||
{
|
||||
assert(_jitc->function);
|
||||
if (_jitc->function->call.argf < 13) {
|
||||
if (jit_arg_f_reg_p(_jitc->function->call.argf)) {
|
||||
jit_movr_d(JIT_FA0 - _jitc->function->call.argf, u);
|
||||
++_jitc->function->call.argf;
|
||||
if (!(_jitc->function->call.call & jit_call_varargs)) {
|
||||
/* in case of excess arguments */
|
||||
if (_jitc->function->call.argi < 8) {
|
||||
if (jit_arg_reg_p(_jitc->function->call.argi)) {
|
||||
#if __WORDSIZE == 32
|
||||
_jitc->function->call.argi += 2;
|
||||
#else
|
||||
|
|
@ -587,7 +541,7 @@ _jit_pushargr_f(jit_state_t *_jit, jit_int32_t u)
|
|||
return;
|
||||
}
|
||||
}
|
||||
if (_jitc->function->call.argi < 8) {
|
||||
if (jit_arg_reg_p(_jitc->function->call.argi)) {
|
||||
/* use reserved 8 bytes area */
|
||||
jit_stxi_d(alloca_offset - 8, JIT_FP, u);
|
||||
jit_ldxi(JIT_RA0 - _jitc->function->call.argi, JIT_FP,
|
||||
|
|
@ -599,14 +553,9 @@ _jit_pushargr_f(jit_state_t *_jit, jit_int32_t u)
|
|||
_jitc->function->call.argi++;
|
||||
#endif
|
||||
}
|
||||
else {
|
||||
#if __WORDSIZE == 32 || __BYTE_ORDER == __LITTLE_ENDIAN
|
||||
jit_stxi_f(_jitc->function->call.size + params_offset, JIT_SP, u);
|
||||
#else
|
||||
jit_stxi_f(_jitc->function->call.size + params_offset + 4,
|
||||
else
|
||||
jit_stxi_f(_jitc->function->call.size + params_offset + F_DISP,
|
||||
JIT_SP, u);
|
||||
#endif
|
||||
}
|
||||
_jitc->function->call.size += sizeof(jit_word_t);
|
||||
}
|
||||
|
||||
|
|
@ -616,12 +565,12 @@ _jit_pushargi_f(jit_state_t *_jit, jit_float32_t u)
|
|||
jit_int32_t regno;
|
||||
|
||||
assert(_jitc->function);
|
||||
if (_jitc->function->call.argf < 13) {
|
||||
if (jit_arg_f_reg_p(_jitc->function->call.argf)) {
|
||||
jit_movi_d(JIT_FA0 - _jitc->function->call.argf, u);
|
||||
++_jitc->function->call.argf;
|
||||
if (!(_jitc->function->call.call & jit_call_varargs)) {
|
||||
/* in case of excess arguments */
|
||||
if (_jitc->function->call.argi < 8) {
|
||||
if (jit_arg_reg_p(_jitc->function->call.argi)) {
|
||||
#if __WORDSIZE == 32
|
||||
_jitc->function->call.argi += 2;
|
||||
#else
|
||||
|
|
@ -634,7 +583,7 @@ _jit_pushargi_f(jit_state_t *_jit, jit_float32_t u)
|
|||
}
|
||||
regno = jit_get_reg(jit_class_fpr);
|
||||
jit_movi_f(regno, u);
|
||||
if (_jitc->function->call.argi < 8) {
|
||||
if (jit_arg_reg_p(_jitc->function->call.argi)) {
|
||||
/* use reserved 8 bytes area */
|
||||
jit_stxi_d(alloca_offset - 8, JIT_FP, regno);
|
||||
jit_ldxi(JIT_RA0 - _jitc->function->call.argi, JIT_FP,
|
||||
|
|
@ -646,14 +595,9 @@ _jit_pushargi_f(jit_state_t *_jit, jit_float32_t u)
|
|||
_jitc->function->call.argi++;
|
||||
#endif
|
||||
}
|
||||
else {
|
||||
#if __WORDSIZE == 32 || __BYTE_ORDER == __LITTLE_ENDIAN
|
||||
jit_stxi_f(_jitc->function->call.size + params_offset, JIT_SP, regno);
|
||||
#else
|
||||
jit_stxi_f(_jitc->function->call.size + params_offset + 4,
|
||||
else
|
||||
jit_stxi_f(_jitc->function->call.size + params_offset + F_DISP,
|
||||
JIT_SP, regno);
|
||||
#endif
|
||||
}
|
||||
_jitc->function->call.size += sizeof(jit_word_t);
|
||||
jit_unget_reg(regno);
|
||||
}
|
||||
|
|
@ -662,12 +606,12 @@ void
|
|||
_jit_pushargr_d(jit_state_t *_jit, jit_int32_t u)
|
||||
{
|
||||
assert(_jitc->function);
|
||||
if (_jitc->function->call.argf < 13) {
|
||||
if (jit_arg_f_reg_p(_jitc->function->call.argf)) {
|
||||
jit_movr_d(JIT_FA0 - _jitc->function->call.argf, u);
|
||||
++_jitc->function->call.argf;
|
||||
if (!(_jitc->function->call.call & jit_call_varargs)) {
|
||||
/* in case of excess arguments */
|
||||
if (_jitc->function->call.argi < 8) {
|
||||
if (jit_arg_reg_p(_jitc->function->call.argi)) {
|
||||
#if __WORDSIZE == 32
|
||||
_jitc->function->call.argi += 2;
|
||||
#else
|
||||
|
|
@ -678,7 +622,7 @@ _jit_pushargr_d(jit_state_t *_jit, jit_int32_t u)
|
|||
return;
|
||||
}
|
||||
}
|
||||
if (_jitc->function->call.argi < 8) {
|
||||
if (jit_arg_reg_p(_jitc->function->call.argi)) {
|
||||
/* use reserved 8 bytes area */
|
||||
jit_stxi_d(alloca_offset - 8, JIT_FP, u);
|
||||
jit_ldxi(JIT_RA0 - _jitc->function->call.argi, JIT_FP,
|
||||
|
|
@ -701,12 +645,12 @@ _jit_pushargi_d(jit_state_t *_jit, jit_float64_t u)
|
|||
jit_int32_t regno;
|
||||
|
||||
assert(_jitc->function);
|
||||
if (_jitc->function->call.argf < 13) {
|
||||
if (jit_arg_f_reg_p(_jitc->function->call.argf)) {
|
||||
jit_movi_d(JIT_FA0 - _jitc->function->call.argf, u);
|
||||
++_jitc->function->call.argf;
|
||||
if (!(_jitc->function->call.call & jit_call_varargs)) {
|
||||
/* in case of excess arguments */
|
||||
if (_jitc->function->call.argi < 8) {
|
||||
if (jit_arg_reg_p(_jitc->function->call.argi)) {
|
||||
#if __WORDSIZE == 32
|
||||
_jitc->function->call.argi += 2;
|
||||
#else
|
||||
|
|
@ -719,7 +663,7 @@ _jit_pushargi_d(jit_state_t *_jit, jit_float64_t u)
|
|||
}
|
||||
regno = jit_get_reg(jit_class_fpr);
|
||||
jit_movi_d(regno, u);
|
||||
if (_jitc->function->call.argi < 8) {
|
||||
if (jit_arg_reg_p(_jitc->function->call.argi)) {
|
||||
/* use reserved 8 bytes area */
|
||||
jit_stxi_d(alloca_offset - 8, JIT_FP, regno);
|
||||
jit_ldxi(JIT_RA0 - _jitc->function->call.argi, JIT_FP,
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue