mirror/guile
mirror/guile
1
Fork 0
mirror of https://git.savannah.gnu.org/git/guile.git synced 2025-06-21 03:00:19 +02:00
Code Activity

Rework {get,push}arg{,i,r}_{f,d} to a more descriptive name and usage.

Browse source
This commit is contained in:
pcpa 2013-01-09 17:14:51 -02:00
parent 9d2566ee0a
commit 4fe47942eb
8 changed files with 168 additions and 123 deletions
Download patch file Download diff file Expand all files Collapse all files

14
ChangeLog
View file

@ -1,3 +1,17 @@
2013-01-09 Paulo Andrade <pcpa@gnu.org>
* include/lightning.h, lib/jit_arm.c, jit_mips-fpu.c,
lib/jit_mips.c, lib/jit_print.c, lib/jit_x86.c, lib/lightning.c:
Remove the jit_code_getarg_{f,d} and jit_code_pusharg{i,r}_{f,d}
calls, replacing them with the new, internal only, jit_movr_w_f,
jit_mov{r,i}_f_w, jit_movr_ww_d, and jit_mov{i,r}_d_ww, that
better describe the operation being done, and allow removing
the hackish code to detect special conditions for arm when
moving from/to vfp from/to a grp register pair.
Rename jit_code_retval_{f,d} to jit_code_x86_retval_{f,d} as
it is specific to 32 bit x86, and used to move abi return
value in x87 register to a sse register.
2013-01-05 Paulo Andrade <pcpa@gnu.org>
* check/cccall.c, check/ccall.ok: New test case to validate

21
include/lightning.h
View file

