mirror of
https://git.savannah.gnu.org/git/guile.git
synced 2025-05-19 19:20:23 +02:00
Provide some type safety for jit_gpr_t and jit_fpr_t
This commit is contained in:
Andy Wingo
parent
cacdeeee4b
commit
99b4fd2d79
22 changed files with 265 additions and 350 deletions
20
jit.h
20
jit.h
|
|
@ -37,15 +37,19 @@ typedef float jit_float32_t;
|
|||
typedef double jit_float64_t;
|
||||
typedef void* jit_pointer_t;
|
||||
typedef int jit_bool_t;
|
||||
/* FIXME: Make the compiler warn when confusing GPR/FPR/immediate. */
|
||||
typedef int jit_gpr_t;
|
||||
typedef int jit_fpr_t;
|
||||
typedef struct jit_gpr { int bits; } jit_gpr_t;
|
||||
typedef struct jit_fpr { int bits; } jit_fpr_t;
|
||||
|
||||
typedef void* jit_addr_t;
|
||||
typedef ptrdiff_t jit_off_t;
|
||||
typedef intptr_t jit_imm_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
|
||||
{
|
||||
JIT_RELOC_ABSOLUTE,
|
||||
|
|
@ -91,9 +95,9 @@ typedef struct jit_reloc
|
|||
# include "jit/alpha.h"
|
||||
#endif
|
||||
|
||||
#define JIT_R(index) jit_r(index)
|
||||
#define JIT_V(index) jit_v(index)
|
||||
#define JIT_F(index) jit_f(index)
|
||||
#define JIT_R(index) JIT_GPR(jit_r(index))
|
||||
#define JIT_V(index) JIT_GPR(jit_v(index))
|
||||
#define JIT_F(index) JIT_FPR(jit_f(index))
|
||||
#define JIT_R_NUM jit_r_num()
|
||||
#define JIT_V_NUM jit_v_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_gpr 0x20000000 /* general purpose */
|
||||
#define jit_class_fpr 0x40000000 /* float */
|
||||
#define jit_class(reg) ((reg) & 0xffff0000)
|
||||
#define jit_regno(reg) ((reg) & 0x00007fff)
|
||||
#define jit_class(bits) ((bits) & 0xffff0000)
|
||||
#define jit_regno(bits) ((bits) & 0x00007fff)
|
||||
|
||||
typedef struct jit_state jit_state_t;
|
||||
enum jit_arg_loc
|
||||
|
|
|
|||
88
jit/jit.c
88
jit/jit.c
|
|
@ -36,70 +36,70 @@
|
|||
#endif
|
||||
|
||||
#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__)
|
||||
# define JIT_SP _RSP
|
||||
# define JIT_RET _RAX
|
||||
# define JIT_SP JIT_GPR(_RSP)
|
||||
# define JIT_RET JIT_GPR(_RAX)
|
||||
# if __X32
|
||||
# define JIT_FRET _ST0
|
||||
# define JIT_FRET JIT_FPR(_ST0)
|
||||
# else
|
||||
# if __CYGWIN__
|
||||
# define JIT_RA0 _RCX
|
||||
# define JIT_RA0 JIT_GPR(_RCX)
|
||||
# else
|
||||
# define JIT_RA0 _RDI
|
||||
# define JIT_RA0 JIT_GPR(_RDI)
|
||||
# endif
|
||||
# define JIT_FA0 _XMM0
|
||||
# define JIT_FRET _XMM0
|
||||
# define JIT_FA0 JIT_FPR(_XMM0)
|
||||
# define JIT_FRET JIT_FPR(_XMM0)
|
||||
# endif
|
||||
#elif defined(__mips__)
|
||||
# define JIT_RA0 _A0
|
||||
# define JIT_FA0 _F12
|
||||
# define JIT_SP _SP
|
||||
# define JIT_RET _V0
|
||||
# define JIT_FRET _F0
|
||||
# define JIT_RA0 JIT_GPR(_A0)
|
||||
# define JIT_FA0 JIT_FPR(_F12)
|
||||
# define JIT_SP JIT_GPR(_SP)
|
||||
# define JIT_RET JIT_GPR(_V0)
|
||||
# define JIT_FRET JIT_FPR(_F0)
|
||||
#elif defined(__arm__)
|
||||
# define JIT_RA0 _R0
|
||||
# define JIT_FA0 _D0
|
||||
# define JIT_SP _R13
|
||||
# define JIT_RET _R0
|
||||
# define JIT_RA0 JIT_GPR(_R0)
|
||||
# define JIT_FA0 JIT_FPR(_D0)
|
||||
# define JIT_SP JIT_GPR(_R13)
|
||||
# define JIT_RET JIT_GPR(_R0)
|
||||
# if defined(__ARM_PCS_VFP)
|
||||
# define JIT_FRET _D0
|
||||
# define JIT_FRET JIT_FPR(_D0)
|
||||
# else
|
||||
# define JIT_FRET _R0
|
||||
# define JIT_FRET JIT_FPR(_R0)
|
||||
# endif
|
||||
#elif defined(__ppc__) || defined(__powerpc__)
|
||||
# define JIT_RA0 _R3
|
||||
# define JIT_FA0 _F1
|
||||
# define JIT_SP _R1
|
||||
# define JIT_RET _R3
|
||||
# define JIT_FRET _F1
|
||||
# define JIT_RA0 JIT_GPR(_R3)
|
||||
# define JIT_FA0 JIT_FPR(_F1)
|
||||
# define JIT_SP JIT_GPR(_R1)
|
||||
# define JIT_RET JIT_GPR(_R3)
|
||||
# define JIT_FRET JIT_FPR(_F1)
|
||||
#elif defined(__sparc__)
|
||||
# define JIT_SP _SP
|
||||
# define JIT_RET _I0
|
||||
# define JIT_FRET _F0
|
||||
# define JIT_SP JIT_GPR(_SP)
|
||||
# define JIT_RET JIT_GPR(_I0)
|
||||
# define JIT_FRET JIT_FPR(_F0)
|
||||
#elif defined(__ia64__)
|
||||
# define JIT_SP _R12
|
||||
# define JIT_RET _R8
|
||||
# define JIT_FRET _F8
|
||||
# define JIT_SP JIT_GPR(_R12)
|
||||
# define JIT_RET JIT_GPR(_R8)
|
||||
# define JIT_FRET JIT_FPR(_F8)
|
||||
#elif defined(__hppa__)
|
||||
# define JIT_SP _R30
|
||||
# define JIT_RET _R28
|
||||
# define JIT_FRET _F4
|
||||
# define JIT_SP JIT_GPR(_R30)
|
||||
# define JIT_RET JIT_GPR(_R28)
|
||||
# define JIT_FRET JIT_FPR(_F4)
|
||||
#elif defined(__aarch64__)
|
||||
# define JIT_RA0 _R0
|
||||
# define JIT_FA0 _V0
|
||||
# define JIT_SP _SP
|
||||
# define JIT_RET _R0
|
||||
# define JIT_FRET _V0
|
||||
# define JIT_RA0 JIT_GPR(_R0)
|
||||
# define JIT_FA0 JIT_FPR(_V0)
|
||||
# define JIT_SP JIT_GPR(_SP)
|
||||
# define JIT_RET JIT_GPR(_R0)
|
||||
# define JIT_FRET JIT_FPR(_V0)
|
||||
#elif defined(__s390__) || defined(__s390x__)
|
||||
# define JIT_SP _R15
|
||||
# define JIT_RET _R2
|
||||
# define JIT_FRET _F0
|
||||
# define JIT_SP JIT_GPR(_R15)
|
||||
# define JIT_RET JIT_GPR(_R2)
|
||||
# define JIT_FRET JIT_FPR(_F0)
|
||||
#elif defined(__alpha__)
|
||||
# define JIT_SP _SP
|
||||
# define JIT_RET _V0
|
||||
# define JIT_FRET _F0
|
||||
# define JIT_SP JIT_GPR(_SP)
|
||||
# define JIT_RET JIT_GPR(_V0)
|
||||
# define JIT_FRET JIT_FPR(_F0)
|
||||
#endif
|
||||
|
||||
/*
|
||||
|
|
|
|||
146
jit/x86-cpu.c
146
jit/x86-cpu.c
|
|
@ -272,9 +272,9 @@ get_temp_gpr(jit_state_t *_jit)
|
|||
_jit->temp_gpr_saved = 1;
|
||||
#if __X32
|
||||
pushr(_jit, _RBP_REGNO);
|
||||
return _RBP;
|
||||
return JIT_GPR(_RBP);
|
||||
#else
|
||||
return _R8;
|
||||
return JIT_GPR(_R8);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
|
@ -504,7 +504,7 @@ alui(jit_state_t *_jit, int32_t code, int32_t r0, jit_word_t i0)
|
|||
ii(_jit, i0);
|
||||
}
|
||||
} else {
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
movi(_jit, rn(reg), i0);
|
||||
alur(_jit, code, r0, rn(reg));
|
||||
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);
|
||||
iaddr(_jit, r0, r1);
|
||||
} else {
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
movi(_jit, rn(reg), i0);
|
||||
iaddr(_jit, r0, rn(reg));
|
||||
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);
|
||||
}
|
||||
else if (r0 == r1) {
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
movi(_jit, rn(reg), i0);
|
||||
iaddr(_jit, r0, rn(reg));
|
||||
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);
|
||||
}
|
||||
else if (r0 == r1) {
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
movi(_jit, rn(reg), i0);
|
||||
iaddxr(_jit, r0, rn(reg));
|
||||
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);
|
||||
iaddr(_jit, r0, r1);
|
||||
} else {
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
movi(_jit, rn(reg), i0);
|
||||
isubr(_jit, r0, rn(reg));
|
||||
unget_temp_gpr(_jit);
|
||||
|
|
@ -820,7 +820,7 @@ static void
|
|||
subcr(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
|
||||
{
|
||||
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, r0, r1);
|
||||
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)) {
|
||||
isubi(_jit, r0, i0);
|
||||
} else {
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
movi(_jit, rn(reg), i0);
|
||||
isubr(_jit, r0, rn(reg));
|
||||
unget_temp_gpr(_jit);
|
||||
|
|
@ -849,7 +849,7 @@ static void
|
|||
subxr(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
|
||||
{
|
||||
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, r0, r1);
|
||||
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)) {
|
||||
isubxi(_jit, r0, i0);
|
||||
} else {
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
imovi(_jit, rn(reg), i0);
|
||||
isubxr(_jit, r0, rn(reg));
|
||||
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)
|
||||
{
|
||||
if (r0 == _RCX_REGNO) {
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
movr(_jit, rn(reg), r1);
|
||||
if (r2 != _RCX_REGNO)
|
||||
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);
|
||||
}
|
||||
} else {
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
movi(_jit, rn(reg), i0);
|
||||
imulr(_jit, r0, rn(reg));
|
||||
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, r1, r1);
|
||||
} else {
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
movi(_jit, rn(reg), i0);
|
||||
if (sign)
|
||||
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;
|
||||
if (r2 == _RAX_REGNO || r2 == _RDX_REGNO) {
|
||||
int32_t tmp = get_temp_gpr(_jit);
|
||||
movr(_jit, tmp, r2);
|
||||
r2 = tmp;
|
||||
jit_gpr_t tmp = get_temp_gpr(_jit);
|
||||
movr(_jit, rn(tmp), r2);
|
||||
r2 = rn(tmp);
|
||||
tmp_divisor = 1;
|
||||
}
|
||||
|
||||
|
|
@ -1206,10 +1206,10 @@ static void
|
|||
divremi(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0,
|
||||
jit_bool_t sign, jit_bool_t divide)
|
||||
{
|
||||
int32_t r2 = get_temp_gpr(_jit);
|
||||
movi(_jit, r2, i0);
|
||||
jit_gpr_t tmp = get_temp_gpr(_jit);
|
||||
movi(_jit, rn(tmp), i0);
|
||||
|
||||
divremr(_jit, r0, r1, r2, sign, divide);
|
||||
divremr(_jit, r0, r1, rn(tmp), sign, divide);
|
||||
}
|
||||
|
||||
static void
|
||||
|
|
@ -1272,9 +1272,9 @@ iqdivr(jit_state_t *_jit, int32_t r0, int32_t r1,
|
|||
|
||||
int tmp_divisor = 0;
|
||||
if (r3 == _RAX_REGNO || r3 == _RDX_REGNO) {
|
||||
int32_t tmp = get_temp_gpr(_jit);
|
||||
movr(_jit, tmp, r3);
|
||||
r3 = tmp;
|
||||
jit_gpr_t tmp = get_temp_gpr(_jit);
|
||||
movr(_jit, rn(tmp), r3);
|
||||
r3 = rn(tmp);
|
||||
tmp_divisor = 1;
|
||||
}
|
||||
|
||||
|
|
@ -1323,7 +1323,7 @@ static void
|
|||
iqdivi(jit_state_t *_jit, int32_t r0, int32_t r1,
|
||||
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);
|
||||
if (sign)
|
||||
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)) {
|
||||
iandi(_jit, r0, i0);
|
||||
} else {
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
movi(_jit, rn(reg), i0);
|
||||
iandr(_jit, r0, rn(reg));
|
||||
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);
|
||||
iorr(_jit, r0, r1);
|
||||
} else {
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
movi(_jit, rn(reg), i0);
|
||||
iorr(_jit, r0, rn(reg));
|
||||
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);
|
||||
ixorr(_jit, r0, r1);
|
||||
} else {
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
movi(_jit, rn(reg), i0);
|
||||
ixorr(_jit, r0, rn(reg));
|
||||
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);
|
||||
cc(_jit, code, r0);
|
||||
} else {
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
ixorr(_jit, rn(reg), rn(reg));
|
||||
icmpr(_jit, r1, r2);
|
||||
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);
|
||||
cc(_jit, code, r0);
|
||||
} else {
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
ixorr(_jit, rn(reg), rn(reg));
|
||||
icmpi(_jit, r1, i0);
|
||||
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);
|
||||
cc(_jit, code, r0);
|
||||
} else {
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
ixorr(_jit, rn(reg), rn(reg));
|
||||
testr(_jit, r1, r1);
|
||||
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)) {
|
||||
movcr(_jit, r0, r1);
|
||||
} else {
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
movr(_jit, rn(reg), r1);
|
||||
movcr(_jit, r0, rn(reg));
|
||||
unget_temp_gpr(_jit);
|
||||
|
|
@ -1545,7 +1545,7 @@ extr_uc(jit_state_t *_jit, int32_t r0, int32_t r1)
|
|||
if (reg8_p(r1)) {
|
||||
movcr_u(_jit, r0, r1);
|
||||
} else {
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
movr(_jit, rn(reg), r1);
|
||||
movcr_u(_jit, r0, rn(reg));
|
||||
unget_temp_gpr(_jit);
|
||||
|
|
@ -1626,7 +1626,7 @@ ldi_c(jit_state_t *_jit, int32_t r0, jit_word_t i0)
|
|||
ic(_jit, 0xbe);
|
||||
rx(_jit, r0, i0, _NOREG, _NOREG, _SCL1);
|
||||
} else {
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
movi(_jit, rn(reg), i0);
|
||||
ldr_c(_jit, r0, rn(reg));
|
||||
unget_temp_gpr(_jit);
|
||||
|
|
@ -1651,7 +1651,7 @@ ldi_uc(jit_state_t *_jit, int32_t r0, jit_word_t i0)
|
|||
ic(_jit, 0xb6);
|
||||
rx(_jit, r0, i0, _NOREG, _NOREG, _SCL1);
|
||||
} else {
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
movi(_jit, rn(reg), i0);
|
||||
ldr_uc(_jit, r0, rn(reg));
|
||||
unget_temp_gpr(_jit);
|
||||
|
|
@ -1676,7 +1676,7 @@ ldi_s(jit_state_t *_jit, int32_t r0, jit_word_t i0)
|
|||
ic(_jit, 0xbf);
|
||||
rx(_jit, r0, i0, _NOREG, _NOREG, _SCL1);
|
||||
} else {
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
movi(_jit, rn(reg), i0);
|
||||
ldr_s(_jit, r0, rn(reg));
|
||||
unget_temp_gpr(_jit);
|
||||
|
|
@ -1701,7 +1701,7 @@ ldi_us(jit_state_t *_jit, int32_t r0, jit_word_t i0)
|
|||
ic(_jit, 0xb7);
|
||||
rx(_jit, r0, i0, _NOREG, _NOREG, _SCL1);
|
||||
} else {
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
movi(_jit, rn(reg), i0);
|
||||
ldr_us(_jit, r0, rn(reg));
|
||||
unget_temp_gpr(_jit);
|
||||
|
|
@ -1733,7 +1733,7 @@ ldi_i(jit_state_t *_jit, int32_t r0, jit_word_t i0)
|
|||
#endif
|
||||
rx(_jit, r0, i0, _NOREG, _NOREG, _SCL1);
|
||||
} else {
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
movi(_jit, rn(reg), i0);
|
||||
ldr_i(_jit, r0, rn(reg));
|
||||
unget_temp_gpr(_jit);
|
||||
|
|
@ -1758,7 +1758,7 @@ ldi_ui(jit_state_t *_jit, int32_t r0, jit_word_t i0)
|
|||
ic(_jit, 0x63);
|
||||
rx(_jit, r0, i0, _NOREG, _NOREG, _SCL1);
|
||||
} else {
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
movi(_jit, rn(reg), i0);
|
||||
ldr_ui(_jit, r0, rn(reg));
|
||||
unget_temp_gpr(_jit);
|
||||
|
|
@ -1782,7 +1782,7 @@ ldi_l(jit_state_t *_jit, int32_t r0, jit_word_t i0)
|
|||
ic(_jit, 0x8b);
|
||||
rx(_jit, r0, i0, _NOREG, _NOREG, _SCL1);
|
||||
} else {
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
movi(_jit, rn(reg), i0);
|
||||
ldr_l(_jit, r0, rn(reg));
|
||||
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);
|
||||
rx(_jit, r0, i0, r1, _NOREG, _SCL1);
|
||||
} else {
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
movi(_jit, rn(reg), i0);
|
||||
ldxr_c(_jit, r0, r1, rn(reg));
|
||||
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);
|
||||
rx(_jit, r0, i0, r1, _NOREG, _SCL1);
|
||||
} else {
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
movi(_jit, rn(reg), i0);
|
||||
ldxr_uc(_jit, r0, r1, rn(reg));
|
||||
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);
|
||||
rx(_jit, r0, i0, r1, _NOREG, _SCL1);
|
||||
} else {
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
movi(_jit, rn(reg), i0);
|
||||
ldxr_s(_jit, r0, r1, rn(reg));
|
||||
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);
|
||||
rx(_jit, r0, i0, r1, _NOREG, _SCL1);
|
||||
} else {
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
movi(_jit, rn(reg), i0);
|
||||
ldxr_us(_jit, r0, r1, rn(reg));
|
||||
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
|
||||
rx(_jit, r0, i0, r1, _NOREG, _SCL1);
|
||||
} else {
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
movi(_jit, rn(reg), i0);
|
||||
ldxr_i(_jit, r0, r1, rn(reg));
|
||||
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);
|
||||
rx(_jit, r0, i0, r1, _NOREG, _SCL1);
|
||||
} else {
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
movi(_jit, rn(reg), i0);
|
||||
ldxr_ui(_jit, r0, r1, rn(reg));
|
||||
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);
|
||||
rx(_jit, r0, i0, r1, _NOREG, _SCL1);
|
||||
} else {
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
movi(_jit, rn(reg), i0);
|
||||
ldxr_l(_jit, r0, r1, rn(reg));
|
||||
unget_temp_gpr(_jit);
|
||||
|
|
@ -2008,7 +2008,7 @@ str_c(jit_state_t *_jit, int32_t r0, int32_t r1)
|
|||
ic(_jit, 0x88);
|
||||
rx(_jit, r1, 0, r0, _NOREG, _SCL1);
|
||||
} else {
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
movr(_jit, rn(reg), r1);
|
||||
rex(_jit, 0, 0, rn(reg), _NOREG, r0);
|
||||
ic(_jit, 0x88);
|
||||
|
|
@ -2026,7 +2026,7 @@ sti_c(jit_state_t *_jit, jit_word_t i0, int32_t r0)
|
|||
ic(_jit, 0x88);
|
||||
rx(_jit, r0, i0, _NOREG, _NOREG, _SCL1);
|
||||
} else {
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
movr(_jit, rn(reg), r0);
|
||||
rex(_jit, 0, 0, rn(reg), _NOREG, _NOREG);
|
||||
ic(_jit, 0x88);
|
||||
|
|
@ -2034,7 +2034,7 @@ sti_c(jit_state_t *_jit, jit_word_t i0, int32_t r0)
|
|||
unget_temp_gpr(_jit);
|
||||
}
|
||||
} else {
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
movi(_jit, rn(reg), i0);
|
||||
str_c(_jit, rn(reg), r0);
|
||||
unget_temp_gpr(_jit);
|
||||
|
|
@ -2059,7 +2059,7 @@ sti_s(jit_state_t *_jit, jit_word_t i0, int32_t r0)
|
|||
ic(_jit, 0x89);
|
||||
rx(_jit, r0, i0, _NOREG, _NOREG, _SCL1);
|
||||
} else {
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
movi(_jit, rn(reg), i0);
|
||||
str_s(_jit, rn(reg), r0);
|
||||
unget_temp_gpr(_jit);
|
||||
|
|
@ -2082,7 +2082,7 @@ sti_i(jit_state_t *_jit, jit_word_t i0, int32_t r0)
|
|||
ic(_jit, 0x89);
|
||||
rx(_jit, r0, i0, _NOREG, _NOREG, _SCL1);
|
||||
} else {
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
movi(_jit, rn(reg), i0);
|
||||
str_i(_jit, rn(reg), r0);
|
||||
unget_temp_gpr(_jit);
|
||||
|
|
@ -2106,7 +2106,7 @@ sti_l(jit_state_t *_jit, jit_word_t i0, int32_t r0)
|
|||
ic(_jit, 0x89);
|
||||
rx(_jit, r0, i0, _NOREG, _NOREG, _SCL1);
|
||||
} else {
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
movi(_jit, rn(reg), i0);
|
||||
str_l(_jit, rn(reg), r0);
|
||||
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)
|
||||
{
|
||||
#if __X64_32
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
addr(_jit, rn(reg), r0, r1);
|
||||
str_c(_jit, rn(reg), r2);
|
||||
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);
|
||||
rx(_jit, r2, 0, r0, r1, _SCL1);
|
||||
} else {
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
movr(_jit, rn(reg), r2);
|
||||
rex(_jit, 0, 0, rn(reg), r1, r0);
|
||||
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);
|
||||
rx(_jit, r1, i0, r0, _NOREG, _SCL1);
|
||||
} else {
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
movr(_jit, rn(reg), r1);
|
||||
rex(_jit, 0, 0, rn(reg), _NOREG, r0);
|
||||
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);
|
||||
}
|
||||
} else {
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
movi(_jit, rn(reg), i0);
|
||||
stxr_c(_jit, rn(reg), r0, r1);
|
||||
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)
|
||||
{
|
||||
#if __X64_32
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
addr(_jit, rn(reg), r0, r1);
|
||||
str_s(_jit, rn(reg), r2);
|
||||
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);
|
||||
rx(_jit, r1, i0, r0, _NOREG, _SCL1);
|
||||
} else {
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
movi(_jit, rn(reg), i0);
|
||||
stxr_s(_jit, rn(reg), r0, r1);
|
||||
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)
|
||||
{
|
||||
#if __X64_32
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
addr(_jit, rn(reg), r0, r1);
|
||||
str_i(rn(reg), r2);
|
||||
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);
|
||||
rx(_jit, r1, i0, r0, _NOREG, _SCL1);
|
||||
} else {
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
movi(_jit, rn(reg), i0);
|
||||
stxr_i(_jit, rn(reg), r0, r1);
|
||||
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);
|
||||
rx(_jit, r1, i0, r0, _NOREG, _SCL1);
|
||||
} else {
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
movi(_jit, rn(reg), i0);
|
||||
stxr_l(_jit, rn(reg), r0, r1);
|
||||
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)) {
|
||||
testi(_jit, r0, i1);
|
||||
} else {
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
movi(_jit, rn(reg), i1);
|
||||
testr(_jit, r0, rn(reg));
|
||||
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)) {
|
||||
testi(_jit, r0, i1);
|
||||
} else {
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
movi(_jit, rn(reg), i1);
|
||||
testr(_jit, r0, rn(reg));
|
||||
unget_temp_gpr(_jit);
|
||||
|
|
@ -2481,7 +2481,7 @@ boaddi(jit_state_t *_jit, int32_t r0, jit_word_t i1)
|
|||
iaddi(_jit, r0, i1);
|
||||
return jo(_jit);
|
||||
}
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
movi(_jit, rn(reg), i1);
|
||||
unget_temp_gpr(_jit);
|
||||
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);
|
||||
return jc(_jit);
|
||||
}
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
movi(_jit, rn(reg), i1);
|
||||
unget_temp_gpr(_jit);
|
||||
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);
|
||||
return jno(_jit);
|
||||
}
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
movi(_jit, rn(reg), i1);
|
||||
unget_temp_gpr(_jit);
|
||||
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);
|
||||
return jnc(_jit);
|
||||
}
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
movi(_jit, rn(reg), i1);
|
||||
unget_temp_gpr(_jit);
|
||||
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);
|
||||
return jo(_jit);
|
||||
}
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
movi(_jit, rn(reg), i1);
|
||||
unget_temp_gpr(_jit);
|
||||
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);
|
||||
return jc(_jit);
|
||||
}
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
movi(_jit, rn(reg), i1);
|
||||
unget_temp_gpr(_jit);
|
||||
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);
|
||||
return jno(_jit);
|
||||
}
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
movi(_jit, rn(reg), i1);
|
||||
unget_temp_gpr(_jit);
|
||||
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);
|
||||
return jnc(_jit);
|
||||
}
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
movi(_jit, rn(reg), i1);
|
||||
unget_temp_gpr(_jit);
|
||||
return bxsubr_u(_jit, r0, rn(reg));
|
||||
|
|
@ -2646,7 +2646,7 @@ calli(jit_state_t *_jit, jit_word_t i0)
|
|||
}
|
||||
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);
|
||||
callr(_jit, rn(reg));
|
||||
unget_temp_gpr(_jit);
|
||||
|
|
@ -2672,7 +2672,7 @@ jmpi(jit_state_t *_jit, jit_word_t i0)
|
|||
}
|
||||
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);
|
||||
jmpr(_jit, rn(reg));
|
||||
unget_temp_gpr(_jit);
|
||||
|
|
|
|||
|
|
@ -181,7 +181,7 @@ pushr_d(jit_state_t *_jit, int32_t r0)
|
|||
static void
|
||||
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));
|
||||
ssexr(_jit, 0x66, X86_SSE_G2X, r0, rn(tmp));
|
||||
unget_temp_gpr(_jit);
|
||||
|
|
@ -193,7 +193,7 @@ get_temp_xpr(jit_state_t *_jit)
|
|||
/* Reserve XMM7 for the JIT. */
|
||||
ASSERT(!_jit->temp_fpr_saved);
|
||||
_jit->temp_fpr_saved = 1;
|
||||
return _XMM7;
|
||||
return JIT_FPR(_XMM7);
|
||||
}
|
||||
|
||||
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))
|
||||
xorpsr(_jit, r0, r0);
|
||||
else {
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
movi(_jit, rn(reg), data.i);
|
||||
movdlxr(_jit, r0, rn(reg));
|
||||
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))
|
||||
xorpdr(_jit, r0, r0);
|
||||
else {
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
#if __X64 && !__X64_32
|
||||
movi(_jit, rn(reg), data.w);
|
||||
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)
|
||||
subssr(_jit, 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, r0, r1);
|
||||
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)
|
||||
subsdr(_jit, 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, r0, r1);
|
||||
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)
|
||||
divssr(_jit, 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, r0, r1);
|
||||
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)
|
||||
divsdr(_jit, 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, r0, r1);
|
||||
divsdr(_jit, r0, rn(reg));
|
||||
|
|
@ -573,7 +573,7 @@ static void
|
|||
absr_f(jit_state_t *_jit, int32_t r0, int32_t 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));
|
||||
psrl(_jit, rn(reg), 1);
|
||||
andpsr(_jit, r0, rn(reg));
|
||||
|
|
@ -590,7 +590,7 @@ static void
|
|||
absr_d(jit_state_t *_jit, int32_t r0, int32_t 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));
|
||||
psrq(_jit, rn(reg), 1);
|
||||
andpdr(_jit, r0, rn(reg));
|
||||
|
|
@ -606,10 +606,10 @@ absr_d(jit_state_t *_jit, int32_t r0, int32_t r1)
|
|||
static void
|
||||
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);
|
||||
if (r0 == r1) {
|
||||
int32_t freg = get_temp_xpr(_jit);
|
||||
jit_fpr_t freg = get_temp_xpr(_jit);
|
||||
movdlxr(_jit, rn(freg), rn(ireg));
|
||||
xorpsr(_jit, r0, rn(freg));
|
||||
unget_temp_xpr(_jit);
|
||||
|
|
@ -623,10 +623,10 @@ negr_f(jit_state_t *_jit, int32_t r0, int32_t r1)
|
|||
static void
|
||||
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);
|
||||
if (r0 == r1) {
|
||||
int32_t freg = get_temp_xpr(_jit);
|
||||
jit_fpr_t freg = get_temp_xpr(_jit);
|
||||
movdlxr(_jit, rn(freg), rn(ireg));
|
||||
pslq(_jit, rn(freg), 32);
|
||||
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))
|
||||
movssmr(_jit, i0, _NOREG, _NOREG, _SCL1, r0);
|
||||
else {
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
movi(_jit, rn(reg), i0);
|
||||
ldr_f(_jit, r0, rn(reg));
|
||||
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)
|
||||
{
|
||||
#if __X64_32
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
addr(_jit, rn(reg), r1, r2);
|
||||
ldr_f(_jit, r0, rn(reg));
|
||||
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))
|
||||
movssmr(_jit, i0, r1, _NOREG, _SCL1, r0);
|
||||
else {
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
#if __X64_32
|
||||
addi(rn(reg), r1, i0);
|
||||
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))
|
||||
movssrm(_jit, r0, i0, _NOREG, _NOREG, _SCL1);
|
||||
else {
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
movi(_jit, rn(reg), i0);
|
||||
str_f(_jit, rn(reg), r0);
|
||||
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)
|
||||
{
|
||||
#if __X64_32
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
addr(_jit, rn(reg), r0, r1);
|
||||
str_f(_jit, rn(reg), r2);
|
||||
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))
|
||||
movssrm(_jit, r1, i0, r0, _NOREG, _SCL1);
|
||||
else {
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
#if __X64_32
|
||||
addi(rn(reg), r0, i0);
|
||||
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))
|
||||
movsdmr(_jit, i0, _NOREG, _NOREG, _SCL1, r0);
|
||||
else {
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
movi(_jit, rn(reg), i0);
|
||||
ldr_d(_jit, r0, rn(reg));
|
||||
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)
|
||||
{
|
||||
#if __X64_32
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
addr(_jit, rn(reg), r1, r2);
|
||||
ldr_d(_jit, r0, rn(reg));
|
||||
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))
|
||||
movsdmr(_jit, i0, r1, _NOREG, _SCL1, r0);
|
||||
else {
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
#if __X64_32
|
||||
addi(rn(reg), r1, i0);
|
||||
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))
|
||||
movsdrm(_jit, r0, i0, _NOREG, _NOREG, _SCL1);
|
||||
else {
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
movi(_jit, rn(reg), i0);
|
||||
str_d(_jit, rn(reg), r0);
|
||||
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)
|
||||
{
|
||||
#if __X64_32
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
addr(_jit, rn(reg), r0, r1);
|
||||
str_d(_jit, rn(reg), r2);
|
||||
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))
|
||||
movsdrm(_jit, r1, i0, r0, _NOREG, _SCL1);
|
||||
else {
|
||||
int32_t reg = get_temp_gpr(_jit);
|
||||
jit_gpr_t reg = get_temp_gpr(_jit);
|
||||
#if __X64_32
|
||||
addi(rn(reg), r0, i0);
|
||||
str_d(_jit, rn(reg), r1);
|
||||
|
|
|
|||
141
jit/x86.c
141
jit/x86.c
|
|
@ -376,23 +376,23 @@ is_gpr_arg(jit_arg_abi_t arg)
|
|||
return !is_fpr_arg(arg);
|
||||
}
|
||||
|
||||
static const jit_reg_t abi_gpr_args[] = {
|
||||
static const jit_gpr_t abi_gpr_args[] = {
|
||||
#if __X32
|
||||
/* No GPRs in args. */
|
||||
#elif __CYGWIN__
|
||||
_RCX, _RDX, _R8, _R9
|
||||
JIT_GPR(_RCX), JIT_GPR(_RDX), JIT_GPR(_R8), JIT_GPR(_R9)
|
||||
#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
|
||||
};
|
||||
|
||||
static const jit_reg_t abi_fpr_args[] = {
|
||||
static const jit_fpr_t abi_fpr_args[] = {
|
||||
#if __X32
|
||||
/* No FPRs in args. */
|
||||
#elif __CYGWIN__
|
||||
_XMM0, _XMM1, _XMM2, _XMM3
|
||||
JIT_FPR(_XMM0), JIT_FPR(_XMM1), JIT_FPR(_XMM2), JIT_FPR(_XMM3)
|
||||
#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
|
||||
};
|
||||
|
||||
|
|
@ -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);
|
||||
|
||||
if (args[idx].loc.gpr == dst)
|
||||
if (rn(args[idx].loc.gpr) == rn(dst))
|
||||
return;
|
||||
|
||||
/* 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=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));
|
||||
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;
|
||||
update subsequent args if any. */
|
||||
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;
|
||||
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);
|
||||
|
||||
if (args[idx].loc.fpr == dst)
|
||||
if (rn(args[idx].loc.fpr) == rn(dst))
|
||||
return;
|
||||
|
||||
/* 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=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_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;
|
||||
update subsequent args if any. */
|
||||
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;
|
||||
return;
|
||||
}
|
||||
|
|
@ -750,7 +750,7 @@ jit_callr(jit_state_t *_jit, jit_gpr_t f,
|
|||
{
|
||||
prepare_args(_jit, argc, abi, args);
|
||||
|
||||
callr(_jit, f);
|
||||
callr(_jit, rn(f));
|
||||
}
|
||||
|
||||
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_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++) {
|
||||
const jit_arg_t arg = args[i];
|
||||
const jit_anyreg_t reg = regs[i];
|
||||
switch (arg.kind) {
|
||||
switch (args[i].kind) {
|
||||
case JIT_ARG_LOC_IMM:
|
||||
abort();
|
||||
case JIT_ARG_LOC_GPR:
|
||||
{
|
||||
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;
|
||||
}
|
||||
}
|
||||
shuffle_gpr_arg(_jit, regs[i].gpr, argc, args, i);
|
||||
break;
|
||||
case JIT_ARG_LOC_FPR:
|
||||
{
|
||||
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;
|
||||
}
|
||||
}
|
||||
shuffle_fpr_arg(_jit, regs[i].fpr, argc, args, i);
|
||||
break;
|
||||
case JIT_ARG_LOC_MEM:
|
||||
/* Load spilled arguments once we're done with registers. */
|
||||
break;
|
||||
default:
|
||||
abort();
|
||||
}
|
||||
}
|
||||
|
||||
/* Load spilled arguments from memory into registers. */
|
||||
/* Now load spilled arguments from memory into registers. */
|
||||
for (size_t i = 0; i < argc; i++) {
|
||||
const jit_arg_t arg = args[i];
|
||||
const jit_anyreg_t reg = regs[i];
|
||||
switch (arg.kind) {
|
||||
case JIT_ARG_LOC_IMM:
|
||||
abort();
|
||||
case JIT_ARG_LOC_GPR:
|
||||
case JIT_ARG_LOC_FPR:
|
||||
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();
|
||||
if (args[i].kind == JIT_ARG_LOC_MEM) {
|
||||
if (is_gpr_arg(abi[i]))
|
||||
abi_mem_to_gpr(_jit, abi[i], regs[i].gpr, args[i].loc.mem.base,
|
||||
args[i].loc.mem.offset);
|
||||
else
|
||||
abi_mem_to_fpr(_jit, abi[i], regs[i].fpr, args[i].loc.mem.base,
|
||||
args[i].loc.mem.offset);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
128
jit/x86.h
128
jit/x86.h
|
|
@ -44,7 +44,7 @@
|
|||
# define __X32 0
|
||||
#endif
|
||||
|
||||
#define JIT_FP _RBP
|
||||
#define JIT_FP JIT_GPR(_RBP)
|
||||
typedef enum {
|
||||
#if __X32
|
||||
# define jit_r(i) (_RAX + (i))
|
||||
|
|
@ -53,22 +53,22 @@ typedef enum {
|
|||
# define jit_v_num() 3
|
||||
# define jit_f(i) (jit_cpu.sse2 ? _XMM0 + (i) : _ST0 + (i))
|
||||
# define jit_f_num() (jit_cpu.sse2 ? 8 : 6)
|
||||
# define JIT_R0 _RAX
|
||||
# define JIT_R1 _RCX
|
||||
# define JIT_R2 _RDX
|
||||
# define JIT_R0 JIT_GPR(_RAX)
|
||||
# define JIT_R1 JIT_GPR(_RCX)
|
||||
# define JIT_R2 JIT_GPR(_RDX)
|
||||
_RAX, _RCX, _RDX,
|
||||
# define JIT_V0 _RBX
|
||||
# define JIT_V1 _RSI
|
||||
# define JIT_V2 _RDI
|
||||
# define JIT_V0 JIT_GPR(_RBX)
|
||||
# define JIT_V1 JIT_GPR(_RSI)
|
||||
# define JIT_V2 JIT_GPR(_RDI)
|
||||
_RBX, _RSI, _RDI,
|
||||
_RSP, _RBP,
|
||||
# define JIT_F0 _XMM0
|
||||
# define JIT_F1 _XMM1
|
||||
# define JIT_F2 _XMM2
|
||||
# define JIT_F3 _XMM3
|
||||
# define JIT_F4 _XMM4
|
||||
# define JIT_F5 _XMM5
|
||||
# define JIT_F6 _XMM6
|
||||
# define JIT_F0 JIT_FPR(_XMM0)
|
||||
# define JIT_F1 JIT_FPR(_XMM1)
|
||||
# define JIT_F2 JIT_FPR(_XMM2)
|
||||
# define JIT_F3 JIT_FPR(_XMM3)
|
||||
# define JIT_F4 JIT_FPR(_XMM4)
|
||||
# define JIT_F5 JIT_FPR(_XMM5)
|
||||
# define JIT_F6 JIT_FPR(_XMM6)
|
||||
_XMM0, _XMM1, _XMM2, _XMM3, _XMM4, _XMM5, _XMM6, _XMM7,
|
||||
# define jit_sse_reg_p(reg) ((reg) >= _XMM0 && (reg) <= _XMM7)
|
||||
#else
|
||||
|
|
@ -79,16 +79,16 @@ typedef enum {
|
|||
# define jit_v_num() 7
|
||||
# define jit_f(index) (_XMM4 + (index))
|
||||
# define jit_f_num() 12
|
||||
# define JIT_R0 _RAX
|
||||
# define JIT_R1 _R10
|
||||
# define JIT_R2 _R11
|
||||
# define JIT_V0 _RBX
|
||||
# define JIT_V1 _RDI
|
||||
# define JIT_V2 _RSI
|
||||
# define JIT_V3 _R12
|
||||
# define JIT_V4 _R13
|
||||
# define JIT_V5 _R14
|
||||
# define JIT_V6 _R15
|
||||
# define JIT_R0 JIT_GPR(_RAX)
|
||||
# define JIT_R1 JIT_GPR(_R10)
|
||||
# define JIT_R2 JIT_GPR(_R11)
|
||||
# define JIT_V0 JIT_GPR(_RBX)
|
||||
# define JIT_V1 JIT_GPR(_RDI)
|
||||
# define JIT_V2 JIT_GPR(_RSI)
|
||||
# define JIT_V3 JIT_GPR(_R12)
|
||||
# define JIT_V4 JIT_GPR(_R13)
|
||||
# define JIT_V5 JIT_GPR(_R14)
|
||||
# define JIT_V6 JIT_GPR(_R15)
|
||||
/* Volatile - Return value register */
|
||||
_RAX,
|
||||
/* Volatile */
|
||||
|
|
@ -100,22 +100,22 @@ typedef enum {
|
|||
_R9, _R8, _RDX, _RCX,
|
||||
/* Nonvolatile */
|
||||
_RSP, _RBP,
|
||||
# define JIT_F0 _XMM0
|
||||
# define JIT_F1 _XMM1
|
||||
# define JIT_F2 _XMM2
|
||||
# define JIT_F3 _XMM3
|
||||
# define JIT_F4 _XMM4
|
||||
# define JIT_F5 _XMM5
|
||||
# define JIT_F6 _XMM6
|
||||
# define JIT_F7 _XMM7
|
||||
# define JIT_F8 _XMM8
|
||||
# define JIT_F9 _XMM9
|
||||
# define JIT_F10 _XMM10
|
||||
# define JIT_F11 _XMM11
|
||||
# define JIT_F12 _XMM12
|
||||
# define JIT_F13 _XMM13
|
||||
# define JIT_F14 _XMM14
|
||||
# define JIT_F15 _XMM15
|
||||
# define JIT_F0 JIT_FPR(_XMM0)
|
||||
# define JIT_F1 JIT_FPR(_XMM1)
|
||||
# define JIT_F2 JIT_FPR(_XMM2)
|
||||
# define JIT_F3 JIT_FPR(_XMM3)
|
||||
# define JIT_F4 JIT_FPR(_XMM4)
|
||||
# define JIT_F5 JIT_FPR(_XMM5)
|
||||
# define JIT_F6 JIT_FPR(_XMM6)
|
||||
# define JIT_F7 JIT_FPR(_XMM7)
|
||||
# define JIT_F8 JIT_FPR(_XMM8)
|
||||
# define JIT_F9 JIT_FPR(_XMM9)
|
||||
# define JIT_F10 JIT_FPR(_XMM10)
|
||||
# define JIT_F11 JIT_FPR(_XMM11)
|
||||
# define JIT_F12 JIT_FPR(_XMM12)
|
||||
# define JIT_F13 JIT_FPR(_XMM13)
|
||||
# define JIT_F14 JIT_FPR(_XMM14)
|
||||
# define JIT_F15 JIT_FPR(_XMM15)
|
||||
/* Volatile */
|
||||
_XMM4, _XMM5,
|
||||
/* Nonvolatile */
|
||||
|
|
@ -131,34 +131,34 @@ typedef enum {
|
|||
# define jit_v_num() 4
|
||||
# define jit_f(index) (_XMM8 + (index))
|
||||
# define jit_f_num() 8
|
||||
# define JIT_R0 _RAX
|
||||
# define JIT_R1 _R10
|
||||
# define JIT_R2 _R11
|
||||
# define JIT_R3 _R12
|
||||
# define JIT_R0 JIT_GPR(_RAX)
|
||||
# define JIT_R1 JIT_GPR(_R10)
|
||||
# define JIT_R2 JIT_GPR(_R11)
|
||||
# define JIT_R3 JIT_GPR(_R12)
|
||||
_RAX, _R10, _R11, _R12,
|
||||
# define JIT_V0 _RBX
|
||||
# define JIT_V1 _R13
|
||||
# define JIT_V2 _R14
|
||||
# define JIT_V3 _R15
|
||||
# define JIT_V0 JIT_GPR(_RBX)
|
||||
# define JIT_V1 JIT_GPR(_R13)
|
||||
# define JIT_V2 JIT_GPR(_R14)
|
||||
# define JIT_V3 JIT_GPR(_R15)
|
||||
_RBX, _R13, _R14, _R15,
|
||||
_R9, _R8, _RCX, _RDX, _RSI, _RDI,
|
||||
_RSP, _RBP,
|
||||
# define JIT_F0 _XMM0
|
||||
# define JIT_F1 _XMM1
|
||||
# define JIT_F2 _XMM2
|
||||
# define JIT_F3 _XMM3
|
||||
# define JIT_F4 _XMM4
|
||||
# define JIT_F5 _XMM5
|
||||
# define JIT_F6 _XMM6
|
||||
# define JIT_F7 _XMM7
|
||||
# define JIT_F8 _XMM8
|
||||
# define JIT_F9 _XMM9
|
||||
# define JIT_F10 _XMM10
|
||||
# define JIT_F11 _XMM11
|
||||
# define JIT_F12 _XMM12
|
||||
# define JIT_F13 _XMM13
|
||||
# define JIT_F14 _XMM14
|
||||
# define JIT_F15 _XMM15
|
||||
# define JIT_F0 JIT_FPR(_XMM0)
|
||||
# define JIT_F1 JIT_FPR(_XMM1)
|
||||
# define JIT_F2 JIT_FPR(_XMM2)
|
||||
# define JIT_F3 JIT_FPR(_XMM3)
|
||||
# define JIT_F4 JIT_FPR(_XMM4)
|
||||
# define JIT_F5 JIT_FPR(_XMM5)
|
||||
# define JIT_F6 JIT_FPR(_XMM6)
|
||||
# define JIT_F7 JIT_FPR(_XMM7)
|
||||
# define JIT_F8 JIT_FPR(_XMM8)
|
||||
# define JIT_F9 JIT_FPR(_XMM9)
|
||||
# define JIT_F10 JIT_FPR(_XMM10)
|
||||
# define JIT_F11 JIT_FPR(_XMM11)
|
||||
# define JIT_F12 JIT_FPR(_XMM12)
|
||||
# define JIT_F13 JIT_FPR(_XMM13)
|
||||
# define JIT_F14 JIT_FPR(_XMM14)
|
||||
# define JIT_F15 JIT_FPR(_XMM15)
|
||||
_XMM8, _XMM9, _XMM10, _XMM11, _XMM12, _XMM13, _XMM14, _XMM15,
|
||||
_XMM7, _XMM6, _XMM5, _XMM4, _XMM3, _XMM2, _XMM1, _XMM0,
|
||||
# define jit_sse_reg_p(reg) ((reg) >= _XMM8 && (reg) <= _XMM0)
|
||||
|
|
|
|||
|
|
@ -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 };
|
||||
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_load_args(j, 2, abi, args, regs);
|
||||
|
|
|
|||
|
|
@ -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 };
|
||||
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_load_args(j, 2, abi, args, regs);
|
||||
|
|
|
|||
|
|
@ -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 };
|
||||
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_load_args(j, 2, abi, args, regs);
|
||||
|
|
|
|||
|
|
@ -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 };
|
||||
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_load_args(j, 2, abi, args, regs);
|
||||
|
|
|
|||
|
|
@ -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 };
|
||||
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_load_args(j, 2, abi, args, regs);
|
||||
|
|
|
|||
|
|
@ -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 };
|
||||
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_load_args(j, 2, abi, args, regs);
|
||||
|
|
|
|||
|
|
@ -3,14 +3,14 @@
|
|||
static void
|
||||
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);
|
||||
}
|
||||
|
||||
static void
|
||||
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);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -3,14 +3,14 @@
|
|||
static void
|
||||
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);
|
||||
}
|
||||
|
||||
static void
|
||||
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);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -3,14 +3,14 @@
|
|||
static void
|
||||
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);
|
||||
}
|
||||
|
||||
static void
|
||||
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);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -3,14 +3,14 @@
|
|||
static void
|
||||
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);
|
||||
}
|
||||
|
||||
static void
|
||||
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);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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_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);
|
||||
|
||||
void (*f)(double) = jit_end(j, NULL);
|
||||
|
|
|
|||
|
|
@ -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_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);
|
||||
|
||||
void (*f)(float) = jit_end(j, NULL);
|
||||
|
|
|
|||
|
|
@ -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_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);
|
||||
|
||||
void (*f)(void*, double) = jit_end(j, NULL);
|
||||
|
|
|
|||
|
|
@ -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_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);
|
||||
|
||||
void (*f)(void*, float) = jit_end(j, NULL);
|
||||
|
|
|
|||
|
|
@ -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 };
|
||||
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_load_args(j, 2, abi, args, regs);
|
||||
|
|
|
|||
|
|
@ -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 };
|
||||
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_load_args(j, 2, abi, args, regs);
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue