mirror/guile
mirror/guile
1
Fork 0
mirror of https://git.savannah.gnu.org/git/guile.git synced 2025-05-19 11:10:25 +02:00
Code Activity

Provide some type safety for jit_gpr_t and jit_fpr_t

Browse source
This commit is contained in:
Andy Wingo 2019-04-03 11:50:32 +02:00
parent cacdeeee4b
commit 99b4fd2d79
22 changed files with 265 additions and 350 deletions
Download patch file Download diff file Expand all files Collapse all files

20
jit.h
View file

@ -37,15 +37,19 @@ typedef float jit_float32_t;
typedef double jit_float64_t; typedef double jit_float64_t;
typedef void* jit_pointer_t; typedef void* jit_pointer_t;
typedef int jit_bool_t; typedef int jit_bool_t;
/* FIXME: Make the compiler warn when confusing GPR/FPR/immediate. */ typedef struct jit_gpr { int bits; } jit_gpr_t;
typedef int jit_gpr_t; typedef struct jit_fpr { int bits; } jit_fpr_t;
typedef int jit_fpr_t;
typedef void* jit_addr_t; typedef void* jit_addr_t;
typedef ptrdiff_t jit_off_t; typedef ptrdiff_t jit_off_t;
typedef intptr_t jit_imm_t; typedef intptr_t jit_imm_t;
typedef uintptr_t jit_uimm_t; typedef uintptr_t jit_uimm_t;
#define JIT_GPR(bits) ((jit_gpr_t) { bits })
#define JIT_FPR(bits) ((jit_fpr_t) { bits })
static inline jit_gpr_t jit_gpr(int bits) { return JIT_GPR(bits); }
static inline jit_fpr_t jit_fpr(int bits) { return JIT_FPR(bits); }
enum jit_reloc_kind enum jit_reloc_kind
{ {
JIT_RELOC_ABSOLUTE, JIT_RELOC_ABSOLUTE,
@ -91,9 +95,9 @@ typedef struct jit_reloc
# include "jit/alpha.h" # include "jit/alpha.h"
#endif #endif
#define JIT_R(index) jit_r(index) #define JIT_R(index) JIT_GPR(jit_r(index))
#define JIT_V(index) jit_v(index) #define JIT_V(index) JIT_GPR(jit_v(index))
#define JIT_F(index) jit_f(index) #define JIT_F(index) JIT_FPR(jit_f(index))
#define JIT_R_NUM jit_r_num() #define JIT_R_NUM jit_r_num()
#define JIT_V_NUM jit_v_num() #define JIT_V_NUM jit_v_num()
#define JIT_F_NUM jit_f_num() #define JIT_F_NUM jit_f_num()
@ -103,8 +107,8 @@ typedef struct jit_reloc
#define jit_class_sav 0x10000000 /* callee save */ #define jit_class_sav 0x10000000 /* callee save */
#define jit_class_gpr 0x20000000 /* general purpose */ #define jit_class_gpr 0x20000000 /* general purpose */
#define jit_class_fpr 0x40000000 /* float */ #define jit_class_fpr 0x40000000 /* float */
#define jit_class(reg) ((reg) & 0xffff0000) #define jit_class(bits) ((bits) & 0xffff0000)
#define jit_regno(reg) ((reg) & 0x00007fff) #define jit_regno(bits) ((bits) & 0x00007fff)
typedef struct jit_state jit_state_t; typedef struct jit_state jit_state_t;
enum jit_arg_loc enum jit_arg_loc

88
jit/jit.c
View file

@ -36,70 +36,70 @@
#endif #endif
#define rc(value) jit_class_##value #define rc(value) jit_class_##value
#define rn(reg) (jit_regno(_rvs[jit_regno(reg)].spec)) #define rn(reg) (jit_regno(_rvs[jit_regno(reg.bits)].spec))
#if defined(__i386__) || defined(__x86_64__) #if defined(__i386__) || defined(__x86_64__)
# define JIT_SP _RSP # define JIT_SP JIT_GPR(_RSP)
# define JIT_RET _RAX # define JIT_RET JIT_GPR(_RAX)
# if __X32 # if __X32
# define JIT_FRET _ST0 # define JIT_FRET JIT_FPR(_ST0)
# else # else
# if __CYGWIN__ # if __CYGWIN__
# define JIT_RA0 _RCX # define JIT_RA0 JIT_GPR(_RCX)
# else # else
# define JIT_RA0 _RDI # define JIT_RA0 JIT_GPR(_RDI)
# endif # endif
# define JIT_FA0 _XMM0 # define JIT_FA0 JIT_FPR(_XMM0)
# define JIT_FRET _XMM0 # define JIT_FRET JIT_FPR(_XMM0)
# endif # endif
#elif defined(__mips__) #elif defined(__mips__)
# define JIT_RA0 _A0 # define JIT_RA0 JIT_GPR(_A0)
# define JIT_FA0 _F12 # define JIT_FA0 JIT_FPR(_F12)
# define JIT_SP _SP # define JIT_SP JIT_GPR(_SP)
# define JIT_RET _V0 # define JIT_RET JIT_GPR(_V0)
# define JIT_FRET _F0 # define JIT_FRET JIT_FPR(_F0)
#elif defined(__arm__) #elif defined(__arm__)
# define JIT_RA0 _R0 # define JIT_RA0 JIT_GPR(_R0)
# define JIT_FA0 _D0 # define JIT_FA0 JIT_FPR(_D0)
# define JIT_SP _R13 # define JIT_SP JIT_GPR(_R13)
# define JIT_RET _R0 # define JIT_RET JIT_GPR(_R0)
# if defined(__ARM_PCS_VFP) # if defined(__ARM_PCS_VFP)
# define JIT_FRET _D0 # define JIT_FRET JIT_FPR(_D0)
# else # else
# define JIT_FRET _R0 # define JIT_FRET JIT_FPR(_R0)
# endif # endif
#elif defined(__ppc__) || defined(__powerpc__) #elif defined(__ppc__) || defined(__powerpc__)
# define JIT_RA0 _R3 # define JIT_RA0 JIT_GPR(_R3)
# define JIT_FA0 _F1 # define JIT_FA0 JIT_FPR(_F1)
# define JIT_SP _R1 # define JIT_SP JIT_GPR(_R1)
# define JIT_RET _R3 # define JIT_RET JIT_GPR(_R3)
# define JIT_FRET _F1 # define JIT_FRET JIT_FPR(_F1)
#elif defined(__sparc__) #elif defined(__sparc__)
# define JIT_SP _SP # define JIT_SP JIT_GPR(_SP)
# define JIT_RET _I0 # define JIT_RET JIT_GPR(_I0)
# define JIT_FRET _F0 # define JIT_FRET JIT_FPR(_F0)
#elif defined(__ia64__) #elif defined(__ia64__)
# define JIT_SP _R12 # define JIT_SP JIT_GPR(_R12)
# define JIT_RET _R8 # define JIT_RET JIT_GPR(_R8)
# define JIT_FRET _F8 # define JIT_FRET JIT_FPR(_F8)
#elif defined(__hppa__) #elif defined(__hppa__)
# define JIT_SP _R30 # define JIT_SP JIT_GPR(_R30)
# define JIT_RET _R28 # define JIT_RET JIT_GPR(_R28)
# define JIT_FRET _F4 # define JIT_FRET JIT_FPR(_F4)
#elif defined(__aarch64__) #elif defined(__aarch64__)
# define JIT_RA0 _R0 # define JIT_RA0 JIT_GPR(_R0)
# define JIT_FA0 _V0 # define JIT_FA0 JIT_FPR(_V0)
# define JIT_SP _SP # define JIT_SP JIT_GPR(_SP)
# define JIT_RET _R0 # define JIT_RET JIT_GPR(_R0)
# define JIT_FRET _V0 # define JIT_FRET JIT_FPR(_V0)
#elif defined(__s390__) || defined(__s390x__) #elif defined(__s390__) || defined(__s390x__)
# define JIT_SP _R15 # define JIT_SP JIT_GPR(_R15)
# define JIT_RET _R2 # define JIT_RET JIT_GPR(_R2)
# define JIT_FRET _F0 # define JIT_FRET JIT_FPR(_F0)
#elif defined(__alpha__) #elif defined(__alpha__)
# define JIT_SP _SP # define JIT_SP JIT_GPR(_SP)
# define JIT_RET _V0 # define JIT_RET JIT_GPR(_V0)
# define JIT_FRET _F0 # define JIT_FRET JIT_FPR(_F0)
#endif #endif
/* /*

146
jit/x86-cpu.c
View file

@ -272,9 +272,9 @@ get_temp_gpr(jit_state_t *_jit)
_jit->temp_gpr_saved = 1; _jit->temp_gpr_saved = 1;
#if __X32 #if __X32
pushr(_jit, _RBP_REGNO); pushr(_jit, _RBP_REGNO);
return _RBP; return JIT_GPR(_RBP);
#else #else
return _R8; return JIT_GPR(_R8);
#endif #endif
} }
@ -504,7 +504,7 @@ alui(jit_state_t *_jit, int32_t code, int32_t r0, jit_word_t i0)
ii(_jit, i0); ii(_jit, i0);
} }
} else { } else {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
movi(_jit, rn(reg), i0); movi(_jit, rn(reg), i0);
alur(_jit, code, r0, rn(reg)); alur(_jit, code, r0, rn(reg));
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
@ -709,7 +709,7 @@ addi(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
movi(_jit, r0, i0); movi(_jit, r0, i0);
iaddr(_jit, r0, r1); iaddr(_jit, r0, r1);
} else { } else {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
movi(_jit, rn(reg), i0); movi(_jit, rn(reg), i0);
iaddr(_jit, r0, rn(reg)); iaddr(_jit, r0, rn(reg));
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
@ -735,7 +735,7 @@ addci(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
iaddi(_jit, r0, i0); iaddi(_jit, r0, i0);
} }
else if (r0 == r1) { else if (r0 == r1) {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
movi(_jit, rn(reg), i0); movi(_jit, rn(reg), i0);
iaddr(_jit, r0, rn(reg)); iaddr(_jit, r0, rn(reg));
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
@ -764,7 +764,7 @@ addxi(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
iaddxi(_jit, r0, i0); iaddxi(_jit, r0, i0);
} }
else if (r0 == r1) { else if (r0 == r1) {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
movi(_jit, rn(reg), i0); movi(_jit, rn(reg), i0);
iaddxr(_jit, r0, rn(reg)); iaddxr(_jit, r0, rn(reg));
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
@ -809,7 +809,7 @@ subi(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
movi(_jit, r0, -i0); movi(_jit, r0, -i0);
iaddr(_jit, r0, r1); iaddr(_jit, r0, r1);
} else { } else {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
movi(_jit, rn(reg), i0); movi(_jit, rn(reg), i0);
isubr(_jit, r0, rn(reg)); isubr(_jit, r0, rn(reg));
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
@ -820,7 +820,7 @@ static void
subcr(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2) subcr(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
{ {
if (r0 == r2 && r0 != r1) { if (r0 == r2 && r0 != r1) {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
movr(_jit, rn(reg), r0); movr(_jit, rn(reg), r0);
movr(_jit, r0, r1); movr(_jit, r0, r1);
isubr(_jit, r0, rn(reg)); isubr(_jit, r0, rn(reg));
@ -838,7 +838,7 @@ subci(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
if (can_sign_extend_int_p(i0)) { if (can_sign_extend_int_p(i0)) {
isubi(_jit, r0, i0); isubi(_jit, r0, i0);
} else { } else {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
movi(_jit, rn(reg), i0); movi(_jit, rn(reg), i0);
isubr(_jit, r0, rn(reg)); isubr(_jit, r0, rn(reg));
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
@ -849,7 +849,7 @@ static void
subxr(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2) subxr(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
{ {
if (r0 == r2 && r0 != r1) { if (r0 == r2 && r0 != r1) {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
movr(_jit, rn(reg), r0); movr(_jit, rn(reg), r0);
movr(_jit, r0, r1); movr(_jit, r0, r1);
isubxr(_jit, r0, rn(reg)); isubxr(_jit, r0, rn(reg));
@ -867,7 +867,7 @@ subxi(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
if (can_sign_extend_int_p(i0)) { if (can_sign_extend_int_p(i0)) {
isubxi(_jit, r0, i0); isubxi(_jit, r0, i0);
} else { } else {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
imovi(_jit, rn(reg), i0); imovi(_jit, rn(reg), i0);
isubxr(_jit, r0, rn(reg)); isubxr(_jit, r0, rn(reg));
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
@ -887,7 +887,7 @@ rotshr(jit_state_t *_jit, int32_t code,
int32_t r0, int32_t r1, int32_t r2) int32_t r0, int32_t r1, int32_t r2)
{ {
if (r0 == _RCX_REGNO) { if (r0 == _RCX_REGNO) {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
movr(_jit, rn(reg), r1); movr(_jit, rn(reg), r1);
if (r2 != _RCX_REGNO) if (r2 != _RCX_REGNO)
movr(_jit, _RCX_REGNO, r2); movr(_jit, _RCX_REGNO, r2);
@ -1004,7 +1004,7 @@ imuli(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
ii(_jit, i0); ii(_jit, i0);
} }
} else { } else {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
movi(_jit, rn(reg), i0); movi(_jit, rn(reg), i0);
imulr(_jit, r0, rn(reg)); imulr(_jit, r0, rn(reg));
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
@ -1132,7 +1132,7 @@ iqmuli(jit_state_t *_jit, int32_t r0, int32_t r1,
ixorr(_jit, r0, r0); ixorr(_jit, r0, r0);
ixorr(_jit, r1, r1); ixorr(_jit, r1, r1);
} else { } else {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
movi(_jit, rn(reg), i0); movi(_jit, rn(reg), i0);
if (sign) if (sign)
qmulr(_jit, r0, r1, r2, rn(reg)); qmulr(_jit, r0, r1, r2, rn(reg));
@ -1172,9 +1172,9 @@ divremr(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2,
int tmp_divisor = 0; int tmp_divisor = 0;
if (r2 == _RAX_REGNO || r2 == _RDX_REGNO) { if (r2 == _RAX_REGNO || r2 == _RDX_REGNO) {
int32_t tmp = get_temp_gpr(_jit); jit_gpr_t tmp = get_temp_gpr(_jit);
movr(_jit, tmp, r2); movr(_jit, rn(tmp), r2);
r2 = tmp; r2 = rn(tmp);
tmp_divisor = 1; tmp_divisor = 1;
} }
@ -1206,10 +1206,10 @@ static void
divremi(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0, divremi(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0,
jit_bool_t sign, jit_bool_t divide) jit_bool_t sign, jit_bool_t divide)
{ {
int32_t r2 = get_temp_gpr(_jit); jit_gpr_t tmp = get_temp_gpr(_jit);
movi(_jit, r2, i0); movi(_jit, rn(tmp), i0);
divremr(_jit, r0, r1, r2, sign, divide); divremr(_jit, r0, r1, rn(tmp), sign, divide);
} }
static void static void
@ -1272,9 +1272,9 @@ iqdivr(jit_state_t *_jit, int32_t r0, int32_t r1,
int tmp_divisor = 0; int tmp_divisor = 0;
if (r3 == _RAX_REGNO || r3 == _RDX_REGNO) { if (r3 == _RAX_REGNO || r3 == _RDX_REGNO) {
int32_t tmp = get_temp_gpr(_jit); jit_gpr_t tmp = get_temp_gpr(_jit);
movr(_jit, tmp, r3); movr(_jit, rn(tmp), r3);
r3 = tmp; r3 = rn(tmp);
tmp_divisor = 1; tmp_divisor = 1;
} }
@ -1323,7 +1323,7 @@ static void
iqdivi(jit_state_t *_jit, int32_t r0, int32_t r1, iqdivi(jit_state_t *_jit, int32_t r0, int32_t r1,
int32_t r2, jit_word_t i0, jit_bool_t sign) int32_t r2, jit_word_t i0, jit_bool_t sign)
{ {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
movi(_jit, rn(reg), i0); movi(_jit, rn(reg), i0);
if (sign) if (sign)
qdivr(_jit, r0, r1, r2, rn(reg)); qdivr(_jit, r0, r1, r2, rn(reg));
@ -1378,7 +1378,7 @@ andi(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
if (can_sign_extend_int_p(i0)) { if (can_sign_extend_int_p(i0)) {
iandi(_jit, r0, i0); iandi(_jit, r0, i0);
} else { } else {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
movi(_jit, rn(reg), i0); movi(_jit, rn(reg), i0);
iandr(_jit, r0, rn(reg)); iandr(_jit, r0, rn(reg));
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
@ -1419,7 +1419,7 @@ ori(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
movi(_jit, r0, i0); movi(_jit, r0, i0);
iorr(_jit, r0, r1); iorr(_jit, r0, r1);
} else { } else {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
movi(_jit, rn(reg), i0); movi(_jit, rn(reg), i0);
iorr(_jit, r0, rn(reg)); iorr(_jit, r0, rn(reg));
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
@ -1456,7 +1456,7 @@ xori(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
movi(_jit, r0, i0); movi(_jit, r0, i0);
ixorr(_jit, r0, r1); ixorr(_jit, r0, r1);
} else { } else {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
movi(_jit, rn(reg), i0); movi(_jit, rn(reg), i0);
ixorr(_jit, r0, rn(reg)); ixorr(_jit, r0, rn(reg));
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
@ -1475,7 +1475,7 @@ cr(jit_state_t *_jit, int32_t code, int32_t r0, int32_t r1, int32_t r2)
imovi(_jit, r0, 0); imovi(_jit, r0, 0);
cc(_jit, code, r0); cc(_jit, code, r0);
} else { } else {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
ixorr(_jit, rn(reg), rn(reg)); ixorr(_jit, rn(reg), rn(reg));
icmpr(_jit, r1, r2); icmpr(_jit, r1, r2);
cc(_jit, code, rn(reg)); cc(_jit, code, rn(reg));
@ -1496,7 +1496,7 @@ ci(jit_state_t *_jit, int32_t code, int32_t r0, int32_t r1, jit_word_t i0)
imovi(_jit, r0, 0); imovi(_jit, r0, 0);
cc(_jit, code, r0); cc(_jit, code, r0);
} else { } else {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
ixorr(_jit, rn(reg), rn(reg)); ixorr(_jit, rn(reg), rn(reg));
icmpi(_jit, r1, i0); icmpi(_jit, r1, i0);
cc(_jit, code, rn(reg)); cc(_jit, code, rn(reg));
@ -1517,7 +1517,7 @@ ci0(jit_state_t *_jit, int32_t code, int32_t r0, int32_t r1)
imovi(_jit, r0, 0); imovi(_jit, r0, 0);
cc(_jit, code, r0); cc(_jit, code, r0);
} else { } else {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
ixorr(_jit, rn(reg), rn(reg)); ixorr(_jit, rn(reg), rn(reg));
testr(_jit, r1, r1); testr(_jit, r1, r1);
cc(_jit, code, rn(reg)); cc(_jit, code, rn(reg));
@ -1532,7 +1532,7 @@ extr_c(jit_state_t *_jit, int32_t r0, int32_t r1)
if (reg8_p(r1)) { if (reg8_p(r1)) {
movcr(_jit, r0, r1); movcr(_jit, r0, r1);
} else { } else {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
movr(_jit, rn(reg), r1); movr(_jit, rn(reg), r1);
movcr(_jit, r0, rn(reg)); movcr(_jit, r0, rn(reg));
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
@ -1545,7 +1545,7 @@ extr_uc(jit_state_t *_jit, int32_t r0, int32_t r1)
if (reg8_p(r1)) { if (reg8_p(r1)) {
movcr_u(_jit, r0, r1); movcr_u(_jit, r0, r1);
} else { } else {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
movr(_jit, rn(reg), r1); movr(_jit, rn(reg), r1);
movcr_u(_jit, r0, rn(reg)); movcr_u(_jit, r0, rn(reg));
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
@ -1626,7 +1626,7 @@ ldi_c(jit_state_t *_jit, int32_t r0, jit_word_t i0)
ic(_jit, 0xbe); ic(_jit, 0xbe);
rx(_jit, r0, i0, _NOREG, _NOREG, _SCL1); rx(_jit, r0, i0, _NOREG, _NOREG, _SCL1);
} else { } else {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
movi(_jit, rn(reg), i0); movi(_jit, rn(reg), i0);
ldr_c(_jit, r0, rn(reg)); ldr_c(_jit, r0, rn(reg));
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
@ -1651,7 +1651,7 @@ ldi_uc(jit_state_t *_jit, int32_t r0, jit_word_t i0)
ic(_jit, 0xb6); ic(_jit, 0xb6);
rx(_jit, r0, i0, _NOREG, _NOREG, _SCL1); rx(_jit, r0, i0, _NOREG, _NOREG, _SCL1);
} else { } else {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
movi(_jit, rn(reg), i0); movi(_jit, rn(reg), i0);
ldr_uc(_jit, r0, rn(reg)); ldr_uc(_jit, r0, rn(reg));
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
@ -1676,7 +1676,7 @@ ldi_s(jit_state_t *_jit, int32_t r0, jit_word_t i0)
ic(_jit, 0xbf); ic(_jit, 0xbf);
rx(_jit, r0, i0, _NOREG, _NOREG, _SCL1); rx(_jit, r0, i0, _NOREG, _NOREG, _SCL1);
} else { } else {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
movi(_jit, rn(reg), i0); movi(_jit, rn(reg), i0);
ldr_s(_jit, r0, rn(reg)); ldr_s(_jit, r0, rn(reg));
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
@ -1701,7 +1701,7 @@ ldi_us(jit_state_t *_jit, int32_t r0, jit_word_t i0)
ic(_jit, 0xb7); ic(_jit, 0xb7);
rx(_jit, r0, i0, _NOREG, _NOREG, _SCL1); rx(_jit, r0, i0, _NOREG, _NOREG, _SCL1);
} else { } else {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
movi(_jit, rn(reg), i0); movi(_jit, rn(reg), i0);
ldr_us(_jit, r0, rn(reg)); ldr_us(_jit, r0, rn(reg));
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
@ -1733,7 +1733,7 @@ ldi_i(jit_state_t *_jit, int32_t r0, jit_word_t i0)
#endif #endif
rx(_jit, r0, i0, _NOREG, _NOREG, _SCL1); rx(_jit, r0, i0, _NOREG, _NOREG, _SCL1);
} else { } else {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
movi(_jit, rn(reg), i0); movi(_jit, rn(reg), i0);
ldr_i(_jit, r0, rn(reg)); ldr_i(_jit, r0, rn(reg));
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
@ -1758,7 +1758,7 @@ ldi_ui(jit_state_t *_jit, int32_t r0, jit_word_t i0)
ic(_jit, 0x63); ic(_jit, 0x63);
rx(_jit, r0, i0, _NOREG, _NOREG, _SCL1); rx(_jit, r0, i0, _NOREG, _NOREG, _SCL1);
} else { } else {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
movi(_jit, rn(reg), i0); movi(_jit, rn(reg), i0);
ldr_ui(_jit, r0, rn(reg)); ldr_ui(_jit, r0, rn(reg));
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
@ -1782,7 +1782,7 @@ ldi_l(jit_state_t *_jit, int32_t r0, jit_word_t i0)
ic(_jit, 0x8b); ic(_jit, 0x8b);
rx(_jit, r0, i0, _NOREG, _NOREG, _SCL1); rx(_jit, r0, i0, _NOREG, _NOREG, _SCL1);
} else { } else {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
movi(_jit, rn(reg), i0); movi(_jit, rn(reg), i0);
ldr_l(_jit, r0, rn(reg)); ldr_l(_jit, r0, rn(reg));
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
@ -1814,7 +1814,7 @@ ldxi_c(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
ic(_jit, 0xbe); ic(_jit, 0xbe);
rx(_jit, r0, i0, r1, _NOREG, _SCL1); rx(_jit, r0, i0, r1, _NOREG, _SCL1);
} else { } else {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
movi(_jit, rn(reg), i0); movi(_jit, rn(reg), i0);
ldxr_c(_jit, r0, r1, rn(reg)); ldxr_c(_jit, r0, r1, rn(reg));
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
@ -1844,7 +1844,7 @@ ldxi_uc(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
ic(_jit, 0xb6); ic(_jit, 0xb6);
rx(_jit, r0, i0, r1, _NOREG, _SCL1); rx(_jit, r0, i0, r1, _NOREG, _SCL1);
} else { } else {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
movi(_jit, rn(reg), i0); movi(_jit, rn(reg), i0);
ldxr_uc(_jit, r0, r1, rn(reg)); ldxr_uc(_jit, r0, r1, rn(reg));
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
@ -1874,7 +1874,7 @@ ldxi_s(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
ic(_jit, 0xbf); ic(_jit, 0xbf);
rx(_jit, r0, i0, r1, _NOREG, _SCL1); rx(_jit, r0, i0, r1, _NOREG, _SCL1);
} else { } else {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
movi(_jit, rn(reg), i0); movi(_jit, rn(reg), i0);
ldxr_s(_jit, r0, r1, rn(reg)); ldxr_s(_jit, r0, r1, rn(reg));
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
@ -1904,7 +1904,7 @@ ldxi_us(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
ic(_jit, 0xb7); ic(_jit, 0xb7);
rx(_jit, r0, i0, r1, _NOREG, _SCL1); rx(_jit, r0, i0, r1, _NOREG, _SCL1);
} else { } else {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
movi(_jit, rn(reg), i0); movi(_jit, rn(reg), i0);
ldxr_us(_jit, r0, r1, rn(reg)); ldxr_us(_jit, r0, r1, rn(reg));
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
@ -1936,7 +1936,7 @@ ldxi_i(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
#endif #endif
rx(_jit, r0, i0, r1, _NOREG, _SCL1); rx(_jit, r0, i0, r1, _NOREG, _SCL1);
} else { } else {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
movi(_jit, rn(reg), i0); movi(_jit, rn(reg), i0);
ldxr_i(_jit, r0, r1, rn(reg)); ldxr_i(_jit, r0, r1, rn(reg));
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
@ -1967,7 +1967,7 @@ ldxi_ui(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
ic(_jit, 0x8b); ic(_jit, 0x8b);
rx(_jit, r0, i0, r1, _NOREG, _SCL1); rx(_jit, r0, i0, r1, _NOREG, _SCL1);
} else { } else {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
movi(_jit, rn(reg), i0); movi(_jit, rn(reg), i0);
ldxr_ui(_jit, r0, r1, rn(reg)); ldxr_ui(_jit, r0, r1, rn(reg));
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
@ -1991,7 +1991,7 @@ ldxi_l(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
ic(_jit, 0x8b); ic(_jit, 0x8b);
rx(_jit, r0, i0, r1, _NOREG, _SCL1); rx(_jit, r0, i0, r1, _NOREG, _SCL1);
} else { } else {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
movi(_jit, rn(reg), i0); movi(_jit, rn(reg), i0);
ldxr_l(_jit, r0, r1, rn(reg)); ldxr_l(_jit, r0, r1, rn(reg));
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
@ -2008,7 +2008,7 @@ str_c(jit_state_t *_jit, int32_t r0, int32_t r1)
ic(_jit, 0x88); ic(_jit, 0x88);
rx(_jit, r1, 0, r0, _NOREG, _SCL1); rx(_jit, r1, 0, r0, _NOREG, _SCL1);
} else { } else {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
movr(_jit, rn(reg), r1); movr(_jit, rn(reg), r1);
rex(_jit, 0, 0, rn(reg), _NOREG, r0); rex(_jit, 0, 0, rn(reg), _NOREG, r0);
ic(_jit, 0x88); ic(_jit, 0x88);
@ -2026,7 +2026,7 @@ sti_c(jit_state_t *_jit, jit_word_t i0, int32_t r0)
ic(_jit, 0x88); ic(_jit, 0x88);
rx(_jit, r0, i0, _NOREG, _NOREG, _SCL1); rx(_jit, r0, i0, _NOREG, _NOREG, _SCL1);
} else { } else {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
movr(_jit, rn(reg), r0); movr(_jit, rn(reg), r0);
rex(_jit, 0, 0, rn(reg), _NOREG, _NOREG); rex(_jit, 0, 0, rn(reg), _NOREG, _NOREG);
ic(_jit, 0x88); ic(_jit, 0x88);
@ -2034,7 +2034,7 @@ sti_c(jit_state_t *_jit, jit_word_t i0, int32_t r0)
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
} }
} else { } else {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
movi(_jit, rn(reg), i0); movi(_jit, rn(reg), i0);
str_c(_jit, rn(reg), r0); str_c(_jit, rn(reg), r0);
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
@ -2059,7 +2059,7 @@ sti_s(jit_state_t *_jit, jit_word_t i0, int32_t r0)
ic(_jit, 0x89); ic(_jit, 0x89);
rx(_jit, r0, i0, _NOREG, _NOREG, _SCL1); rx(_jit, r0, i0, _NOREG, _NOREG, _SCL1);
} else { } else {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
movi(_jit, rn(reg), i0); movi(_jit, rn(reg), i0);
str_s(_jit, rn(reg), r0); str_s(_jit, rn(reg), r0);
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
@ -2082,7 +2082,7 @@ sti_i(jit_state_t *_jit, jit_word_t i0, int32_t r0)
ic(_jit, 0x89); ic(_jit, 0x89);
rx(_jit, r0, i0, _NOREG, _NOREG, _SCL1); rx(_jit, r0, i0, _NOREG, _NOREG, _SCL1);
} else { } else {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
movi(_jit, rn(reg), i0); movi(_jit, rn(reg), i0);
str_i(_jit, rn(reg), r0); str_i(_jit, rn(reg), r0);
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
@ -2106,7 +2106,7 @@ sti_l(jit_state_t *_jit, jit_word_t i0, int32_t r0)
ic(_jit, 0x89); ic(_jit, 0x89);
rx(_jit, r0, i0, _NOREG, _NOREG, _SCL1); rx(_jit, r0, i0, _NOREG, _NOREG, _SCL1);
} else { } else {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
movi(_jit, rn(reg), i0); movi(_jit, rn(reg), i0);
str_l(_jit, rn(reg), r0); str_l(_jit, rn(reg), r0);
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
@ -2118,7 +2118,7 @@ static void
stxr_c(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2) stxr_c(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
{ {
#if __X64_32 #if __X64_32
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
addr(_jit, rn(reg), r0, r1); addr(_jit, rn(reg), r0, r1);
str_c(_jit, rn(reg), r2); str_c(_jit, rn(reg), r2);
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
@ -2128,7 +2128,7 @@ stxr_c(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
ic(_jit, 0x88); ic(_jit, 0x88);
rx(_jit, r2, 0, r0, r1, _SCL1); rx(_jit, r2, 0, r0, r1, _SCL1);
} else { } else {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
movr(_jit, rn(reg), r2); movr(_jit, rn(reg), r2);
rex(_jit, 0, 0, rn(reg), r1, r0); rex(_jit, 0, 0, rn(reg), r1, r0);
ic(_jit, 0x88); ic(_jit, 0x88);
@ -2147,7 +2147,7 @@ stxi_c(jit_state_t *_jit, jit_word_t i0, int32_t r0, int32_t r1)
ic(_jit, 0x88); ic(_jit, 0x88);
rx(_jit, r1, i0, r0, _NOREG, _SCL1); rx(_jit, r1, i0, r0, _NOREG, _SCL1);
} else { } else {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
movr(_jit, rn(reg), r1); movr(_jit, rn(reg), r1);
rex(_jit, 0, 0, rn(reg), _NOREG, r0); rex(_jit, 0, 0, rn(reg), _NOREG, r0);
ic(_jit, 0x88); ic(_jit, 0x88);
@ -2155,7 +2155,7 @@ stxi_c(jit_state_t *_jit, jit_word_t i0, int32_t r0, int32_t r1)
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
} }
} else { } else {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
movi(_jit, rn(reg), i0); movi(_jit, rn(reg), i0);
stxr_c(_jit, rn(reg), r0, r1); stxr_c(_jit, rn(reg), r0, r1);
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
@ -2166,7 +2166,7 @@ static void
stxr_s(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2) stxr_s(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
{ {
#if __X64_32 #if __X64_32
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
addr(_jit, rn(reg), r0, r1); addr(_jit, rn(reg), r0, r1);
str_s(_jit, rn(reg), r2); str_s(_jit, rn(reg), r2);
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
@ -2187,7 +2187,7 @@ stxi_s(jit_state_t *_jit, jit_word_t i0, int32_t r0, int32_t r1)
ic(_jit, 0x89); ic(_jit, 0x89);
rx(_jit, r1, i0, r0, _NOREG, _SCL1); rx(_jit, r1, i0, r0, _NOREG, _SCL1);
} else { } else {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
movi(_jit, rn(reg), i0); movi(_jit, rn(reg), i0);
stxr_s(_jit, rn(reg), r0, r1); stxr_s(_jit, rn(reg), r0, r1);
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
@ -2198,7 +2198,7 @@ static void
stxr_i(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2) stxr_i(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
{ {
#if __X64_32 #if __X64_32
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
addr(_jit, rn(reg), r0, r1); addr(_jit, rn(reg), r0, r1);
str_i(rn(reg), r2); str_i(rn(reg), r2);
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
@ -2217,7 +2217,7 @@ stxi_i(jit_state_t *_jit, jit_word_t i0, int32_t r0, int32_t r1)
ic(_jit, 0x89); ic(_jit, 0x89);
rx(_jit, r1, i0, r0, _NOREG, _SCL1); rx(_jit, r1, i0, r0, _NOREG, _SCL1);
} else { } else {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
movi(_jit, rn(reg), i0); movi(_jit, rn(reg), i0);
stxr_i(_jit, rn(reg), r0, r1); stxr_i(_jit, rn(reg), r0, r1);
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
@ -2241,7 +2241,7 @@ stxi_l(jit_state_t *_jit, jit_word_t i0, int32_t r0, int32_t r1)
ic(_jit, 0x89); ic(_jit, 0x89);
rx(_jit, r1, i0, r0, _NOREG, _SCL1); rx(_jit, r1, i0, r0, _NOREG, _SCL1);
} else { } else {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
movi(_jit, rn(reg), i0); movi(_jit, rn(reg), i0);
stxr_l(_jit, rn(reg), r0, r1); stxr_l(_jit, rn(reg), r0, r1);
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
@ -2438,7 +2438,7 @@ bmsi(jit_state_t *_jit, int32_t r0, jit_word_t i1)
if (can_zero_extend_int_p(i1)) { if (can_zero_extend_int_p(i1)) {
testi(_jit, r0, i1); testi(_jit, r0, i1);
} else { } else {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
movi(_jit, rn(reg), i1); movi(_jit, rn(reg), i1);
testr(_jit, r0, rn(reg)); testr(_jit, r0, rn(reg));
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
@ -2459,7 +2459,7 @@ bmci(jit_state_t *_jit, int32_t r0, jit_word_t i1)
if (can_zero_extend_int_p(i1)) { if (can_zero_extend_int_p(i1)) {
testi(_jit, r0, i1); testi(_jit, r0, i1);
} else { } else {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
movi(_jit, rn(reg), i1); movi(_jit, rn(reg), i1);
testr(_jit, r0, rn(reg)); testr(_jit, r0, rn(reg));
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
@ -2481,7 +2481,7 @@ boaddi(jit_state_t *_jit, int32_t r0, jit_word_t i1)
iaddi(_jit, r0, i1); iaddi(_jit, r0, i1);
return jo(_jit); return jo(_jit);
} }
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
movi(_jit, rn(reg), i1); movi(_jit, rn(reg), i1);
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
return boaddr(_jit, r0, rn(reg)); return boaddr(_jit, r0, rn(reg));
@ -2501,7 +2501,7 @@ boaddi_u(jit_state_t *_jit, int32_t r0, jit_word_t i1)
iaddi(_jit, r0, i1); iaddi(_jit, r0, i1);
return jc(_jit); return jc(_jit);
} }
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
movi(_jit, rn(reg), i1); movi(_jit, rn(reg), i1);
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
return boaddr_u(_jit, r0, rn(reg)); return boaddr_u(_jit, r0, rn(reg));
@ -2521,7 +2521,7 @@ bxaddi(jit_state_t *_jit, int32_t r0, jit_word_t i1)
iaddi(_jit, r0, i1); iaddi(_jit, r0, i1);
return jno(_jit); return jno(_jit);
} }
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
movi(_jit, rn(reg), i1); movi(_jit, rn(reg), i1);
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
return bxaddr(_jit, r0, rn(reg)); return bxaddr(_jit, r0, rn(reg));
@ -2541,7 +2541,7 @@ bxaddi_u(jit_state_t *_jit, int32_t r0, jit_word_t i1)
iaddi(_jit, r0, i1); iaddi(_jit, r0, i1);
return jnc(_jit); return jnc(_jit);
} }
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
movi(_jit, rn(reg), i1); movi(_jit, rn(reg), i1);
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
return bxaddr_u(_jit, r0, rn(reg)); return bxaddr_u(_jit, r0, rn(reg));
@ -2561,7 +2561,7 @@ bosubi(jit_state_t *_jit, int32_t r0, jit_word_t i1)
isubi(_jit, r0, i1); isubi(_jit, r0, i1);
return jo(_jit); return jo(_jit);
} }
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
movi(_jit, rn(reg), i1); movi(_jit, rn(reg), i1);
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
return bosubr(_jit, r0, rn(reg)); return bosubr(_jit, r0, rn(reg));
@ -2581,7 +2581,7 @@ bosubi_u(jit_state_t *_jit, int32_t r0, jit_word_t i1)
isubi(_jit, r0, i1); isubi(_jit, r0, i1);
return jc(_jit); return jc(_jit);
} }
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
movi(_jit, rn(reg), i1); movi(_jit, rn(reg), i1);
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
return bosubr_u(_jit, r0, rn(reg)); return bosubr_u(_jit, r0, rn(reg));
@ -2601,7 +2601,7 @@ bxsubi(jit_state_t *_jit, int32_t r0, jit_word_t i1)
isubi(_jit, r0, i1); isubi(_jit, r0, i1);
return jno(_jit); return jno(_jit);
} }
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
movi(_jit, rn(reg), i1); movi(_jit, rn(reg), i1);
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
return bxsubr(_jit, r0, rn(reg)); return bxsubr(_jit, r0, rn(reg));
@ -2621,7 +2621,7 @@ bxsubi_u(jit_state_t *_jit, int32_t r0, jit_word_t i1)
isubi(_jit, r0, i1); isubi(_jit, r0, i1);
return jnc(_jit); return jnc(_jit);
} }
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
movi(_jit, rn(reg), i1); movi(_jit, rn(reg), i1);
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
return bxsubr_u(_jit, r0, rn(reg)); return bxsubr_u(_jit, r0, rn(reg));
@ -2646,7 +2646,7 @@ calli(jit_state_t *_jit, jit_word_t i0)
} }
else else
{ {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
jit_patch_there(_jit, mov_addr(_jit, rn(reg)), (void*)i0); jit_patch_there(_jit, mov_addr(_jit, rn(reg)), (void*)i0);
callr(_jit, rn(reg)); callr(_jit, rn(reg));
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
@ -2672,7 +2672,7 @@ jmpi(jit_state_t *_jit, jit_word_t i0)
} }
else else
{ {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
jit_patch_there(_jit, mov_addr(_jit, rn(reg)), (void*)i0); jit_patch_there(_jit, mov_addr(_jit, rn(reg)), (void*)i0);
jmpr(_jit, rn(reg)); jmpr(_jit, rn(reg));
unget_temp_gpr(_jit); unget_temp_gpr(_jit);

52
jit/x86-sse.c
View file

@ -181,7 +181,7 @@ pushr_d(jit_state_t *_jit, int32_t r0)
static void static void
popr_d(jit_state_t *_jit, int32_t r0) popr_d(jit_state_t *_jit, int32_t r0)
{ {
int32_t tmp = get_temp_gpr(_jit); jit_gpr_t tmp = get_temp_gpr(_jit);
popr(_jit, rn(tmp)); popr(_jit, rn(tmp));
ssexr(_jit, 0x66, X86_SSE_G2X, r0, rn(tmp)); ssexr(_jit, 0x66, X86_SSE_G2X, r0, rn(tmp));
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
@ -193,7 +193,7 @@ get_temp_xpr(jit_state_t *_jit)
/* Reserve XMM7 for the JIT. */ /* Reserve XMM7 for the JIT. */
ASSERT(!_jit->temp_fpr_saved); ASSERT(!_jit->temp_fpr_saved);
_jit->temp_fpr_saved = 1; _jit->temp_fpr_saved = 1;
return _XMM7; return JIT_FPR(_XMM7);
} }
static void static void
@ -379,7 +379,7 @@ movi_f(jit_state_t *_jit, int32_t r0, jit_float32_t i0)
if (data.f == 0.0 && !(data.i & 0x80000000)) if (data.f == 0.0 && !(data.i & 0x80000000))
xorpsr(_jit, r0, r0); xorpsr(_jit, r0, r0);
else { else {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
movi(_jit, rn(reg), data.i); movi(_jit, rn(reg), data.i);
movdlxr(_jit, r0, rn(reg)); movdlxr(_jit, r0, rn(reg));
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
@ -399,7 +399,7 @@ movi_d(jit_state_t *_jit, int32_t r0, jit_float64_t i0)
if (data.d == 0.0 && !(data.ii[1] & 0x80000000)) if (data.d == 0.0 && !(data.ii[1] & 0x80000000))
xorpdr(_jit, r0, r0); xorpdr(_jit, r0, r0);
else { else {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
#if __X64 && !__X64_32 #if __X64 && !__X64_32
movi(_jit, rn(reg), data.w); movi(_jit, rn(reg), data.w);
movdqxr(_jit, r0, rn(reg)); movdqxr(_jit, r0, rn(reg));
@ -477,7 +477,7 @@ subr_f(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
if (r0 == r1) if (r0 == r1)
subssr(_jit, r0, r2); subssr(_jit, r0, r2);
else if (r0 == r2) { else if (r0 == r2) {
int32_t reg = get_temp_xpr(_jit); jit_fpr_t reg = get_temp_xpr(_jit);
movr_f(_jit, rn(reg), r0); movr_f(_jit, rn(reg), r0);
movr_f(_jit, r0, r1); movr_f(_jit, r0, r1);
subssr(_jit, r0, rn(reg)); subssr(_jit, r0, rn(reg));
@ -495,7 +495,7 @@ subr_d(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
if (r0 == r1) if (r0 == r1)
subsdr(_jit, r0, r2); subsdr(_jit, r0, r2);
else if (r0 == r2) { else if (r0 == r2) {
int32_t reg = get_temp_xpr(_jit); jit_fpr_t reg = get_temp_xpr(_jit);
movr_d(_jit, rn(reg), r0); movr_d(_jit, rn(reg), r0);
movr_d(_jit, r0, r1); movr_d(_jit, r0, r1);
subsdr(_jit, r0, rn(reg)); subsdr(_jit, r0, rn(reg));
@ -539,7 +539,7 @@ divr_f(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
if (r0 == r1) if (r0 == r1)
divssr(_jit, r0, r2); divssr(_jit, r0, r2);
else if (r0 == r2) { else if (r0 == r2) {
int32_t reg = get_temp_xpr(_jit); jit_fpr_t reg = get_temp_xpr(_jit);
movr_f(_jit, rn(reg), r0); movr_f(_jit, rn(reg), r0);
movr_f(_jit, r0, r1); movr_f(_jit, r0, r1);
divssr(_jit, r0, rn(reg)); divssr(_jit, r0, rn(reg));
@ -557,7 +557,7 @@ divr_d(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
if (r0 == r1) if (r0 == r1)
divsdr(_jit, r0, r2); divsdr(_jit, r0, r2);
else if (r0 == r2) { else if (r0 == r2) {
int32_t reg = get_temp_xpr(_jit); jit_fpr_t reg = get_temp_xpr(_jit);
movr_d(_jit, rn(reg), r0); movr_d(_jit, rn(reg), r0);
movr_d(_jit, r0, r1); movr_d(_jit, r0, r1);
divsdr(_jit, r0, rn(reg)); divsdr(_jit, r0, rn(reg));
@ -573,7 +573,7 @@ static void
absr_f(jit_state_t *_jit, int32_t r0, int32_t r1) absr_f(jit_state_t *_jit, int32_t r0, int32_t r1)
{ {
if (r0 == r1) { if (r0 == r1) {
int32_t reg = get_temp_xpr(_jit); jit_fpr_t reg = get_temp_xpr(_jit);
pcmpeqlr(_jit, rn(reg), rn(reg)); pcmpeqlr(_jit, rn(reg), rn(reg));
psrl(_jit, rn(reg), 1); psrl(_jit, rn(reg), 1);
andpsr(_jit, r0, rn(reg)); andpsr(_jit, r0, rn(reg));
@ -590,7 +590,7 @@ static void
absr_d(jit_state_t *_jit, int32_t r0, int32_t r1) absr_d(jit_state_t *_jit, int32_t r0, int32_t r1)
{ {
if (r0 == r1) { if (r0 == r1) {
int32_t reg = get_temp_xpr(_jit); jit_fpr_t reg = get_temp_xpr(_jit);
pcmpeqlr(_jit, rn(reg), rn(reg)); pcmpeqlr(_jit, rn(reg), rn(reg));
psrq(_jit, rn(reg), 1); psrq(_jit, rn(reg), 1);
andpdr(_jit, r0, rn(reg)); andpdr(_jit, r0, rn(reg));
@ -606,10 +606,10 @@ absr_d(jit_state_t *_jit, int32_t r0, int32_t r1)
static void static void
negr_f(jit_state_t *_jit, int32_t r0, int32_t r1) negr_f(jit_state_t *_jit, int32_t r0, int32_t r1)
{ {
int32_t ireg = get_temp_gpr(_jit); jit_gpr_t ireg = get_temp_gpr(_jit);
imovi(_jit, rn(ireg), 0x80000000); imovi(_jit, rn(ireg), 0x80000000);
if (r0 == r1) { if (r0 == r1) {
int32_t freg = get_temp_xpr(_jit); jit_fpr_t freg = get_temp_xpr(_jit);
movdlxr(_jit, rn(freg), rn(ireg)); movdlxr(_jit, rn(freg), rn(ireg));
xorpsr(_jit, r0, rn(freg)); xorpsr(_jit, r0, rn(freg));
unget_temp_xpr(_jit); unget_temp_xpr(_jit);
@ -623,10 +623,10 @@ negr_f(jit_state_t *_jit, int32_t r0, int32_t r1)
static void static void
negr_d(jit_state_t *_jit, int32_t r0, int32_t r1) negr_d(jit_state_t *_jit, int32_t r0, int32_t r1)
{ {
int32_t ireg = get_temp_gpr(_jit); jit_gpr_t ireg = get_temp_gpr(_jit);
imovi(_jit, rn(ireg), 0x80000000); imovi(_jit, rn(ireg), 0x80000000);
if (r0 == r1) { if (r0 == r1) {
int32_t freg = get_temp_xpr(_jit); jit_fpr_t freg = get_temp_xpr(_jit);
movdlxr(_jit, rn(freg), rn(ireg)); movdlxr(_jit, rn(freg), rn(ireg));
pslq(_jit, rn(freg), 32); pslq(_jit, rn(freg), 32);
xorpdr(_jit, r0, rn(freg)); xorpdr(_jit, r0, rn(freg));
@ -653,7 +653,7 @@ ldi_f(jit_state_t *_jit, int32_t r0, jit_word_t i0)
if (sse_address_p(i0)) if (sse_address_p(i0))
movssmr(_jit, i0, _NOREG, _NOREG, _SCL1, r0); movssmr(_jit, i0, _NOREG, _NOREG, _SCL1, r0);
else { else {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
movi(_jit, rn(reg), i0); movi(_jit, rn(reg), i0);
ldr_f(_jit, r0, rn(reg)); ldr_f(_jit, r0, rn(reg));
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
@ -664,7 +664,7 @@ static void
ldxr_f(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2) ldxr_f(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
{ {
#if __X64_32 #if __X64_32
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
addr(_jit, rn(reg), r1, r2); addr(_jit, rn(reg), r1, r2);
ldr_f(_jit, r0, rn(reg)); ldr_f(_jit, r0, rn(reg));
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
@ -679,7 +679,7 @@ ldxi_f(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
if (can_sign_extend_int_p(i0)) if (can_sign_extend_int_p(i0))
movssmr(_jit, i0, r1, _NOREG, _SCL1, r0); movssmr(_jit, i0, r1, _NOREG, _SCL1, r0);
else { else {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
#if __X64_32 #if __X64_32
addi(rn(reg), r1, i0); addi(rn(reg), r1, i0);
ldr_f(_jit, r0, rn(reg)); ldr_f(_jit, r0, rn(reg));
@ -697,7 +697,7 @@ sti_f(jit_state_t *_jit, jit_word_t i0, int32_t r0)
if (sse_address_p(i0)) if (sse_address_p(i0))
movssrm(_jit, r0, i0, _NOREG, _NOREG, _SCL1); movssrm(_jit, r0, i0, _NOREG, _NOREG, _SCL1);
else { else {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
movi(_jit, rn(reg), i0); movi(_jit, rn(reg), i0);
str_f(_jit, rn(reg), r0); str_f(_jit, rn(reg), r0);
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
@ -708,7 +708,7 @@ static void
stxr_f(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2) stxr_f(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
{ {
#if __X64_32 #if __X64_32
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
addr(_jit, rn(reg), r0, r1); addr(_jit, rn(reg), r0, r1);
str_f(_jit, rn(reg), r2); str_f(_jit, rn(reg), r2);
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
@ -723,7 +723,7 @@ stxi_f(jit_state_t *_jit, jit_word_t i0, int32_t r0, int32_t r1)
if (can_sign_extend_int_p(i0)) if (can_sign_extend_int_p(i0))
movssrm(_jit, r1, i0, r0, _NOREG, _SCL1); movssrm(_jit, r1, i0, r0, _NOREG, _SCL1);
else { else {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
#if __X64_32 #if __X64_32
addi(rn(reg), r0, i0); addi(rn(reg), r0, i0);
str_f(_jit, rn(reg), r1); str_f(_jit, rn(reg), r1);
@ -847,7 +847,7 @@ ldi_d(jit_state_t *_jit, int32_t r0, jit_word_t i0)
if (sse_address_p(i0)) if (sse_address_p(i0))
movsdmr(_jit, i0, _NOREG, _NOREG, _SCL1, r0); movsdmr(_jit, i0, _NOREG, _NOREG, _SCL1, r0);
else { else {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
movi(_jit, rn(reg), i0); movi(_jit, rn(reg), i0);
ldr_d(_jit, r0, rn(reg)); ldr_d(_jit, r0, rn(reg));
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
@ -858,7 +858,7 @@ static void
ldxr_d(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2) ldxr_d(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
{ {
#if __X64_32 #if __X64_32
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
addr(_jit, rn(reg), r1, r2); addr(_jit, rn(reg), r1, r2);
ldr_d(_jit, r0, rn(reg)); ldr_d(_jit, r0, rn(reg));
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
@ -873,7 +873,7 @@ ldxi_d(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
if (can_sign_extend_int_p(i0)) if (can_sign_extend_int_p(i0))
movsdmr(_jit, i0, r1, _NOREG, _SCL1, r0); movsdmr(_jit, i0, r1, _NOREG, _SCL1, r0);
else { else {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
#if __X64_32 #if __X64_32
addi(rn(reg), r1, i0); addi(rn(reg), r1, i0);
ldr_d(_jit, r0, rn(reg)); ldr_d(_jit, r0, rn(reg));
@ -891,7 +891,7 @@ sti_d(jit_state_t *_jit, jit_word_t i0, int32_t r0)
if (sse_address_p(i0)) if (sse_address_p(i0))
movsdrm(_jit, r0, i0, _NOREG, _NOREG, _SCL1); movsdrm(_jit, r0, i0, _NOREG, _NOREG, _SCL1);
else { else {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
movi(_jit, rn(reg), i0); movi(_jit, rn(reg), i0);
str_d(_jit, rn(reg), r0); str_d(_jit, rn(reg), r0);
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
@ -902,7 +902,7 @@ static void
stxr_d(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2) stxr_d(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
{ {
#if __X64_32 #if __X64_32
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
addr(_jit, rn(reg), r0, r1); addr(_jit, rn(reg), r0, r1);
str_d(_jit, rn(reg), r2); str_d(_jit, rn(reg), r2);
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
@ -917,7 +917,7 @@ stxi_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, int32_t r1)
if (can_sign_extend_int_p(i0)) if (can_sign_extend_int_p(i0))
movsdrm(_jit, r1, i0, r0, _NOREG, _SCL1); movsdrm(_jit, r1, i0, r0, _NOREG, _SCL1);
else { else {
int32_t reg = get_temp_gpr(_jit); jit_gpr_t reg = get_temp_gpr(_jit);
#if __X64_32 #if __X64_32
addi(rn(reg), r0, i0); addi(rn(reg), r0, i0);
str_d(_jit, rn(reg), r1); str_d(_jit, rn(reg), r1);

141
jit/x86.c
View file

@ -376,23 +376,23 @@ is_gpr_arg(jit_arg_abi_t arg)
return !is_fpr_arg(arg); return !is_fpr_arg(arg);
} }
static const jit_reg_t abi_gpr_args[] = { static const jit_gpr_t abi_gpr_args[] = {
#if __X32 #if __X32
/* No GPRs in args. */ /* No GPRs in args. */
#elif __CYGWIN__ #elif __CYGWIN__
_RCX, _RDX, _R8, _R9 JIT_GPR(_RCX), JIT_GPR(_RDX), JIT_GPR(_R8), JIT_GPR(_R9)
#else #else
_RDI, _RSI, _RDX, _RCX, _R8, _R9 JIT_GPR(_RDI), JIT_GPR(_RSI), JIT_GPR(_RDX), JIT_GPR(_RCX), JIT_GPR(_R8), JIT_GPR(_R9)
#endif #endif
}; };
static const jit_reg_t abi_fpr_args[] = { static const jit_fpr_t abi_fpr_args[] = {
#if __X32 #if __X32
/* No FPRs in args. */ /* No FPRs in args. */
#elif __CYGWIN__ #elif __CYGWIN__
_XMM0, _XMM1, _XMM2, _XMM3 JIT_FPR(_XMM0), JIT_FPR(_XMM1), JIT_FPR(_XMM2), JIT_FPR(_XMM3)
#else #else
_XMM0, _XMM1, _XMM2, _XMM3, _XMM4, _XMM5, _XMM6, _XMM7 JIT_FPR(_XMM0), JIT_FPR(_XMM1), JIT_FPR(_XMM2), JIT_FPR(_XMM3), JIT_FPR(_XMM4), JIT_FPR(_XMM5), JIT_FPR(_XMM6), JIT_FPR(_XMM7)
#endif #endif
}; };
@ -583,13 +583,13 @@ shuffle_gpr_arg(jit_state_t *_jit, jit_gpr_t dst, size_t argc,
{ {
ASSERT(args[idx].kind == JIT_ARG_LOC_GPR); ASSERT(args[idx].kind == JIT_ARG_LOC_GPR);
if (args[idx].loc.gpr == dst) if (rn(args[idx].loc.gpr) == rn(dst))
return; return;
/* Arg in a reg but it's not the right one. See if this reg /* Arg in a reg but it's not the right one. See if this reg
holds some other arg, and swap if so. */ holds some other arg, and swap if so. */
for (size_t j=idx+1; j<argc; j++) for (size_t j=idx+1; j<argc; j++)
if (args[j].kind == JIT_ARG_LOC_GPR && args[j].loc.gpr == dst) if (args[j].kind == JIT_ARG_LOC_GPR && rn(args[j].loc.gpr) == rn(dst))
{ {
xchgr(_jit, rn(args[idx].loc.gpr), rn(dst)); xchgr(_jit, rn(args[idx].loc.gpr), rn(dst));
args[j].loc.gpr = args[idx].loc.gpr; args[j].loc.gpr = args[idx].loc.gpr;
@ -597,7 +597,7 @@ shuffle_gpr_arg(jit_state_t *_jit, jit_gpr_t dst, size_t argc,
/* Could be this register holds a value for more than one argument; /* Could be this register holds a value for more than one argument;
update subsequent args if any. */ update subsequent args if any. */
for (size_t k=j+1; k<argc; k++) for (size_t k=j+1; k<argc; k++)
if (args[k].kind == JIT_ARG_LOC_GPR && args[k].loc.gpr == dst) if (args[k].kind == JIT_ARG_LOC_GPR && rn(args[k].loc.gpr) == rn(dst))
args[k].loc.gpr = args[j].loc.gpr; args[k].loc.gpr = args[j].loc.gpr;
return; return;
} }
@ -614,13 +614,13 @@ shuffle_fpr_arg(jit_state_t *_jit, jit_fpr_t dst, size_t argc,
{ {
ASSERT(args[idx].kind == JIT_ARG_LOC_FPR); ASSERT(args[idx].kind == JIT_ARG_LOC_FPR);
if (args[idx].loc.fpr == dst) if (rn(args[idx].loc.fpr) == rn(dst))
return; return;
/* Arg in a reg but it's not the right one. See if this reg /* Arg in a reg but it's not the right one. See if this reg
holds some other arg, and swap if so. */ holds some other arg, and swap if so. */
for (size_t j=idx+1; j<argc; j++) for (size_t j=idx+1; j<argc; j++)
if (args[j].kind == JIT_ARG_LOC_FPR && args[j].loc.fpr == dst) if (args[j].kind == JIT_ARG_LOC_FPR && rn(args[j].loc.fpr) == rn(dst))
{ {
jit_fpr_t tmp = get_temp_xpr(_jit); jit_fpr_t tmp = get_temp_xpr(_jit);
jit_movr_d (_jit, tmp, args[idx].loc.fpr); jit_movr_d (_jit, tmp, args[idx].loc.fpr);
@ -632,7 +632,7 @@ shuffle_fpr_arg(jit_state_t *_jit, jit_fpr_t dst, size_t argc,
/* Could be this register holds a value for more than one argument; /* Could be this register holds a value for more than one argument;
update subsequent args if any. */ update subsequent args if any. */
for (size_t k=j+1; k<argc; k++) for (size_t k=j+1; k<argc; k++)
if (args[k].kind == JIT_ARG_LOC_FPR && args[k].loc.fpr == dst) if (args[k].kind == JIT_ARG_LOC_FPR && rn(args[k].loc.fpr) == rn(dst))
args[k].loc.fpr = args[j].loc.fpr; args[k].loc.fpr = args[j].loc.fpr;
return; return;
} }
@ -750,7 +750,7 @@ jit_callr(jit_state_t *_jit, jit_gpr_t f,
{ {
prepare_args(_jit, argc, abi, args); prepare_args(_jit, argc, abi, args);
callr(_jit, f); callr(_jit, rn(f));
} }
void void
@ -769,123 +769,34 @@ jit_load_args(jit_state_t *_jit, size_t argc,
const jit_arg_abi_t abi[], jit_arg_t args[], const jit_arg_abi_t abi[], jit_arg_t args[],
const jit_anyreg_t regs[]) const jit_anyreg_t regs[])
{ {
/* First shuffle the arguments in registers into position. */ /* First shuffle any arguments that are already in registers into
position. */
for (size_t i = 0; i < argc; i++) { for (size_t i = 0; i < argc; i++) {
const jit_arg_t arg = args[i]; switch (args[i].kind) {
const jit_anyreg_t reg = regs[i];
switch (arg.kind) {
case JIT_ARG_LOC_IMM: case JIT_ARG_LOC_IMM:
abort(); abort();
case JIT_ARG_LOC_GPR: case JIT_ARG_LOC_GPR:
{ shuffle_gpr_arg(_jit, regs[i].gpr, argc, args, i);
if (arg.loc.gpr != reg.gpr)
/* Arg in a reg but it's not the right one. See if this reg
holds some other arg, and swap if so. */
for (size_t j=i+1; j<argc; j++)
if (args[j].kind == JIT_ARG_LOC_GPR && args[j].loc.gpr == reg.gpr)
{
xchgr(_jit, rn(arg.loc.gpr), rn(reg.gpr));
args[j].loc.gpr = arg.loc.gpr;
args[i].loc.gpr = reg.gpr;
break;
}
if (arg.loc.gpr != reg.gpr)
/* Arg in reg, but it's not the right one, and the desired reg
is free. */
{
movr(_jit, rn(reg.gpr), rn(arg.loc.gpr));
args[i].loc.gpr = reg.gpr;
}
}
break; break;
case JIT_ARG_LOC_FPR: case JIT_ARG_LOC_FPR:
{ shuffle_fpr_arg(_jit, regs[i].fpr, argc, args, i);
if (arg.loc.fpr != reg.fpr)
/* Arg in a reg but it's not the right one. See if this reg
holds some other arg, and swap if so. */
for (size_t j=i+1; j<argc; j++)
if (args[j].kind == JIT_ARG_LOC_FPR && args[j].loc.fpr == reg.fpr)
{
jit_fpr_t tmp = get_temp_xpr(_jit);
movr_d (_jit, tmp, rn(arg.loc.fpr));
movr_d (_jit, rn(arg.loc.fpr), rn(reg.fpr));
movr_d (_jit, rn(reg.fpr), tmp);
unget_temp_xpr(_jit);
args[j].loc.fpr = arg.loc.fpr;
args[i].loc.fpr = reg.fpr;
break;
}
if (arg.loc.fpr != reg.fpr)
/* Arg in reg, but it's not the right one, and the desired reg
is free. */
{
movr_d(_jit, rn(reg.fpr), rn(arg.loc.fpr));
args[i].loc.fpr = reg.fpr;
}
}
break; break;
case JIT_ARG_LOC_MEM: case JIT_ARG_LOC_MEM:
/* Load spilled arguments once we're done with registers. */
break; break;
default: default:
abort(); abort();
} }
} }
/* Load spilled arguments from memory into registers. */ /* Now load spilled arguments from memory into registers. */
for (size_t i = 0; i < argc; i++) { for (size_t i = 0; i < argc; i++) {
const jit_arg_t arg = args[i]; if (args[i].kind == JIT_ARG_LOC_MEM) {
const jit_anyreg_t reg = regs[i]; if (is_gpr_arg(abi[i]))
switch (arg.kind) { abi_mem_to_gpr(_jit, abi[i], regs[i].gpr, args[i].loc.mem.base,
case JIT_ARG_LOC_IMM: args[i].loc.mem.offset);
abort(); else
case JIT_ARG_LOC_GPR: abi_mem_to_fpr(_jit, abi[i], regs[i].fpr, args[i].loc.mem.base,
case JIT_ARG_LOC_FPR: args[i].loc.mem.offset);
break;
case JIT_ARG_LOC_MEM:
{
jit_gpr_t base = arg.loc.mem.base;
ptrdiff_t offset = arg.loc.mem.offset;
switch (abi[i]) {
case JIT_ARG_ABI_UINT8:
jit_ldxi_uc(_jit, reg.gpr, base, offset);
break;
case JIT_ARG_ABI_INT8:
jit_ldxi_c(_jit, reg.gpr, base, offset);
break;
case JIT_ARG_ABI_UINT16:
jit_ldxi_us(_jit, reg.gpr, base, offset);
break;
case JIT_ARG_ABI_INT16:
jit_ldxi_s(_jit, reg.gpr, base, offset);
break;
case JIT_ARG_ABI_UINT32:
jit_ldxi_ui(_jit, reg.gpr, base, offset);
break;
case JIT_ARG_ABI_INT32:
jit_ldxi_i(_jit, reg.gpr, base, offset);
break;
case JIT_ARG_ABI_UINT64:
jit_ldxi_l(_jit, reg.gpr, base, offset);
break;
case JIT_ARG_ABI_INT64:
jit_ldxi_l(_jit, reg.gpr, base, offset);
break;
case JIT_ARG_ABI_POINTER:
jit_ldxi_l(_jit, reg.gpr, base, offset);
break;
case JIT_ARG_ABI_FLOAT:
jit_ldxi_f(_jit, reg.fpr, base, offset);
break;
case JIT_ARG_ABI_DOUBLE:
jit_ldxi_d(_jit, reg.fpr, base, offset);
break;
default:
abort();
}
}
default:
abort();
} }
} }
} }

128
jit/x86.h
View file

@ -44,7 +44,7 @@
# define __X32 0 # define __X32 0
#endif #endif
#define JIT_FP _RBP #define JIT_FP JIT_GPR(_RBP)
typedef enum { typedef enum {
#if __X32 #if __X32
# define jit_r(i) (_RAX + (i)) # define jit_r(i) (_RAX + (i))
@ -53,22 +53,22 @@ typedef enum {
# define jit_v_num() 3 # define jit_v_num() 3
# define jit_f(i) (jit_cpu.sse2 ? _XMM0 + (i) : _ST0 + (i)) # define jit_f(i) (jit_cpu.sse2 ? _XMM0 + (i) : _ST0 + (i))
# define jit_f_num() (jit_cpu.sse2 ? 8 : 6) # define jit_f_num() (jit_cpu.sse2 ? 8 : 6)
# define JIT_R0 _RAX # define JIT_R0 JIT_GPR(_RAX)
# define JIT_R1 _RCX # define JIT_R1 JIT_GPR(_RCX)
# define JIT_R2 _RDX # define JIT_R2 JIT_GPR(_RDX)
_RAX, _RCX, _RDX, _RAX, _RCX, _RDX,
# define JIT_V0 _RBX # define JIT_V0 JIT_GPR(_RBX)
# define JIT_V1 _RSI # define JIT_V1 JIT_GPR(_RSI)
# define JIT_V2 _RDI # define JIT_V2 JIT_GPR(_RDI)
_RBX, _RSI, _RDI, _RBX, _RSI, _RDI,
_RSP, _RBP, _RSP, _RBP,
# define JIT_F0 _XMM0 # define JIT_F0 JIT_FPR(_XMM0)
# define JIT_F1 _XMM1 # define JIT_F1 JIT_FPR(_XMM1)
# define JIT_F2 _XMM2 # define JIT_F2 JIT_FPR(_XMM2)
# define JIT_F3 _XMM3 # define JIT_F3 JIT_FPR(_XMM3)
# define JIT_F4 _XMM4 # define JIT_F4 JIT_FPR(_XMM4)
# define JIT_F5 _XMM5 # define JIT_F5 JIT_FPR(_XMM5)
# define JIT_F6 _XMM6 # define JIT_F6 JIT_FPR(_XMM6)
_XMM0, _XMM1, _XMM2, _XMM3, _XMM4, _XMM5, _XMM6, _XMM7, _XMM0, _XMM1, _XMM2, _XMM3, _XMM4, _XMM5, _XMM6, _XMM7,
# define jit_sse_reg_p(reg) ((reg) >= _XMM0 && (reg) <= _XMM7) # define jit_sse_reg_p(reg) ((reg) >= _XMM0 && (reg) <= _XMM7)
#else #else
@ -79,16 +79,16 @@ typedef enum {
# define jit_v_num() 7 # define jit_v_num() 7
# define jit_f(index) (_XMM4 + (index)) # define jit_f(index) (_XMM4 + (index))
# define jit_f_num() 12 # define jit_f_num() 12
# define JIT_R0 _RAX # define JIT_R0 JIT_GPR(_RAX)
# define JIT_R1 _R10 # define JIT_R1 JIT_GPR(_R10)
# define JIT_R2 _R11 # define JIT_R2 JIT_GPR(_R11)
# define JIT_V0 _RBX # define JIT_V0 JIT_GPR(_RBX)
# define JIT_V1 _RDI # define JIT_V1 JIT_GPR(_RDI)
# define JIT_V2 _RSI # define JIT_V2 JIT_GPR(_RSI)
# define JIT_V3 _R12 # define JIT_V3 JIT_GPR(_R12)
# define JIT_V4 _R13 # define JIT_V4 JIT_GPR(_R13)
# define JIT_V5 _R14 # define JIT_V5 JIT_GPR(_R14)
# define JIT_V6 _R15 # define JIT_V6 JIT_GPR(_R15)
/* Volatile - Return value register */ /* Volatile - Return value register */
_RAX, _RAX,
/* Volatile */ /* Volatile */
@ -100,22 +100,22 @@ typedef enum {
_R9, _R8, _RDX, _RCX, _R9, _R8, _RDX, _RCX,
/* Nonvolatile */ /* Nonvolatile */
_RSP, _RBP, _RSP, _RBP,
# define JIT_F0 _XMM0 # define JIT_F0 JIT_FPR(_XMM0)
# define JIT_F1 _XMM1 # define JIT_F1 JIT_FPR(_XMM1)
# define JIT_F2 _XMM2 # define JIT_F2 JIT_FPR(_XMM2)
# define JIT_F3 _XMM3 # define JIT_F3 JIT_FPR(_XMM3)
# define JIT_F4 _XMM4 # define JIT_F4 JIT_FPR(_XMM4)
# define JIT_F5 _XMM5 # define JIT_F5 JIT_FPR(_XMM5)
# define JIT_F6 _XMM6 # define JIT_F6 JIT_FPR(_XMM6)
# define JIT_F7 _XMM7 # define JIT_F7 JIT_FPR(_XMM7)
# define JIT_F8 _XMM8 # define JIT_F8 JIT_FPR(_XMM8)
# define JIT_F9 _XMM9 # define JIT_F9 JIT_FPR(_XMM9)
# define JIT_F10 _XMM10 # define JIT_F10 JIT_FPR(_XMM10)
# define JIT_F11 _XMM11 # define JIT_F11 JIT_FPR(_XMM11)
# define JIT_F12 _XMM12 # define JIT_F12 JIT_FPR(_XMM12)
# define JIT_F13 _XMM13 # define JIT_F13 JIT_FPR(_XMM13)
# define JIT_F14 _XMM14 # define JIT_F14 JIT_FPR(_XMM14)
# define JIT_F15 _XMM15 # define JIT_F15 JIT_FPR(_XMM15)
/* Volatile */ /* Volatile */
_XMM4, _XMM5, _XMM4, _XMM5,
/* Nonvolatile */ /* Nonvolatile */
@ -131,34 +131,34 @@ typedef enum {
# define jit_v_num() 4 # define jit_v_num() 4
# define jit_f(index) (_XMM8 + (index)) # define jit_f(index) (_XMM8 + (index))
# define jit_f_num() 8 # define jit_f_num() 8
# define JIT_R0 _RAX # define JIT_R0 JIT_GPR(_RAX)
# define JIT_R1 _R10 # define JIT_R1 JIT_GPR(_R10)
# define JIT_R2 _R11 # define JIT_R2 JIT_GPR(_R11)
# define JIT_R3 _R12 # define JIT_R3 JIT_GPR(_R12)
_RAX, _R10, _R11, _R12, _RAX, _R10, _R11, _R12,
# define JIT_V0 _RBX # define JIT_V0 JIT_GPR(_RBX)
# define JIT_V1 _R13 # define JIT_V1 JIT_GPR(_R13)
# define JIT_V2 _R14 # define JIT_V2 JIT_GPR(_R14)
# define JIT_V3 _R15 # define JIT_V3 JIT_GPR(_R15)
_RBX, _R13, _R14, _R15, _RBX, _R13, _R14, _R15,
_R9, _R8, _RCX, _RDX, _RSI, _RDI, _R9, _R8, _RCX, _RDX, _RSI, _RDI,
_RSP, _RBP, _RSP, _RBP,
# define JIT_F0 _XMM0 # define JIT_F0 JIT_FPR(_XMM0)
# define JIT_F1 _XMM1 # define JIT_F1 JIT_FPR(_XMM1)
# define JIT_F2 _XMM2 # define JIT_F2 JIT_FPR(_XMM2)
# define JIT_F3 _XMM3 # define JIT_F3 JIT_FPR(_XMM3)
# define JIT_F4 _XMM4 # define JIT_F4 JIT_FPR(_XMM4)
# define JIT_F5 _XMM5 # define JIT_F5 JIT_FPR(_XMM5)
# define JIT_F6 _XMM6 # define JIT_F6 JIT_FPR(_XMM6)
# define JIT_F7 _XMM7 # define JIT_F7 JIT_FPR(_XMM7)
# define JIT_F8 _XMM8 # define JIT_F8 JIT_FPR(_XMM8)
# define JIT_F9 _XMM9 # define JIT_F9 JIT_FPR(_XMM9)
# define JIT_F10 _XMM10 # define JIT_F10 JIT_FPR(_XMM10)
# define JIT_F11 _XMM11 # define JIT_F11 JIT_FPR(_XMM11)
# define JIT_F12 _XMM12 # define JIT_F12 JIT_FPR(_XMM12)
# define JIT_F13 _XMM13 # define JIT_F13 JIT_FPR(_XMM13)
# define JIT_F14 _XMM14 # define JIT_F14 JIT_FPR(_XMM14)
# define JIT_F15 _XMM15 # define JIT_F15 JIT_FPR(_XMM15)
_XMM8, _XMM9, _XMM10, _XMM11, _XMM12, _XMM13, _XMM14, _XMM15, _XMM8, _XMM9, _XMM10, _XMM11, _XMM12, _XMM13, _XMM14, _XMM15,
_XMM7, _XMM6, _XMM5, _XMM4, _XMM3, _XMM2, _XMM1, _XMM0, _XMM7, _XMM6, _XMM5, _XMM4, _XMM3, _XMM2, _XMM1, _XMM0,
# define jit_sse_reg_p(reg) ((reg) >= _XMM8 && (reg) <= _XMM0) # define jit_sse_reg_p(reg) ((reg) >= _XMM8 && (reg) <= _XMM0)

2
tests/addr_d.c
View file

@ -7,7 +7,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_DOUBLE, JIT_ARG_ABI_DOUBLE }; const jit_arg_abi_t abi[] = { JIT_ARG_ABI_DOUBLE, JIT_ARG_ABI_DOUBLE };
jit_arg_t args[2]; jit_arg_t args[2];
const jit_anyreg_t regs[] = { { .gpr=JIT_F0 }, { .gpr=JIT_F1 }}; const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 }};
jit_receive(j, 2, abi, args); jit_receive(j, 2, abi, args);
jit_load_args(j, 2, abi, args, regs); jit_load_args(j, 2, abi, args, regs);

2
tests/addr_f.c
View file

@ -7,7 +7,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_FLOAT, JIT_ARG_ABI_FLOAT }; const jit_arg_abi_t abi[] = { JIT_ARG_ABI_FLOAT, JIT_ARG_ABI_FLOAT };
jit_arg_t args[2]; jit_arg_t args[2];
const jit_anyreg_t regs[] = { { .gpr=JIT_F0 }, { .gpr=JIT_F1 }}; const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 }};
jit_receive(j, 2, abi, args); jit_receive(j, 2, abi, args);
jit_load_args(j, 2, abi, args, regs); jit_load_args(j, 2, abi, args, regs);

2
tests/divr_d.c
View file

@ -7,7 +7,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_DOUBLE, JIT_ARG_ABI_DOUBLE }; const jit_arg_abi_t abi[] = { JIT_ARG_ABI_DOUBLE, JIT_ARG_ABI_DOUBLE };
jit_arg_t args[2]; jit_arg_t args[2];
const jit_anyreg_t regs[] = { { .gpr=JIT_F0 }, { .gpr=JIT_F1 }}; const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 }};
jit_receive(j, 2, abi, args); jit_receive(j, 2, abi, args);
jit_load_args(j, 2, abi, args, regs); jit_load_args(j, 2, abi, args, regs);

2
tests/divr_f.c
View file

@ -7,7 +7,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_FLOAT, JIT_ARG_ABI_FLOAT }; const jit_arg_abi_t abi[] = { JIT_ARG_ABI_FLOAT, JIT_ARG_ABI_FLOAT };
jit_arg_t args[2]; jit_arg_t args[2];
const jit_anyreg_t regs[] = { { .gpr=JIT_F0 }, { .gpr=JIT_F1 }}; const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 }};
jit_receive(j, 2, abi, args); jit_receive(j, 2, abi, args);
jit_load_args(j, 2, abi, args, regs); jit_load_args(j, 2, abi, args, regs);

2
tests/mulr_d.c
View file

@ -7,7 +7,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_DOUBLE, JIT_ARG_ABI_DOUBLE }; const jit_arg_abi_t abi[] = { JIT_ARG_ABI_DOUBLE, JIT_ARG_ABI_DOUBLE };
jit_arg_t args[2]; jit_arg_t args[2];
const jit_anyreg_t regs[] = { { .gpr=JIT_F0 }, { .gpr=JIT_F1 }}; const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 }};
jit_receive(j, 2, abi, args); jit_receive(j, 2, abi, args);
jit_load_args(j, 2, abi, args, regs); jit_load_args(j, 2, abi, args, regs);

2
tests/mulr_f.c
View file

@ -7,7 +7,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_FLOAT, JIT_ARG_ABI_FLOAT }; const jit_arg_abi_t abi[] = { JIT_ARG_ABI_FLOAT, JIT_ARG_ABI_FLOAT };
jit_arg_t args[2]; jit_arg_t args[2];
const jit_anyreg_t regs[] = { { .gpr=JIT_F0 }, { .gpr=JIT_F1 }}; const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 }};
jit_receive(j, 2, abi, args); jit_receive(j, 2, abi, args);
jit_load_args(j, 2, abi, args, regs); jit_load_args(j, 2, abi, args, regs);

4
tests/qdivr.c
View file

@ -3,14 +3,14 @@
static void static void
maybe_save(jit_state_t *j, jit_gpr_t reg) maybe_save(jit_state_t *j, jit_gpr_t reg)
{ {
if (jit_class(reg) & jit_class_sav) if (jit_class(reg.bits) & jit_class_sav)
jit_pushr(j, reg); jit_pushr(j, reg);
} }
static void static void
maybe_restore(jit_state_t *j, jit_gpr_t reg) maybe_restore(jit_state_t *j, jit_gpr_t reg)
{ {
if (jit_class(reg) & jit_class_sav) if (jit_class(reg.bits) & jit_class_sav)
jit_popr(j, reg); jit_popr(j, reg);
} }

4
tests/qdivr_u.c
View file

@ -3,14 +3,14 @@
static void static void
maybe_save(jit_state_t *j, jit_gpr_t reg) maybe_save(jit_state_t *j, jit_gpr_t reg)
{ {
if (jit_class(reg) & jit_class_sav) if (jit_class(reg.bits) & jit_class_sav)
jit_pushr(j, reg); jit_pushr(j, reg);
} }
static void static void
maybe_restore(jit_state_t *j, jit_gpr_t reg) maybe_restore(jit_state_t *j, jit_gpr_t reg)
{ {
if (jit_class(reg) & jit_class_sav) if (jit_class(reg.bits) & jit_class_sav)
jit_popr(j, reg); jit_popr(j, reg);
} }

4
tests/qmulr.c
View file

@ -3,14 +3,14 @@
static void static void
maybe_save(jit_state_t *j, jit_gpr_t reg) maybe_save(jit_state_t *j, jit_gpr_t reg)
{ {
if (jit_class(reg) & jit_class_sav) if (jit_class(reg.bits) & jit_class_sav)
jit_pushr(j, reg); jit_pushr(j, reg);
} }
static void static void
maybe_restore(jit_state_t *j, jit_gpr_t reg) maybe_restore(jit_state_t *j, jit_gpr_t reg)
{ {
if (jit_class(reg) & jit_class_sav) if (jit_class(reg.bits) & jit_class_sav)
jit_popr(j, reg); jit_popr(j, reg);
} }

4
tests/qmulr_u.c
View file

@ -3,14 +3,14 @@
static void static void
maybe_save(jit_state_t *j, jit_gpr_t reg) maybe_save(jit_state_t *j, jit_gpr_t reg)
{ {
if (jit_class(reg) & jit_class_sav) if (jit_class(reg.bits) & jit_class_sav)
jit_pushr(j, reg); jit_pushr(j, reg);
} }
static void static void
maybe_restore(jit_state_t *j, jit_gpr_t reg) maybe_restore(jit_state_t *j, jit_gpr_t reg)
{ {
if (jit_class(reg) & jit_class_sav) if (jit_class(reg.bits) & jit_class_sav)
jit_popr(j, reg); jit_popr(j, reg);
} }

2
tests/sti_d.c
View file

@ -14,7 +14,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
jit_receive(j, 1, abi, args); jit_receive(j, 1, abi, args);
jit_load_args(j, 1, abi, args, regs); jit_load_args(j, 1, abi, args, regs);
jit_sti_d(j, &data[1], JIT_R0); jit_sti_d(j, &data[1], JIT_F0);
jit_ret(j); jit_ret(j);
void (*f)(double) = jit_end(j, NULL); void (*f)(double) = jit_end(j, NULL);

2
tests/sti_f.c
View file

@ -14,7 +14,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
jit_receive(j, 1, abi, args); jit_receive(j, 1, abi, args);
jit_load_args(j, 1, abi, args, regs); jit_load_args(j, 1, abi, args, regs);
jit_sti_f(j, &data[1], JIT_R0); jit_sti_f(j, &data[1], JIT_F0);
jit_ret(j); jit_ret(j);
void (*f)(float) = jit_end(j, NULL); void (*f)(float) = jit_end(j, NULL);

2
tests/str_d.c
View file

@ -14,7 +14,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
jit_receive(j, 2, abi, args); jit_receive(j, 2, abi, args);
jit_load_args(j, 2, abi, args, regs); jit_load_args(j, 2, abi, args, regs);
jit_str_d(j, JIT_F0, JIT_R0); jit_str_d(j, JIT_R0, JIT_F0);
jit_ret(j); jit_ret(j);
void (*f)(void*, double) = jit_end(j, NULL); void (*f)(void*, double) = jit_end(j, NULL);

2
tests/str_f.c
View file

@ -14,7 +14,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
jit_receive(j, 2, abi, args); jit_receive(j, 2, abi, args);
jit_load_args(j, 2, abi, args, regs); jit_load_args(j, 2, abi, args, regs);
jit_str_f(j, JIT_F0, JIT_R0); jit_str_f(j, JIT_R0, JIT_F0);
jit_ret(j); jit_ret(j);
void (*f)(void*, float) = jit_end(j, NULL); void (*f)(void*, float) = jit_end(j, NULL);

2
tests/subr_d.c
View file

@ -7,7 +7,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_DOUBLE, JIT_ARG_ABI_DOUBLE }; const jit_arg_abi_t abi[] = { JIT_ARG_ABI_DOUBLE, JIT_ARG_ABI_DOUBLE };
jit_arg_t args[2]; jit_arg_t args[2];
const jit_anyreg_t regs[] = { { .gpr=JIT_F0 }, { .gpr=JIT_F1 }}; const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 }};
jit_receive(j, 2, abi, args); jit_receive(j, 2, abi, args);
jit_load_args(j, 2, abi, args, regs); jit_load_args(j, 2, abi, args, regs);

2
tests/subr_f.c
View file

@ -7,7 +7,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_FLOAT, JIT_ARG_ABI_FLOAT }; const jit_arg_abi_t abi[] = { JIT_ARG_ABI_FLOAT, JIT_ARG_ABI_FLOAT };
jit_arg_t args[2]; jit_arg_t args[2];
const jit_anyreg_t regs[] = { { .gpr=JIT_F0 }, { .gpr=JIT_F1 }}; const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 }};
jit_receive(j, 2, abi, args); jit_receive(j, 2, abi, args);
jit_load_args(j, 2, abi, args, regs); jit_load_args(j, 2, abi, args, regs);