1 /*
2 * Stack-less Just-In-Time compiler
3 *
4 * Copyright Zoltan Herczeg (hzmester@freemail.hu). All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without modification, are
7 * permitted provided that the following conditions are met:
8 *
9 * 1. Redistributions of source code must retain the above copyright notice, this list of
10 * conditions and the following disclaimer.
11 *
12 * 2. Redistributions in binary form must reproduce the above copyright notice, this list
13 * of conditions and the following disclaimer in the documentation and/or other materials
14 * provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) AND CONTRIBUTORS ``AS IS'' AND ANY
17 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
19 * SHALL THE COPYRIGHT HOLDER(S) OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
21 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
22 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
23 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
24 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 */
26
27 /* mips 32-bit arch dependent functions. */
28
emit_copysign(struct sljit_compiler * compiler,sljit_s32 op,sljit_sw src1,sljit_sw src2,sljit_sw dst)29 static sljit_s32 emit_copysign(struct sljit_compiler *compiler, sljit_s32 op,
30 sljit_sw src1, sljit_sw src2, sljit_sw dst)
31 {
32 int is_32 = (op & SLJIT_32);
33 sljit_ins mfhc = MFC1, mthc = MTC1;
34 sljit_ins src1_r = FS(src1), src2_r = FS(src2), dst_r = FS(dst);
35
36 if (!is_32) {
37 switch (cpu_feature_list & CPU_FEATURE_FR) {
38 #if defined(SLJIT_MIPS_REV) && SLJIT_MIPS_REV >= 2
39 case CPU_FEATURE_FR:
40 mfhc = MFHC1;
41 mthc = MTHC1;
42 break;
43 #endif /* SLJIT_MIPS_REV >= 2 */
44 default:
45 src1_r |= (1 << 11);
46 src2_r |= (1 << 11);
47 dst_r |= (1 << 11);
48 break;
49 }
50 }
51
52 FAIL_IF(push_inst(compiler, mfhc | T(TMP_REG1) | src1_r, DR(TMP_REG1)));
53 FAIL_IF(push_inst(compiler, mfhc | T(TMP_REG2) | src2_r, DR(TMP_REG2)));
54 if (!is_32 && src1 != dst)
55 FAIL_IF(push_inst(compiler, MOV_fmt(FMT_S) | FS(src1) | FD(dst), MOVABLE_INS));
56 #if !defined(SLJIT_MIPS_REV) || SLJIT_MIPS_REV <= 1
57 else
58 FAIL_IF(push_inst(compiler, NOP, UNMOVABLE_INS));
59 #endif /* MIPS III */
60 FAIL_IF(push_inst(compiler, XOR | T(TMP_REG1) | D(TMP_REG2) | S(TMP_REG2), DR(TMP_REG2)));
61 FAIL_IF(push_inst(compiler, SRL | T(TMP_REG2) | D(TMP_REG2) | SH_IMM(31), DR(TMP_REG2)));
62 FAIL_IF(push_inst(compiler, SLL | T(TMP_REG2) | D(TMP_REG2) | SH_IMM(31), DR(TMP_REG2)));
63 FAIL_IF(push_inst(compiler, XOR | T(TMP_REG2) | D(TMP_REG1) | S(TMP_REG1), DR(TMP_REG1)));
64 FAIL_IF(push_inst(compiler, mthc | T(TMP_REG1) | dst_r, MOVABLE_INS));
65 #if !defined(SLJIT_MIPS_REV) || SLJIT_MIPS_REV <= 1
66 if (mthc == MTC1)
67 return push_inst(compiler, NOP, UNMOVABLE_INS);
68 #endif /* MIPS III */
69 return SLJIT_SUCCESS;
70 }
71
load_immediate(struct sljit_compiler * compiler,sljit_s32 dst_ar,sljit_sw imm)72 static sljit_s32 load_immediate(struct sljit_compiler *compiler, sljit_s32 dst_ar, sljit_sw imm)
73 {
74 if (!(imm & ~0xffff))
75 return push_inst(compiler, ORI | SA(0) | TA(dst_ar) | IMM(imm), dst_ar);
76
77 if (imm < 0 && imm >= SIMM_MIN)
78 return push_inst(compiler, ADDIU | SA(0) | TA(dst_ar) | IMM(imm), dst_ar);
79
80 FAIL_IF(push_inst(compiler, LUI | TA(dst_ar) | IMM(imm >> 16), dst_ar));
81 return (imm & 0xffff) ? push_inst(compiler, ORI | SA(dst_ar) | TA(dst_ar) | IMM(imm), dst_ar) : SLJIT_SUCCESS;
82 }
83
emit_const(struct sljit_compiler * compiler,sljit_s32 dst,sljit_sw init_value)84 static SLJIT_INLINE sljit_s32 emit_const(struct sljit_compiler *compiler, sljit_s32 dst, sljit_sw init_value)
85 {
86 FAIL_IF(push_inst(compiler, LUI | T(dst) | IMM(init_value >> 16), DR(dst)));
87 return push_inst(compiler, ORI | S(dst) | T(dst) | IMM(init_value), DR(dst));
88 }
89
sljit_emit_fset64(struct sljit_compiler * compiler,sljit_s32 freg,sljit_f64 value)90 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_fset64(struct sljit_compiler *compiler,
91 sljit_s32 freg, sljit_f64 value)
92 {
93 union {
94 struct {
95 #if defined(SLJIT_LITTLE_ENDIAN) && SLJIT_LITTLE_ENDIAN
96 sljit_s32 lo;
97 sljit_s32 hi;
98 #else /* !SLJIT_LITTLE_ENDIAN */
99 sljit_s32 hi;
100 sljit_s32 lo;
101 #endif /* SLJIT_LITTLE_ENDIAN */
102 } bin;
103 sljit_f64 value;
104 } u;
105
106 CHECK_ERROR();
107 CHECK(check_sljit_emit_fset64(compiler, freg, value));
108
109 u.value = value;
110
111 if (u.bin.lo != 0)
112 FAIL_IF(load_immediate(compiler, DR(TMP_REG1), u.bin.lo));
113 if (u.bin.hi != 0)
114 FAIL_IF(load_immediate(compiler, DR(TMP_REG2), u.bin.hi));
115
116 FAIL_IF(push_inst(compiler, MTC1 | (u.bin.lo != 0 ? T(TMP_REG1) : TA(0)) | FS(freg), MOVABLE_INS));
117 switch (cpu_feature_list & CPU_FEATURE_FR) {
118 #if defined(SLJIT_MIPS_REV) && SLJIT_MIPS_REV >= 2
119 case CPU_FEATURE_FR:
120 return push_inst(compiler, MTHC1 | (u.bin.hi != 0 ? T(TMP_REG2) : TA(0)) | FS(freg), MOVABLE_INS);
121 #endif /* SLJIT_MIPS_REV >= 2 */
122 default:
123 FAIL_IF(push_inst(compiler, MTC1 | (u.bin.hi != 0 ? T(TMP_REG2) : TA(0)) | FS(freg) | (1 << 11), MOVABLE_INS));
124 break;
125 }
126 #if !defined(SLJIT_MIPS_REV) || SLJIT_MIPS_REV <= 1
127 FAIL_IF(push_inst(compiler, NOP, UNMOVABLE_INS));
128 #endif /* MIPS III */
129 return SLJIT_SUCCESS;
130 }
131
sljit_emit_fcopy(struct sljit_compiler * compiler,sljit_s32 op,sljit_s32 freg,sljit_s32 reg)132 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_fcopy(struct sljit_compiler *compiler, sljit_s32 op,
133 sljit_s32 freg, sljit_s32 reg)
134 {
135 sljit_s32 reg2 = 0;
136 sljit_ins inst = FS(freg);
137 sljit_ins mthc = MTC1, mfhc = MFC1;
138 int is_32 = (op & SLJIT_32);
139
140 CHECK_ERROR();
141 CHECK(check_sljit_emit_fcopy(compiler, op, freg, reg));
142
143 op = GET_OPCODE(op);
144 if (reg & REG_PAIR_MASK) {
145 reg2 = REG_PAIR_SECOND(reg);
146 reg = REG_PAIR_FIRST(reg);
147
148 inst |= T(reg2);
149
150 if (op == SLJIT_COPY_TO_F64)
151 FAIL_IF(push_inst(compiler, MTC1 | inst, MOVABLE_INS));
152 else
153 FAIL_IF(push_inst(compiler, MFC1 | inst, DR(reg2)));
154
155 inst = FS(freg) | (1 << 11);
156 #if defined(SLJIT_MIPS_REV) && SLJIT_MIPS_REV >= 2
157 if (cpu_feature_list & CPU_FEATURE_FR) {
158 mthc = MTHC1;
159 mfhc = MFHC1;
160 inst = FS(freg);
161 }
162 #endif /* SLJIT_MIPS_REV >= 2 */
163 }
164
165 inst |= T(reg);
166 if (!is_32 && !reg2) {
167 switch (cpu_feature_list & CPU_FEATURE_FR) {
168 #if defined(SLJIT_MIPS_REV) && SLJIT_MIPS_REV >= 2
169 case CPU_FEATURE_FR:
170 mthc = MTHC1;
171 mfhc = MFHC1;
172 break;
173 #endif /* SLJIT_MIPS_REV >= 2 */
174 default:
175 inst |= (1 << 11);
176 break;
177 }
178 }
179
180 if (op == SLJIT_COPY_TO_F64)
181 FAIL_IF(push_inst(compiler, mthc | inst, MOVABLE_INS));
182 else
183 FAIL_IF(push_inst(compiler, mfhc | inst, DR(reg)));
184
185 #if !defined(SLJIT_MIPS_REV) || SLJIT_MIPS_REV <= 1
186 if (mthc == MTC1 || mfhc == MFC1)
187 return push_inst(compiler, NOP, UNMOVABLE_INS);
188 #endif /* MIPS III */
189 return SLJIT_SUCCESS;
190 }
191
sljit_set_jump_addr(sljit_uw addr,sljit_uw new_target,sljit_sw executable_offset)192 SLJIT_API_FUNC_ATTRIBUTE void sljit_set_jump_addr(sljit_uw addr, sljit_uw new_target, sljit_sw executable_offset)
193 {
194 sljit_ins *inst = (sljit_ins *)addr;
195 SLJIT_UNUSED_ARG(executable_offset);
196
197 SLJIT_UPDATE_WX_FLAGS(inst, inst + 2, 0);
198 SLJIT_ASSERT((inst[0] & 0xffe00000) == LUI && (inst[1] & 0xfc000000) == ORI);
199 inst[0] = (inst[0] & 0xffff0000) | ((new_target >> 16) & 0xffff);
200 inst[1] = (inst[1] & 0xffff0000) | (new_target & 0xffff);
201 SLJIT_UPDATE_WX_FLAGS(inst, inst + 2, 1);
202 inst = (sljit_ins *)SLJIT_ADD_EXEC_OFFSET(inst, executable_offset);
203 SLJIT_CACHE_FLUSH(inst, inst + 2);
204 }
205
sljit_set_const(sljit_uw addr,sljit_sw new_constant,sljit_sw executable_offset)206 SLJIT_API_FUNC_ATTRIBUTE void sljit_set_const(sljit_uw addr, sljit_sw new_constant, sljit_sw executable_offset)
207 {
208 sljit_set_jump_addr(addr, (sljit_uw)new_constant, executable_offset);
209 }
210
call_with_args(struct sljit_compiler * compiler,sljit_s32 arg_types,sljit_ins * ins_ptr,sljit_u32 * extra_space)211 static sljit_s32 call_with_args(struct sljit_compiler *compiler, sljit_s32 arg_types, sljit_ins *ins_ptr, sljit_u32 *extra_space)
212 {
213 sljit_u32 is_tail_call = *extra_space & SLJIT_CALL_RETURN;
214 sljit_u32 offset = 0;
215 sljit_s32 float_arg_count = 0;
216 sljit_s32 word_arg_count = 0;
217 sljit_s32 types = 0;
218 sljit_ins prev_ins = NOP;
219 sljit_ins ins = NOP;
220 sljit_u8 offsets[4];
221 sljit_u8 *offsets_ptr = offsets;
222 #if defined(SLJIT_LITTLE_ENDIAN) && SLJIT_LITTLE_ENDIAN
223 sljit_ins f64_hi = TA(7), f64_lo = TA(6);
224 #else
225 sljit_ins f64_hi = TA(6), f64_lo = TA(7);
226 #endif /* SLJIT_LITTLE_ENDIAN */
227
228 SLJIT_ASSERT(reg_map[TMP_REG1] == 4 && freg_map[TMP_FREG1] == 12);
229
230 arg_types >>= SLJIT_ARG_SHIFT;
231
232 /* See ABI description in sljit_emit_enter. */
233
234 while (arg_types) {
235 types = (types << SLJIT_ARG_SHIFT) | (arg_types & SLJIT_ARG_MASK);
236 *offsets_ptr = (sljit_u8)offset;
237
238 switch (arg_types & SLJIT_ARG_MASK) {
239 case SLJIT_ARG_TYPE_F64:
240 if (offset & 0x7) {
241 offset += sizeof(sljit_sw);
242 *offsets_ptr = (sljit_u8)offset;
243 }
244
245 if (word_arg_count == 0 && float_arg_count <= 1)
246 *offsets_ptr = (sljit_u8)(254 + float_arg_count);
247
248 offset += sizeof(sljit_f64);
249 float_arg_count++;
250 break;
251 case SLJIT_ARG_TYPE_F32:
252 if (word_arg_count == 0 && float_arg_count <= 1)
253 *offsets_ptr = (sljit_u8)(254 + float_arg_count);
254
255 offset += sizeof(sljit_f32);
256 float_arg_count++;
257 break;
258 default:
259 offset += sizeof(sljit_sw);
260 word_arg_count++;
261 break;
262 }
263
264 arg_types >>= SLJIT_ARG_SHIFT;
265 offsets_ptr++;
266 }
267
268 /* Stack is aligned to 16 bytes. */
269 SLJIT_ASSERT(offset <= 8 * sizeof(sljit_sw));
270
271 if (offset > 4 * sizeof(sljit_sw) && (!is_tail_call || offset > compiler->args_size)) {
272 if (is_tail_call) {
273 offset = (offset + sizeof(sljit_sw) + 15) & ~(sljit_uw)0xf;
274 FAIL_IF(emit_stack_frame_release(compiler, (sljit_s32)offset, &prev_ins));
275 *extra_space = offset;
276 } else {
277 FAIL_IF(push_inst(compiler, ADDIU | S(SLJIT_SP) | T(SLJIT_SP) | IMM(-16), DR(SLJIT_SP)));
278 *extra_space = 16;
279 }
280 } else {
281 if (is_tail_call)
282 FAIL_IF(emit_stack_frame_release(compiler, 0, &prev_ins));
283 *extra_space = 0;
284 }
285
286 while (types) {
287 --offsets_ptr;
288
289 switch (types & SLJIT_ARG_MASK) {
290 case SLJIT_ARG_TYPE_F64:
291 if (*offsets_ptr < 4 * sizeof(sljit_sw)) {
292 if (prev_ins != NOP)
293 FAIL_IF(push_inst(compiler, prev_ins, MOVABLE_INS));
294
295 /* Must be preceded by at least one other argument,
296 * and its starting offset must be 8 because of alignment. */
297 SLJIT_ASSERT((*offsets_ptr >> 2) == 2);
298 switch (cpu_feature_list & CPU_FEATURE_FR) {
299 #if defined(SLJIT_MIPS_REV) && SLJIT_MIPS_REV >= 2
300 case CPU_FEATURE_FR:
301 prev_ins = MFHC1 | f64_hi | FS(float_arg_count);
302 break;
303 #endif /* SLJIT_MIPS_REV >= 2 */
304 default:
305 prev_ins = MFC1 | f64_hi | FS(float_arg_count) | (1 << 11);
306 break;
307 }
308 ins = MFC1 | f64_lo | FS(float_arg_count);
309 } else if (*offsets_ptr < 254)
310 ins = SDC1 | S(SLJIT_SP) | FT(float_arg_count) | IMM(*offsets_ptr);
311 else if (*offsets_ptr == 254)
312 ins = MOV_fmt(FMT_D) | FS(SLJIT_FR0) | FD(TMP_FREG1);
313
314 float_arg_count--;
315 break;
316 case SLJIT_ARG_TYPE_F32:
317 if (*offsets_ptr < 4 * sizeof (sljit_sw))
318 ins = MFC1 | TA(4 + (*offsets_ptr >> 2)) | FS(float_arg_count);
319 else if (*offsets_ptr < 254)
320 ins = SWC1 | S(SLJIT_SP) | FT(float_arg_count) | IMM(*offsets_ptr);
321 else if (*offsets_ptr == 254)
322 ins = MOV_fmt(FMT_S) | FS(SLJIT_FR0) | FD(TMP_FREG1);
323
324 float_arg_count--;
325 break;
326 default:
327 if (*offsets_ptr >= 4 * sizeof (sljit_sw))
328 ins = SW | S(SLJIT_SP) | T(word_arg_count) | IMM(*offsets_ptr);
329 else if ((*offsets_ptr >> 2) != word_arg_count - 1)
330 ins = ADDU | S(word_arg_count) | TA(0) | DA(4 + (*offsets_ptr >> 2));
331 else if (*offsets_ptr == 0)
332 ins = ADDU | S(SLJIT_R0) | TA(0) | DA(4);
333
334 word_arg_count--;
335 break;
336 }
337
338 if (ins != NOP) {
339 if (prev_ins != NOP)
340 FAIL_IF(push_inst(compiler, prev_ins, MOVABLE_INS));
341 prev_ins = ins;
342 ins = NOP;
343 }
344
345 types >>= SLJIT_ARG_SHIFT;
346 }
347
348 *ins_ptr = prev_ins;
349
350 return SLJIT_SUCCESS;
351 }
352
sljit_emit_call(struct sljit_compiler * compiler,sljit_s32 type,sljit_s32 arg_types)353 SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_call(struct sljit_compiler *compiler, sljit_s32 type,
354 sljit_s32 arg_types)
355 {
356 struct sljit_jump *jump;
357 sljit_u32 extra_space = 0;
358 sljit_ins ins = NOP;
359
360 CHECK_ERROR_PTR();
361 CHECK_PTR(check_sljit_emit_call(compiler, type, arg_types));
362
363 jump = (struct sljit_jump*)ensure_abuf(compiler, sizeof(struct sljit_jump));
364 PTR_FAIL_IF(!jump);
365 set_jump(jump, compiler, type & SLJIT_REWRITABLE_JUMP);
366
367 if ((type & 0xff) != SLJIT_CALL_REG_ARG) {
368 extra_space = (sljit_u32)type;
369 PTR_FAIL_IF(call_with_args(compiler, arg_types, &ins, &extra_space));
370 } else if (type & SLJIT_CALL_RETURN)
371 PTR_FAIL_IF(emit_stack_frame_release(compiler, 0, &ins));
372
373 SLJIT_ASSERT(DR(PIC_ADDR_REG) == 25 && PIC_ADDR_REG == TMP_REG2);
374
375 if (ins == NOP && compiler->delay_slot != UNMOVABLE_INS)
376 jump->flags |= IS_MOVABLE;
377
378 if (!(type & SLJIT_CALL_RETURN) || extra_space > 0) {
379 jump->flags |= IS_JAL;
380
381 if ((type & 0xff) != SLJIT_CALL_REG_ARG)
382 jump->flags |= IS_CALL;
383
384 PTR_FAIL_IF(push_inst(compiler, JALR | S(PIC_ADDR_REG) | DA(RETURN_ADDR_REG), UNMOVABLE_INS));
385 } else
386 PTR_FAIL_IF(push_inst(compiler, JR | S(PIC_ADDR_REG), UNMOVABLE_INS));
387
388 jump->addr = compiler->size;
389 PTR_FAIL_IF(push_inst(compiler, ins, UNMOVABLE_INS));
390
391 /* Maximum number of instructions required for generating a constant. */
392 compiler->size += 2;
393
394 if (extra_space == 0)
395 return jump;
396
397 if (type & SLJIT_CALL_RETURN)
398 PTR_FAIL_IF(emit_op_mem(compiler, WORD_DATA | LOAD_DATA, RETURN_ADDR_REG,
399 SLJIT_MEM1(SLJIT_SP), (sljit_sw)(extra_space - sizeof(sljit_sw))));
400
401 if (type & SLJIT_CALL_RETURN)
402 PTR_FAIL_IF(push_inst(compiler, JR | SA(RETURN_ADDR_REG), UNMOVABLE_INS));
403
404 PTR_FAIL_IF(push_inst(compiler, ADDIU | S(SLJIT_SP) | T(SLJIT_SP) | IMM(extra_space),
405 (type & SLJIT_CALL_RETURN) ? UNMOVABLE_INS : DR(SLJIT_SP)));
406 return jump;
407 }
408
sljit_emit_icall(struct sljit_compiler * compiler,sljit_s32 type,sljit_s32 arg_types,sljit_s32 src,sljit_sw srcw)409 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_icall(struct sljit_compiler *compiler, sljit_s32 type,
410 sljit_s32 arg_types,
411 sljit_s32 src, sljit_sw srcw)
412 {
413 sljit_u32 extra_space = (sljit_u32)type;
414 sljit_ins ins;
415
416 CHECK_ERROR();
417 CHECK(check_sljit_emit_icall(compiler, type, arg_types, src, srcw));
418
419 if (src & SLJIT_MEM) {
420 ADJUST_LOCAL_OFFSET(src, srcw);
421 FAIL_IF(emit_op_mem(compiler, WORD_DATA | LOAD_DATA, DR(PIC_ADDR_REG), src, srcw));
422 src = PIC_ADDR_REG;
423 srcw = 0;
424 }
425
426 if ((type & 0xff) == SLJIT_CALL_REG_ARG) {
427 if (type & SLJIT_CALL_RETURN) {
428 if (src >= SLJIT_FIRST_SAVED_REG && src <= (SLJIT_S0 - SLJIT_KEPT_SAVEDS_COUNT(compiler->options))) {
429 FAIL_IF(push_inst(compiler, ADDU | S(src) | TA(0) | D(PIC_ADDR_REG), DR(PIC_ADDR_REG)));
430 src = PIC_ADDR_REG;
431 srcw = 0;
432 }
433
434 FAIL_IF(emit_stack_frame_release(compiler, 0, &ins));
435
436 if (ins != NOP)
437 FAIL_IF(push_inst(compiler, ins, MOVABLE_INS));
438 }
439
440 SLJIT_SKIP_CHECKS(compiler);
441 return sljit_emit_ijump(compiler, type, src, srcw);
442 }
443
444 SLJIT_ASSERT(DR(PIC_ADDR_REG) == 25 && PIC_ADDR_REG == TMP_REG2);
445
446 if (src == SLJIT_IMM)
447 FAIL_IF(load_immediate(compiler, DR(PIC_ADDR_REG), srcw));
448 else if (src != PIC_ADDR_REG)
449 FAIL_IF(push_inst(compiler, ADDU | S(src) | TA(0) | D(PIC_ADDR_REG), DR(PIC_ADDR_REG)));
450
451 FAIL_IF(call_with_args(compiler, arg_types, &ins, &extra_space));
452
453 /* Register input. */
454 if (!(type & SLJIT_CALL_RETURN) || extra_space > 0)
455 FAIL_IF(push_inst(compiler, JALR | S(PIC_ADDR_REG) | DA(RETURN_ADDR_REG), UNMOVABLE_INS));
456 else
457 FAIL_IF(push_inst(compiler, JR | S(PIC_ADDR_REG), UNMOVABLE_INS));
458 FAIL_IF(push_inst(compiler, ins, UNMOVABLE_INS));
459
460 if (extra_space == 0)
461 return SLJIT_SUCCESS;
462
463 if (type & SLJIT_CALL_RETURN)
464 FAIL_IF(emit_op_mem(compiler, WORD_DATA | LOAD_DATA, RETURN_ADDR_REG,
465 SLJIT_MEM1(SLJIT_SP), (sljit_sw)(extra_space - sizeof(sljit_sw))));
466
467 if (type & SLJIT_CALL_RETURN)
468 FAIL_IF(push_inst(compiler, JR | SA(RETURN_ADDR_REG), UNMOVABLE_INS));
469
470 return push_inst(compiler, ADDIU | S(SLJIT_SP) | T(SLJIT_SP) | IMM(extra_space),
471 (type & SLJIT_CALL_RETURN) ? UNMOVABLE_INS : DR(SLJIT_SP));
472 }
473
