2 #define fallback_save(r0) _fallback_save(_jit, r0)
3 static void _fallback_save(jit_state_t*, jit_int32_t);
4 #define fallback_load(r0) _fallback_load(_jit, r0)
5 static void _fallback_load(jit_state_t*, jit_int32_t);
6 #define fallback_save_regs(r0) _fallback_save_regs(_jit, r0)
7 static void _fallback_save_regs(jit_state_t*, jit_int32_t);
8 #define fallback_load_regs(r0) _fallback_load_regs(_jit, r0)
9 static void _fallback_load_regs(jit_state_t*, jit_int32_t);
10 #define fallback_calli(i0, i1) _fallback_calli(_jit, i0, i1)
11 static void _fallback_calli(jit_state_t*, jit_word_t, jit_word_t);
12 #define fallback_casx(r0,r1,r2,r3,im) _fallback_casx(_jit,r0,r1,r2,r3,im)
13 static void _fallback_casx(jit_state_t *, jit_int32_t, jit_int32_t,
14 jit_int32_t, jit_int32_t, jit_word_t);
19 _fallback_save(jit_state_t *_jit, jit_int32_t r0)
21 jit_int32_t offset, regno, spec;
22 for (offset = 0; offset < JIT_R_NUM; offset++) {
23 spec = _rvs[offset].spec;
24 regno = jit_regno(spec);
26 if (!(spec & jit_class_sav))
27 stxi(_jitc->function->regoff[offset], rn(JIT_FP), regno);
34 _fallback_load(jit_state_t *_jit, jit_int32_t r0)
36 jit_int32_t offset, regno, spec;
37 for (offset = 0; offset < JIT_R_NUM; offset++) {
38 spec = _rvs[offset].spec;
39 regno = jit_regno(spec);
41 if (!(spec & jit_class_sav))
42 ldxi(regno, rn(JIT_FP), _jitc->function->regoff[offset]);
49 _fallback_save_regs(jit_state_t *_jit, jit_int32_t r0)
51 jit_int32_t offset, regno, spec;
52 for (offset = 0; offset < JIT_R_NUM; offset++) {
53 regno = JIT_R(offset);
54 spec = _rvs[regno].spec;
55 if ((spec & jit_class_gpr) && regno == r0)
57 if (!(spec & jit_class_sav)) {
58 if (!_jitc->function->regoff[regno]) {
59 _jitc->function->regoff[regno] =
60 jit_allocai(sizeof(jit_word_t));
63 jit_regset_setbit(&_jitc->regsav, regno);
64 emit_stxi(_jitc->function->regoff[regno], JIT_FP, regno);
67 /* If knew for certain float registers are not used by
68 * pthread_mutex_lock and pthread_mutex_unlock, could skip this */
69 for (offset = 0; offset < JIT_F_NUM; offset++) {
70 regno = JIT_F(offset);
71 spec = _rvs[regno].spec;
72 if (!(spec & jit_class_sav)) {
73 if (!_jitc->function->regoff[regno]) {
74 _jitc->function->regoff[regno] =
75 jit_allocai(sizeof(jit_word_t));
78 jit_regset_setbit(&_jitc->regsav, regno);
79 emit_stxi_d(_jitc->function->regoff[regno], JIT_FP, regno);
85 _fallback_load_regs(jit_state_t *_jit, jit_int32_t r0)
87 jit_int32_t offset, regno, spec;
88 for (offset = 0; offset < JIT_R_NUM; offset++) {
89 regno = JIT_R(offset);
90 spec = _rvs[regno].spec;
91 if ((spec & jit_class_gpr) && regno == r0)
93 if (!(spec & jit_class_sav)) {
94 jit_regset_clrbit(&_jitc->regsav, regno);
95 emit_ldxi(regno, JIT_FP, _jitc->function->regoff[regno]);
98 /* If knew for certain float registers are not used by
99 * pthread_mutex_lock and pthread_mutex_unlock, could skip this */
100 for (offset = 0; offset < JIT_F_NUM; offset++) {
101 regno = JIT_F(offset);
102 spec = _rvs[regno].spec;
103 if (!(spec & jit_class_sav)) {
104 jit_regset_clrbit(&_jitc->regsav, regno);
105 emit_ldxi_d(regno, JIT_FP, _jitc->function->regoff[regno]);
111 _fallback_calli(jit_state_t *_jit, jit_word_t i0, jit_word_t i1)
113 # if defined(__mips__)
115 # elif defined(__arm__)
117 # elif defined(__sparc__)
119 # elif defined(__ia64__)
120 /* avoid confusion with pushargi patching */
121 if (i1 >= -2097152 && i1 <= 2097151)
122 MOVI(_jitc->rout, i1);
124 MOVL(_jitc->rout, i1);
125 # elif defined(__hppa__)
126 movi(_R26_REGNO, i1);
127 # elif defined(__s390__) || defined(__s390x__)
129 # elif defined(__alpha__)
131 # elif defined(__riscv__)
132 movi(rn(JIT_RA0), i1);
138 _fallback_casx(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
139 jit_int32_t r2, jit_int32_t r3, jit_word_t i0)
141 jit_int32_t r1_reg, iscasi;
142 jit_word_t jump, done;
143 /* XXX only attempts to fallback cas for lightning jit code */
144 static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
145 if ((iscasi = r1 == _NOREG)) {
146 r1_reg = jit_get_reg(jit_class_gpr);
150 fallback_save_regs(r0);
151 fallback_calli((jit_word_t)pthread_mutex_lock, (jit_word_t)&mutex);
157 jump = bnei(_jit->pc.w, r0, 1);
159 # if __WORDSIZE == 32
166 fallback_calli((jit_word_t)pthread_mutex_unlock, (jit_word_t)&mutex);
168 # if defined(__arm__)
169 patch_at(arm_patch_jump, jump, done);
171 patch_at(jump, done);
173 fallback_load_regs(r0);
175 jit_unget_reg(r1_reg);