@ -432,7 +432,7 @@ typedef enum {
#define jit_arg_f() _jit_arg_f(_jit)
#define jit_getarg_f(u,v) _jit_getarg_f(_jit,u,v)
jit_code_arg_f, jit_code_getarg_f,
jit_code_arg_f,
#define jit_addr_f(u,v,w) jit_new_node_www(jit_code_addr_f,u,v,w)
#define jit_addi_f(u,v,w) jit_new_node_wwf(jit_code_addi_f,u,v,w)
@ -568,15 +568,13 @@ typedef enum {
#define jit_pushargr_f(u) _jit_pushargr_f(_jit,u)
#define jit_pushargi_f(u) _jit_pushargi_f(_jit,u)
jit_code_pushargr_f, jit_code_pushargi_f,
#define jit_retr_f(u) _jit_retr_f(_jit,u)
#define jit_reti_f(u) _jit_reti_f(_jit,u)
#define jit_retval_f(u) _jit_retval_f(_jit,u)
jit_code_retval_f,
#define jit_arg_d() _jit_arg_d(_jit)
#define jit_getarg_d(u,v) _jit_getarg_d(_jit,u,v)
jit_code_arg_d, jit_code_getarg_d,
jit_code_arg_d,
#define jit_addr_d(u,v,w) jit_new_node_www(jit_code_addr_d,u,v,w)
#define jit_addi_d(u,v,w) jit_new_node_wwd(jit_code_addi_d,u,v,w)
@ -713,11 +711,22 @@ typedef enum {
#define jit_pushargr_d(u) _jit_pushargr_d(_jit,u)
#define jit_pushargi_d(u) _jit_pushargi_d(_jit,u)
jit_code_pushargr_d, jit_code_pushargi_d,
#define jit_retr_d(u) _jit_retr_d(_jit,u)
#define jit_reti_d(u) _jit_reti_d(_jit,u)
#define jit_retval_d(u) _jit_retval_d(_jit,u)
jit_code_retval_d,
/* Special internal backend specific codes */
jit_code_movr_w_f, jit_code_movr_ww_d, /* w* -> f|d */
#define jit_movr_w_f(u, v) jit_new_node_ww(jit_code_movr_w_f, u, v)
#define jit_movr_ww_d(u, v, w) jit_new_node_www(jit_code_movr_ww_d, u, v, w)
jit_code_movr_f_w, jit_code_movi_f_w, /* f|d -> w* */
#define jit_movr_f_w(u, v) jit_new_node_ww(jit_code_movr_f_w, u, v)
#define jit_movi_f_w(u, v) jit_new_node_wf(jit_code_movi_f_w, u, v)
jit_code_movr_d_ww, jit_code_movi_d_ww,
#define jit_movr_d_ww(u, v, w) jit_new_node_www(jit_code_movr_d_ww, u, v, w)
#define jit_movi_d_ww(u, v, w) jit_new_node_wwd(jit_code_movi_d_ww, u, v, w)
jit_code_x86_retval_f, jit_code_x86_retval_d,
} jit_code_t;
/*

86
lib/jit_arm.c
View file

@ -292,28 +292,48 @@ _jit_reti(jit_state_t *_jit, jit_word_t u)
void
_jit_retr_f(jit_state_t *_jit, jit_int32_t u)
{
jit_movr_f(JIT_FRET, u);
if (jit_cpu.abi) {
if (u != JIT_FRET)
jit_movr_f(JIT_FRET, u);
}
else if (u != JIT_RET)
jit_movr_f_w(JIT_RET, u);
jit_ret();
}
void
_jit_reti_f(jit_state_t *_jit, jit_float32_t u)
{
jit_movi_f(JIT_FRET, u);
if (jit_cpu.abi) {
if (u != JIT_FRET)
jit_movi_f(JIT_FRET, u);
}
else if (u != JIT_RET)
jit_movi_f_w(JIT_RET, u);
jit_ret();
}
void
_jit_retr_d(jit_state_t *_jit, jit_int32_t u)
{
jit_movr_d(JIT_FRET, u);
if (jit_cpu.abi) {
if (u != JIT_FRET)
jit_movr_d(JIT_FRET, u);
}
else if (u != JIT_RET)
jit_movr_d_ww(JIT_RET, _R1, u);
jit_ret();
}
void
_jit_reti_d(jit_state_t *_jit, jit_float64_t u)
{
jit_movi_d(JIT_FRET, u);
if (jit_cpu.abi) {
if (u != JIT_FRET)
jit_movi_d(JIT_FRET, u);
}
else if (u != JIT_RET)
jit_movi_d_ww(JIT_RET, _R1, u);
jit_ret();
}
@ -485,7 +505,7 @@ _jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
jit_ldxi_f(u, JIT_FP, v->u.w < 4 ? v->u.w << 2 : v->u.w);
else {
if (v->u.w < 4)
jit_movr_f(u, JIT_RA0 - v->u.w);
jit_movr_w_f(u, JIT_RA0 - v->u.w);
else
jit_ldxi_f(u, JIT_FP, v->u.w);
}
@ -504,7 +524,7 @@ _jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
jit_ldxi_d(u, JIT_FP, v->u.w < 4 ? v->u.w << 2 : v->u.w);
else {
if (v->u.w < 4)
jit_movr_d(u, JIT_RA0 - v->u.w);
jit_movr_ww_d(u, JIT_RA0 - v->u.w, JIT_RA0 - (v->u.w + 1));
else
jit_ldxi_d(u, JIT_FP, v->u.w);
}
@ -556,7 +576,7 @@ _jit_pushargr_f(jit_state_t *_jit, jit_int32_t u)
}
else {
if (_jit->function->call.argi < 4) {
jit_movr_f(JIT_RA0 - _jit->function->call.argi, u);
jit_movr_f_w(JIT_RA0 - _jit->function->call.argi, u);
++_jit->function->call.argi;
return;
}
@ -580,7 +600,7 @@ _jit_pushargi_f(jit_state_t *_jit, jit_float32_t u)
}
else {
if (_jit->function->call.argi < 4) {
jit_movi_f(JIT_RA0 - _jit->function->call.argi, u);
jit_movi_f_w(JIT_RA0 - _jit->function->call.argi, u);
++_jit->function->call.argi;
return;
}
@ -609,7 +629,9 @@ _jit_pushargr_d(jit_state_t *_jit, jit_int32_t u)
if (_jit->function->call.argi & 1)
++_jit->function->call.argi;
if (_jit->function->call.argi < 4) {
jit_movr_d(JIT_RA0 - _jit->function->call.argi, u);
jit_movr_d_ww(JIT_RA0 - _jit->function->call.argi,
JIT_RA0 - (_jit->function->call.argi + 1),
u);
_jit->function->call.argi += 2;
return;
}
@ -639,7 +661,9 @@ _jit_pushargi_d(jit_state_t *_jit, jit_float64_t u)
if (_jit->function->call.argi & 1)
++_jit->function->call.argi;
if (_jit->function->call.argi < 4) {
jit_movi_d(JIT_RA0 - _jit->function->call.argi, u);
jit_movi_d_ww(JIT_RA0 - _jit->function->call.argi,
JIT_RA0 - (_jit->function->call.argi + 1),
u);
_jit->function->call.argi += 2;
return;
}
@ -745,7 +769,7 @@ _jit_retval_f(jit_state_t *_jit, jit_int32_t r0)
jit_movr_f(r0, JIT_FRET);
}
else if (r0 != JIT_RET)
jit_movr_f(r0, JIT_RET);
jit_movr_w_f(r0, JIT_RET);
}
void
@ -756,7 +780,7 @@ _jit_retval_d(jit_state_t *_jit, jit_int32_t r0)
jit_movr_d(r0, JIT_FRET);
}
else if (r0 != JIT_RET)
jit_movr_d(r0, JIT_RET);
jit_movr_ww_d(r0, JIT_RET, _R1);
}
jit_pointer_t
@ -1410,6 +1434,44 @@ _jit_emit(jit_state_t *_jit)
_jit->function = NULL;
flush_consts();
break;
case jit_code_movr_w_f:
if (jit_swf_p())
swf_movr_f(rn(node->u.w), rn(node->v.w));
else
vfp_movr_f(rn(node->u.w), rn(node->v.w));
break;
case jit_code_movr_f_w:
if (jit_swf_p())
swf_movr_f(rn(node->u.w), rn(node->v.w));
else
vfp_movr_f(rn(node->u.w), rn(node->v.w));
break;
case jit_code_movi_f_w:
assert_data(node);
if (jit_swf_p())
swf_movi_f(rn(node->u.w), node->v.f);
else
vfp_movi_f(rn(node->u.w), node->v.f);
break;
case jit_code_movr_ww_d:
if (jit_swf_p())
swf_movr_d(rn(node->u.w), rn(node->v.w));
else
vfp_movr_d(rn(node->u.w), rn(node->v.w));
break;
case jit_code_movr_d_ww:
if (jit_swf_p())
swf_movr_d(rn(node->u.w), rn(node->w.w));
else
vfp_movr_d(rn(node->u.w), rn(node->w.w));
break;
case jit_code_movi_d_ww:
assert_data(node);
if (jit_swf_p())
swf_movi_d(rn(node->u.w), node->w.d);
else
vfp_movi_d(rn(node->u.w), node->w.d);
break;
case jit_code_arg:
case jit_code_arg_f: case jit_code_arg_d:
break;

50
lib/jit_mips-fpu.c
View file

@ -212,10 +212,10 @@ static void _divi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
# define negr_d(r0,r1) NEG_D(r0,r1)
# define sqrtr_f(r0,r1) SQRT_S(r0,r1)
# define sqrtr_d(r0,r1) SQRT_D(r0,r1)
# define getarg_f(r0, r1) MTC1(r1, r0)
# define pushargr_f(r0, r1) MFC1(r1, r0)
# define pushargi_f(r0, i0) _pushargi_f(_jit, r0, i0)
static void _pushargi_f(jit_state_t*,jit_int32_t,jit_float32_t*);
# define movr_w_f(r0, r1) MTC1(r1, r0)
# define movr_f_w(r0, r1) MFC1(r1, r0)
# define movi_f_w(r0, i0) _movi_f_w(_jit, r0, i0)
static void _movi_f_w(jit_state_t*,jit_int32_t,jit_float32_t*);
# define extr_f(r0, r1) _extr_f(_jit, r0, r1)
static void _extr_f(jit_state_t*,jit_int32_t,jit_int32_t);
# define truncr_f_i(r0, r1) _truncr_f_i(_jit, r0, r1)
@ -243,12 +243,12 @@ static void _stxi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
static void _movr_f(jit_state_t*,jit_int32_t,jit_int32_t);
# define movi_f(r0, i0) _movi_f(_jit, r0, i0)
static void _movi_f(jit_state_t*,jit_int32_t,jit_float32_t*);
# define getarg_d(r0, r1) _getarg_d(_jit, r0, r1)
static void _getarg_d(jit_state_t*,jit_int32_t,jit_int32_t);
# define pushargr_d(r0, r1) _pushargr_d(_jit, r0, r1)
static void _pushargr_d(jit_state_t*,jit_int32_t,jit_int32_t);
# define pushargi_d(r0, i0) _pushargi_d(_jit, r0, i0)
static void _pushargi_d(jit_state_t*,jit_int32_t,jit_float64_t*);
# define movr_ww_d(r0, r1, r2) _movr_ww_d(_jit, r0, r1, r2)
static void _movr_ww_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
# define movr_d_ww(r0, r1, r2) _movr_d_ww(_jit, r0, r1, r2)
static void _movr_d_ww(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
# define movi_d_ww(r0, r1, i0) _movi_d_ww(_jit, r0, r1, i0)
static void _movi_d_ww(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
# define extr_d(r0, r1) _extr_d(_jit, r0, r1)
static void _extr_d(jit_state_t*,jit_int32_t,jit_int32_t);
# define truncr_d_i(r0, r1) _truncr_d_i(_jit, r0, r1)
@ -581,7 +581,7 @@ fopi(mul)
fopi(div)
static void
_pushargi_f(jit_state_t *_jit, jit_int32_t r0, jit_float32_t *i0)
_movi_f_w(jit_state_t *_jit, jit_int32_t r0, jit_float32_t *i0)
{
union {
jit_int32_t i;
@ -733,29 +733,23 @@ dopi(mul)
dopi(div)
static void
_getarg_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
_movr_ww_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
{
# if __WORDSIZE == 32
assert(r1 == r2 - 1);
MTC1(r1, r0);
MTC1(r1 + 1, r0 + 1);
# else
DMTC1(r1, r0);
# endif
MTC1(r2, r0 + 1);
}
static void
_pushargr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
_movr_d_ww(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
{
# if __WORDSIZE == 32
MFC1(r0, r1);
MFC1(r0 + 1, r1 + 1);
# else
DMFC1(r0, r1);
# endif
assert(r0 == r1 - 1);
MFC1(r0, r2);
MFC1(r1, r2 + 1);
}
static void
_pushargi_d(jit_state_t *_jit, jit_int32_t r0, jit_float64_t *i0)
_movi_d_ww(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_float64_t *i0)
{
union {
jit_int32_t i[2];
@ -764,12 +758,8 @@ _pushargi_d(jit_state_t *_jit, jit_int32_t r0, jit_float64_t *i0)
} data;
data.d = *i0;
# if __WORDSIZE == 64
movi(r0, data.l);
# else
movi(r0, data.i[0]);
movi(r0 + 1, data.i[1]);
# endif
movi(r1, data.i[1]);
}
static void

37
lib/jit_mips.c
View file

@ -381,7 +381,7 @@ void
_jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
if (v->u.w < 4)
jit_new_node_ww(jit_code_getarg_f, u, _A0 - v->u.w);
jit_movr_w_f(u, _A0 - v->u.w);
else if (v->u.w < 8)
jit_movr_f(u, _F12 - ((v->u.w - 4) >> 1));
else
@ -392,7 +392,7 @@ void
_jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
if (v->u.w < 4)
jit_new_node_ww(jit_code_getarg_d, u, _A0 - v->u.w);
jit_movr_ww_d(u, _A0 - v->u.w, _A0 - (v->u.w + 1));
else if (v->u.w < 8)
jit_movr_d(u, _F12 - ((v->u.w - 4) >> 1));
else
@ -447,7 +447,7 @@ _jit_pushargr_f(jit_state_t *_jit, jit_int32_t u)
}
else if (offset < 4) {
++_jit->function->call.argi;
jit_new_node_ww(jit_code_pushargr_f, _A0 - offset, u);
jit_movr_f_w(_A0 - offset, u);
}
else
jit_stxi_f(_jit->function->call.size, JIT_SP, u);
@ -468,7 +468,7 @@ _jit_pushargi_f(jit_state_t *_jit, jit_float32_t u)
}
else if (offset < 4) {
++_jit->function->call.argi;
jit_new_node_wf(jit_code_pushargi_f, _A0 - offset, u);
jit_movi_f_w(_A0 - offset, u);
}
else {
regno = jit_get_reg(jit_class_fpr);
@ -494,7 +494,7 @@ _jit_pushargr_d(jit_state_t *_jit, jit_int32_t u)
offset = _jit->function->call.size >> 2;
if (offset < 3) {
if (adjust) {
jit_new_node_ww(jit_code_pushargr_d, _A0 - offset, u);
jit_movr_d_ww(_A0 - offset, _A0 - (offset + 1), u);
_jit->function->call.argi += 2;
}
else {
@ -523,7 +523,7 @@ _jit_pushargi_d(jit_state_t *_jit, jit_float64_t u)
offset = _jit->function->call.size >> 2;
if (offset < 3) {
if (adjust) {
jit_new_node_wd(jit_code_pushargi_d, _A0 - offset, u);
jit_movi_d_ww(_A0 - offset, _A0 - (offset + 1), u);
_jit->function->call.argi += 2;
}
else {
@ -1184,21 +1184,26 @@ _jit_emit(jit_state_t *_jit)
epilog(node);
_jit->function = NULL;
break;
case jit_code_getarg_f:
getarg_f(rn(node->u.w), rn(node->v.w));
case jit_code_movr_w_f:
movr_w_f(rn(node->u.w), rn(node->v.w));
break;
case_rr(pusharg, _f);
case jit_code_pushargi_f:
case jit_code_movr_f_w:
movr_f_w(rn(node->u.w), rn(node->v.w));
break;
case jit_code_movi_f_w:
assert(node->flag & jit_flag_data);
pushargi_f(rn(node->u.w), (jit_float32_t *)node->v.n->u.w);
movi_f_w(rn(node->u.w), (jit_float32_t *)node->v.n->u.w);
break;
case jit_code_getarg_d:
getarg_d(rn(node->u.w), rn(node->v.w));
case jit_code_movr_ww_d:
movr_ww_d(rn(node->u.w), rn(node->v.w), rn(node->w.w));
break;
case_rr(pusharg, _d);
case jit_code_pushargi_d:
case jit_code_movr_d_ww:
movr_d_ww(rn(node->u.w), rn(node->v.w), rn(node->w.w));
break;
case jit_code_movi_d_ww:
assert(node->flag & jit_flag_data);
pushargi_d(rn(node->u.w), (jit_float64_t *)node->v.n->u.w);
movi_d_ww(rn(node->u.w), rn(node->v.w),
(jit_float64_t *)node->w.n->u.w);
break;
case jit_code_arg:
case jit_code_arg_f: case jit_code_arg_d:

12
lib/jit_print.c
View file

@ -119,7 +119,7 @@ static char *code_name[] = {
"jmpr", "jmpi",
"callr", "calli",
"epilog",
"arg_f", "getarg_f",
"arg_f",
"addr_f", "addi_f",
"subr_f", "subi_f",
"mulr_f", "muli_f",
@ -161,9 +161,7 @@ static char *code_name[] = {
"bltgtr_f", "bltgti_f",
"bordr_f", "bordi_f",
"bunordr_f", "bunordi_f",
"pushargr_f", "pushargi_f",
"retval_f",
"arg_d", "getarg_d",
"arg_d",
"addr_d", "addi_d",
"subr_d", "subi_d",
"mulr_d", "muli_d",
@ -205,8 +203,10 @@ static char *code_name[] = {
"bltgtr_d", "bltgti_d",
"bordr_d", "bordi_d",
"bunordr_d", "bunordi_d",
"pushargr_d", "pushargi_d",
"retval_d",
"movr_w_f", "movr_ww_d",
"movr_f_w", "movi_f_w",
"movr_d_ww", "movi_d_ww",
"x86_retval_f", "x86_retval_d",
};
/*

8
lib/jit_x86.c
View file

@ -849,7 +849,7 @@ void
_jit_retval_f(jit_state_t *_jit, jit_int32_t r0)
{
# if __WORDSIZE == 32
jit_new_node_w(jit_code_retval_f, r0);
jit_new_node_w(jit_code_x86_retval_f, r0);
# else
if (r0 != JIT_FRET)
jit_movr_f(r0, JIT_FRET);
@ -860,7 +860,7 @@ void
_jit_retval_d(jit_state_t *_jit, jit_int32_t r0)
{
# if __WORDSIZE == 32
jit_new_node_w(jit_code_retval_d, r0);
jit_new_node_w(jit_code_x86_retval_d, r0);
# else
if (r0 != JIT_FRET)
jit_movr_d(r0, JIT_FRET);
@ -1578,7 +1578,7 @@ _jit_emit(jit_state_t *_jit)
_jit->function = NULL;
break;
#if __WORDSIZE == 32
case jit_code_retval_f:
case jit_code_x86_retval_f:
if (jit_sse_reg_p(node->u.w)) {
fstpr(_ST1_REGNO);
sse_from_x87_f(rn(node->u.w), _ST0_REGNO);
@ -1586,7 +1586,7 @@ _jit_emit(jit_state_t *_jit)
else
fstpr(rn(node->u.w) + 1);
break;
case jit_code_retval_d:
case jit_code_x86_retval_d:
if (jit_sse_reg_p(node->u.w)) {
fstpr(_ST1_REGNO);
sse_from_x87_d(rn(node->u.w), _ST0_REGNO);

63
lib/lightning.c
View file

@ -793,10 +793,8 @@ _jit_classify(jit_state_t *_jit, jit_code_t code)
case jit_code_callr: case jit_code_jmpr:
mask = jit_cc_a0_reg|jit_cc_a0_jmp;
break;
case jit_code_pushargr_f: case jit_code_pushargr_d:
mask = jit_cc_a0_reg|jit_cc_a1_reg;
break;
case jit_code_retval_f: case jit_code_retval_d:
case jit_code_x86_retval_f:
case jit_code_x86_retval_d:
mask = jit_cc_a0_reg|jit_cc_a0_chg;
break;
case jit_code_movi: case jit_code_ldi_c: case jit_code_ldi_uc:
@ -805,12 +803,16 @@ _jit_classify(jit_state_t *_jit, jit_code_t code)
case jit_code_ldi_d:
mask = jit_cc_a0_reg|jit_cc_a0_chg|jit_cc_a1_int;
break;
case jit_code_movi_f: case jit_code_pushargi_f:
case jit_code_movi_f: case jit_code_movi_f_w:
mask = jit_cc_a0_reg|jit_cc_a0_chg|jit_cc_a1_flt;
break;
case jit_code_movi_d: case jit_code_pushargi_d:
case jit_code_movi_d:
mask = jit_cc_a0_reg|jit_cc_a0_chg|jit_cc_a1_dbl;
break;
case jit_code_movi_d_ww:
mask = jit_cc_a0_reg|jit_cc_a0_chg|jit_cc_a1_reg|jit_cc_a1_chg|
jit_cc_a2_dbl;
break;
case jit_code_negr: case jit_code_comr: case jit_code_movr:
case jit_code_extr_c: case jit_code_extr_uc: case jit_code_extr_s:
case jit_code_extr_us: case jit_code_extr_i: case jit_code_extr_ui:
@ -824,9 +826,13 @@ _jit_classify(jit_state_t *_jit, jit_code_t code)
case jit_code_negr_d: case jit_code_absr_d: case jit_code_sqrtr_d:
case jit_code_movr_d: case jit_code_extr_d: case jit_code_extr_f_d:
case jit_code_ldr_d:
case jit_code_getarg_f: case jit_code_getarg_d:
case jit_code_movr_w_f: case jit_code_movr_f_w:
mask = jit_cc_a0_reg|jit_cc_a0_chg|jit_cc_a1_reg;
break;
case jit_code_movr_d_ww:
mask = jit_cc_a0_reg|jit_cc_a0_chg|jit_cc_a1_reg|jit_cc_a1_chg|
jit_cc_a2_reg;
break;
case jit_code_addi: case jit_code_addxi: case jit_code_addci:
case jit_code_subi: case jit_code_subxi: case jit_code_subci:
case jit_code_muli: case jit_code_divi: case jit_code_divi_u:
@ -881,6 +887,7 @@ _jit_classify(jit_state_t *_jit, jit_code_t code)
case jit_code_unltr_d: case jit_code_unler_d: case jit_code_uneqr_d:
case jit_code_unger_d: case jit_code_ungtr_d: case jit_code_ltgtr_d:
case jit_code_ordr_d: case jit_code_unordr_d: case jit_code_ldxr_d:
case jit_code_movr_ww_d:
mask = jit_cc_a0_reg|jit_cc_a0_chg|jit_cc_a1_reg|jit_cc_a2_reg;
break;
case jit_code_sti_c: case jit_code_sti_s: case jit_code_sti_i:
@ -1354,48 +1361,6 @@ _jit_update(jit_state_t *_jit, jit_node_t *node,
jit_regset_setbit(*live, value);
}
break;
#if __arm__
/* This is not trivial to generalize, so, any backend
* that needs to pass double as arguments or receive
* double results in an integer register pair should
* need such special case(s).
*/
case jit_code_movi_d:
if (!(node->u.w & jit_regno_patch)) {
spec = jit_class(_rvs[node->u.w].spec);
if (spec & jit_class_gpr) {
/* must be a reti_d or pushargi_d */
jit_regset_clrbit(*mask, node->u.w + 1);
jit_regset_setbit(*live, node->u.w + 1);
jit_regset_clrbit(*mask, node->u.w);
jit_regset_setbit(*live, node->u.w);
}
else
goto fallback;
}
break;
case jit_code_movr_d:
if (!(node->u.w & jit_regno_patch)) {
spec = jit_class(_rvs[jit_regno(node->u.w)].spec);
if (spec & jit_class_gpr) {
/* must be a retr_d */
jit_regset_clrbit(*mask, node->u.w + 1);
jit_regset_setbit(*live, node->u.w + 1);
jit_regset_clrbit(*mask, node->u.w);
jit_regset_setbit(*live, node->u.w);
}
else
goto fallback;
}
if (!(node->v.w & jit_regno_patch)) {
if (jit_regset_tstbit(*mask, node->v.w)) {
jit_regset_clrbit(*mask, node->v.w);
jit_regset_setbit(*live, node->v.w);
}
}
break;
fallback:
#endif
default:
value = jit_classify(node->code);
if (value & jit_cc_a2_reg) {