From 4fe47942ebdbebfa346f9a91275ed4b512c07592 Mon Sep 17 00:00:00 2001 From: pcpa Date: Wed, 9 Jan 2013 17:14:51 -0200 Subject: [PATCH] Rework {get,push}arg{,i,r}_{f,d} to a more descriptive name and usage. --- ChangeLog | 14 ++++++++ include/lightning.h | 21 +++++++---- lib/jit_arm.c | 86 ++++++++++++++++++++++++++++++++++++++------- lib/jit_mips-fpu.c | 50 +++++++++++--------------- lib/jit_mips.c | 37 ++++++++++--------- lib/jit_print.c | 12 +++---- lib/jit_x86.c | 8 ++--- lib/lightning.c | 63 ++++++++------------------------- 8 files changed, 168 insertions(+), 123 deletions(-) diff --git a/ChangeLog b/ChangeLog index 5ab333f8d..97d8b2642 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,17 @@ +2013-01-09 Paulo Andrade + + * 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 * check/cccall.c, check/ccall.ok: New test case to validate diff --git a/include/lightning.h b/include/lightning.h index 298ef1851..821177ebd 100644 --- a/include/lightning.h +++ b/include/lightning.h @@ -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; /* diff --git a/lib/jit_arm.c b/lib/jit_arm.c index eb96a463f..d3316833a 100644 --- a/lib/jit_arm.c +++ b/lib/jit_arm.c @@ -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; diff --git a/lib/jit_mips-fpu.c b/lib/jit_mips-fpu.c index c4f51c667..1501febc2 100644 --- a/lib/jit_mips-fpu.c +++ b/lib/jit_mips-fpu.c @@ -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 diff --git a/lib/jit_mips.c b/lib/jit_mips.c index aba1a051c..cbf4ebd6b 100644 --- a/lib/jit_mips.c +++ b/lib/jit_mips.c @@ -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: diff --git a/lib/jit_print.c b/lib/jit_print.c index f5d3316bb..0b3d3bca0 100644 --- a/lib/jit_print.c +++ b/lib/jit_print.c @@ -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", }; /* diff --git a/lib/jit_x86.c b/lib/jit_x86.c index f79577029..fe7aa9863 100644 --- a/lib/jit_x86.c +++ b/lib/jit_x86.c @@ -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); diff --git a/lib/lightning.c b/lib/lightning.c index 805025158..f61aed34b 100644 --- a/lib/lightning.c +++ b/lib/lightning.c @@ -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) {