1 /*
2 * Stack-less Just-In-Time compiler
3 *
4 * Copyright 2009-2012 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
sljit_get_platform_name(void)27 SLJIT_API_FUNC_ATTRIBUTE SLJIT_CONST char* sljit_get_platform_name(void)
28 {
29 return "ARM-64" SLJIT_CPUINFO;
30 }
31
32 /* Length of an instruction word */
33 typedef sljit_ui sljit_ins;
34
35 #define TMP_ZERO 0
36
37 #define TMP_REG1 (SLJIT_NUMBER_OF_REGISTERS + 2)
38 #define TMP_REG2 (SLJIT_NUMBER_OF_REGISTERS + 3)
39 #define TMP_REG3 (SLJIT_NUMBER_OF_REGISTERS + 4)
40 #define TMP_REG4 (SLJIT_NUMBER_OF_REGISTERS + 5)
41 #define TMP_LR (SLJIT_NUMBER_OF_REGISTERS + 6)
42 #define TMP_SP (SLJIT_NUMBER_OF_REGISTERS + 7)
43
44 #define TMP_FREG1 (0)
45 #define TMP_FREG2 (SLJIT_NUMBER_OF_FLOAT_REGISTERS + 1)
46
47 static SLJIT_CONST sljit_ub reg_map[SLJIT_NUMBER_OF_REGISTERS + 8] = {
48 31, 0, 1, 2, 3, 4, 5, 6, 7, 13, 14, 15, 16, 17, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 29, 9, 10, 11, 12, 30, 31
49 };
50
51 #define W_OP (1 << 31)
52 #define RD(rd) (reg_map[rd])
53 #define RT(rt) (reg_map[rt])
54 #define RN(rn) (reg_map[rn] << 5)
55 #define RT2(rt2) (reg_map[rt2] << 10)
56 #define RM(rm) (reg_map[rm] << 16)
57 #define VD(vd) (vd)
58 #define VT(vt) (vt)
59 #define VN(vn) ((vn) << 5)
60 #define VM(vm) ((vm) << 16)
61
62 /* --------------------------------------------------------------------- */
63 /* Instrucion forms */
64 /* --------------------------------------------------------------------- */
65
66 #define ADC 0x9a000000
67 #define ADD 0x8b000000
68 #define ADDI 0x91000000
69 #define AND 0x8a000000
70 #define ANDI 0x92000000
71 #define ASRV 0x9ac02800
72 #define B 0x14000000
73 #define B_CC 0x54000000
74 #define BL 0x94000000
75 #define BLR 0xd63f0000
76 #define BR 0xd61f0000
77 #define BRK 0xd4200000
78 #define CBZ 0xb4000000
79 #define CLZ 0xdac01000
80 #define CSINC 0x9a800400
81 #define EOR 0xca000000
82 #define EORI 0xd2000000
83 #define FABS 0x1e60c000
84 #define FADD 0x1e602800
85 #define FCMP 0x1e602000
86 #define FCVT 0x1e224000
87 #define FCVTZS 0x9e780000
88 #define FDIV 0x1e601800
89 #define FMOV 0x1e604000
90 #define FMUL 0x1e600800
91 #define FNEG 0x1e614000
92 #define FSUB 0x1e603800
93 #define LDRI 0xf9400000
94 #define LDP 0xa9400000
95 #define LDP_PST 0xa8c00000
96 #define LSLV 0x9ac02000
97 #define LSRV 0x9ac02400
98 #define MADD 0x9b000000
99 #define MOVK 0xf2800000
100 #define MOVN 0x92800000
101 #define MOVZ 0xd2800000
102 #define NOP 0xd503201f
103 #define ORN 0xaa200000
104 #define ORR 0xaa000000
105 #define ORRI 0xb2000000
106 #define RET 0xd65f0000
107 #define SBC 0xda000000
108 #define SBFM 0x93000000
109 #define SCVTF 0x9e620000
110 #define SDIV 0x9ac00c00
111 #define SMADDL 0x9b200000
112 #define SMULH 0x9b403c00
113 #define STP 0xa9000000
114 #define STP_PRE 0xa9800000
115 #define STRI 0xf9000000
116 #define STR_FI 0x3d000000
117 #define STR_FR 0x3c206800
118 #define STUR_FI 0x3c000000
119 #define SUB 0xcb000000
120 #define SUBI 0xd1000000
121 #define SUBS 0xeb000000
122 #define UBFM 0xd3000000
123 #define UDIV 0x9ac00800
124 #define UMULH 0x9bc03c00
125
126 /* dest_reg is the absolute name of the register
127 Useful for reordering instructions in the delay slot. */
push_inst(struct sljit_compiler * compiler,sljit_ins ins)128 static sljit_si push_inst(struct sljit_compiler *compiler, sljit_ins ins)
129 {
130 sljit_ins *ptr = (sljit_ins*)ensure_buf(compiler, sizeof(sljit_ins));
131 FAIL_IF(!ptr);
132 *ptr = ins;
133 compiler->size++;
134 return SLJIT_SUCCESS;
135 }
136
emit_imm64_const(struct sljit_compiler * compiler,sljit_si dst,sljit_uw imm)137 static SLJIT_INLINE sljit_si emit_imm64_const(struct sljit_compiler *compiler, sljit_si dst, sljit_uw imm)
138 {
139 FAIL_IF(push_inst(compiler, MOVZ | RD(dst) | ((imm & 0xffff) << 5)));
140 FAIL_IF(push_inst(compiler, MOVK | RD(dst) | (((imm >> 16) & 0xffff) << 5) | (1 << 21)));
141 FAIL_IF(push_inst(compiler, MOVK | RD(dst) | (((imm >> 32) & 0xffff) << 5) | (2 << 21)));
142 return push_inst(compiler, MOVK | RD(dst) | ((imm >> 48) << 5) | (3 << 21));
143 }
144
modify_imm64_const(sljit_ins * inst,sljit_uw new_imm)145 static SLJIT_INLINE void modify_imm64_const(sljit_ins* inst, sljit_uw new_imm)
146 {
147 sljit_si dst = inst[0] & 0x1f;
148 SLJIT_ASSERT((inst[0] & 0xffe00000) == MOVZ && (inst[1] & 0xffe00000) == (MOVK | (1 << 21)));
149 inst[0] = MOVZ | dst | ((new_imm & 0xffff) << 5);
150 inst[1] = MOVK | dst | (((new_imm >> 16) & 0xffff) << 5) | (1 << 21);
151 inst[2] = MOVK | dst | (((new_imm >> 32) & 0xffff) << 5) | (2 << 21);
152 inst[3] = MOVK | dst | ((new_imm >> 48) << 5) | (3 << 21);
153 }
154
detect_jump_type(struct sljit_jump * jump,sljit_ins * code_ptr,sljit_ins * code)155 static SLJIT_INLINE sljit_si detect_jump_type(struct sljit_jump *jump, sljit_ins *code_ptr, sljit_ins *code)
156 {
157 sljit_sw diff;
158 sljit_uw target_addr;
159
160 if (jump->flags & SLJIT_REWRITABLE_JUMP) {
161 jump->flags |= PATCH_ABS64;
162 return 0;
163 }
164
165 if (jump->flags & JUMP_ADDR)
166 target_addr = jump->u.target;
167 else {
168 SLJIT_ASSERT(jump->flags & JUMP_LABEL);
169 target_addr = (sljit_uw)(code + jump->u.label->size);
170 }
171 diff = (sljit_sw)target_addr - (sljit_sw)(code_ptr + 4);
172
173 if (jump->flags & IS_COND) {
174 diff += sizeof(sljit_ins);
175 if (diff <= 0xfffff && diff >= -0x100000) {
176 code_ptr[-5] ^= (jump->flags & IS_CBZ) ? (0x1 << 24) : 0x1;
177 jump->addr -= sizeof(sljit_ins);
178 jump->flags |= PATCH_COND;
179 return 5;
180 }
181 diff -= sizeof(sljit_ins);
182 }
183
184 if (diff <= 0x7ffffff && diff >= -0x8000000) {
185 jump->flags |= PATCH_B;
186 return 4;
187 }
188
189 if (target_addr <= 0xffffffffl) {
190 if (jump->flags & IS_COND)
191 code_ptr[-5] -= (2 << 5);
192 code_ptr[-2] = code_ptr[0];
193 return 2;
194 }
195 if (target_addr <= 0xffffffffffffl) {
196 if (jump->flags & IS_COND)
197 code_ptr[-5] -= (1 << 5);
198 jump->flags |= PATCH_ABS48;
199 code_ptr[-1] = code_ptr[0];
200 return 1;
201 }
202
203 jump->flags |= PATCH_ABS64;
204 return 0;
205 }
206
sljit_generate_code(struct sljit_compiler * compiler)207 SLJIT_API_FUNC_ATTRIBUTE void* sljit_generate_code(struct sljit_compiler *compiler)
208 {
209 struct sljit_memory_fragment *buf;
210 sljit_ins *code;
211 sljit_ins *code_ptr;
212 sljit_ins *buf_ptr;
213 sljit_ins *buf_end;
214 sljit_uw word_count;
215 sljit_uw addr;
216 sljit_si dst;
217
218 struct sljit_label *label;
219 struct sljit_jump *jump;
220 struct sljit_const *const_;
221
222 CHECK_ERROR_PTR();
223 check_sljit_generate_code(compiler);
224 reverse_buf(compiler);
225
226 code = (sljit_ins*)SLJIT_MALLOC_EXEC(compiler->size * sizeof(sljit_ins));
227 PTR_FAIL_WITH_EXEC_IF(code);
228 buf = compiler->buf;
229
230 code_ptr = code;
231 word_count = 0;
232 label = compiler->labels;
233 jump = compiler->jumps;
234 const_ = compiler->consts;
235
236 do {
237 buf_ptr = (sljit_ins*)buf->memory;
238 buf_end = buf_ptr + (buf->used_size >> 2);
239 do {
240 *code_ptr = *buf_ptr++;
241 /* These structures are ordered by their address. */
242 SLJIT_ASSERT(!label || label->size >= word_count);
243 SLJIT_ASSERT(!jump || jump->addr >= word_count);
244 SLJIT_ASSERT(!const_ || const_->addr >= word_count);
245 if (label && label->size == word_count) {
246 label->addr = (sljit_uw)code_ptr;
247 label->size = code_ptr - code;
248 label = label->next;
249 }
250 if (jump && jump->addr == word_count) {
251 jump->addr = (sljit_uw)(code_ptr - 4);
252 code_ptr -= detect_jump_type(jump, code_ptr, code);
253 jump = jump->next;
254 }
255 if (const_ && const_->addr == word_count) {
256 const_->addr = (sljit_uw)code_ptr;
257 const_ = const_->next;
258 }
259 code_ptr ++;
260 word_count ++;
261 } while (buf_ptr < buf_end);
262
263 buf = buf->next;
264 } while (buf);
265
266 if (label && label->size == word_count) {
267 label->addr = (sljit_uw)code_ptr;
268 label->size = code_ptr - code;
269 label = label->next;
270 }
271
272 SLJIT_ASSERT(!label);
273 SLJIT_ASSERT(!jump);
274 SLJIT_ASSERT(!const_);
275 SLJIT_ASSERT(code_ptr - code <= (sljit_sw)compiler->size);
276
277 jump = compiler->jumps;
278 while (jump) {
279 do {
280 addr = (jump->flags & JUMP_LABEL) ? jump->u.label->addr : jump->u.target;
281 buf_ptr = (sljit_ins*)jump->addr;
282 if (jump->flags & PATCH_B) {
283 addr = (sljit_sw)(addr - jump->addr) >> 2;
284 SLJIT_ASSERT((sljit_sw)addr <= 0x1ffffff && (sljit_sw)addr >= -0x2000000);
285 buf_ptr[0] = ((jump->flags & IS_BL) ? BL : B) | (addr & 0x3ffffff);
286 if (jump->flags & IS_COND)
287 buf_ptr[-1] -= (4 << 5);
288 break;
289 }
290 if (jump->flags & PATCH_COND) {
291 addr = (sljit_sw)(addr - jump->addr) >> 2;
292 SLJIT_ASSERT((sljit_sw)addr <= 0x3ffff && (sljit_sw)addr >= -0x40000);
293 buf_ptr[0] = (buf_ptr[0] & ~0xffffe0) | ((addr & 0x7ffff) << 5);
294 break;
295 }
296
297 SLJIT_ASSERT((jump->flags & (PATCH_ABS48 | PATCH_ABS64)) || addr <= 0xffffffffl);
298 SLJIT_ASSERT((jump->flags & PATCH_ABS64) || addr <= 0xffffffffffffl);
299
300 dst = buf_ptr[0] & 0x1f;
301 buf_ptr[0] = MOVZ | dst | ((addr & 0xffff) << 5);
302 buf_ptr[1] = MOVK | dst | (((addr >> 16) & 0xffff) << 5) | (1 << 21);
303 if (jump->flags & (PATCH_ABS48 | PATCH_ABS64))
304 buf_ptr[2] = MOVK | dst | (((addr >> 32) & 0xffff) << 5) | (2 << 21);
305 if (jump->flags & PATCH_ABS64)
306 buf_ptr[3] = MOVK | dst | (((addr >> 48) & 0xffff) << 5) | (3 << 21);
307 } while (0);
308 jump = jump->next;
309 }
310
311 compiler->error = SLJIT_ERR_COMPILED;
312 compiler->executable_size = (code_ptr - code) * sizeof(sljit_ins);
313 SLJIT_CACHE_FLUSH(code, code_ptr);
314 return code;
315 }
316
317 /* --------------------------------------------------------------------- */
318 /* Core code generator functions. */
319 /* --------------------------------------------------------------------- */
320
321 #define COUNT_TRAILING_ZERO(value, result) \
322 result = 0; \
323 if (!(value & 0xffffffff)) { \
324 result += 32; \
325 value >>= 32; \
326 } \
327 if (!(value & 0xffff)) { \
328 result += 16; \
329 value >>= 16; \
330 } \
331 if (!(value & 0xff)) { \
332 result += 8; \
333 value >>= 8; \
334 } \
335 if (!(value & 0xf)) { \
336 result += 4; \
337 value >>= 4; \
338 } \
339 if (!(value & 0x3)) { \
340 result += 2; \
341 value >>= 2; \
342 } \
343 if (!(value & 0x1)) { \
344 result += 1; \
345 value >>= 1; \
346 }
347
348 #define LOGICAL_IMM_CHECK 0x100
349
logical_imm(sljit_sw imm,sljit_si len)350 static sljit_ins logical_imm(sljit_sw imm, sljit_si len)
351 {
352 sljit_si negated, ones, right;
353 sljit_uw mask, uimm;
354 sljit_ins ins;
355
356 if (len & LOGICAL_IMM_CHECK) {
357 len &= ~LOGICAL_IMM_CHECK;
358 if (len == 32 && (imm == 0 || imm == -1))
359 return 0;
360 if (len == 16 && ((sljit_si)imm == 0 || (sljit_si)imm == -1))
361 return 0;
362 }
363
364 SLJIT_ASSERT((len == 32 && imm != 0 && imm != -1)
365 || (len == 16 && (sljit_si)imm != 0 && (sljit_si)imm != -1));
366 uimm = (sljit_uw)imm;
367 while (1) {
368 if (len <= 0) {
369 SLJIT_ASSERT_STOP();
370 return 0;
371 }
372 mask = ((sljit_uw)1 << len) - 1;
373 if ((uimm & mask) != ((uimm >> len) & mask))
374 break;
375 len >>= 1;
376 }
377
378 len <<= 1;
379
380 negated = 0;
381 if (uimm & 0x1) {
382 negated = 1;
383 uimm = ~uimm;
384 }
385
386 if (len < 64)
387 uimm &= ((sljit_uw)1 << len) - 1;
388
389 /* Unsigned right shift. */
390 COUNT_TRAILING_ZERO(uimm, right);
391
392 /* Signed shift. We also know that the highest bit is set. */
393 imm = (sljit_sw)~uimm;
394 SLJIT_ASSERT(imm < 0);
395
396 COUNT_TRAILING_ZERO(imm, ones);
397
398 if (~imm)
399 return 0;
400
401 if (len == 64)
402 ins = 1 << 22;
403 else
404 ins = (0x3f - ((len << 1) - 1)) << 10;
405
406 if (negated)
407 return ins | ((len - ones - 1) << 10) | ((len - ones - right) << 16);
408
409 return ins | ((ones - 1) << 10) | ((len - right) << 16);
410 }
411
412 #undef COUNT_TRAILING_ZERO
413
load_immediate(struct sljit_compiler * compiler,sljit_si dst,sljit_sw simm)414 static sljit_si load_immediate(struct sljit_compiler *compiler, sljit_si dst, sljit_sw simm)
415 {
416 sljit_uw imm = (sljit_uw)simm;
417 sljit_si i, zeros, ones, first;
418 sljit_ins bitmask;
419
420 if (imm <= 0xffff)
421 return push_inst(compiler, MOVZ | RD(dst) | (imm << 5));
422
423 if (simm >= -0x10000 && simm < 0)
424 return push_inst(compiler, MOVN | RD(dst) | ((~imm & 0xffff) << 5));
425
426 if (imm <= 0xffffffffl) {
427 if ((imm & 0xffff0000l) == 0xffff0000)
428 return push_inst(compiler, (MOVN ^ W_OP) | RD(dst) | ((~imm & 0xffff) << 5));
429 if ((imm & 0xffff) == 0xffff)
430 return push_inst(compiler, (MOVN ^ W_OP) | RD(dst) | ((~imm & 0xffff0000l) >> (16 - 5)) | (1 << 21));
431 bitmask = logical_imm(simm, 16);
432 if (bitmask != 0)
433 return push_inst(compiler, (ORRI ^ W_OP) | RD(dst) | RN(TMP_ZERO) | bitmask);
434 }
435 else {
436 bitmask = logical_imm(simm, 32);
437 if (bitmask != 0)
438 return push_inst(compiler, ORRI | RD(dst) | RN(TMP_ZERO) | bitmask);
439 }
440
441 if (imm <= 0xffffffffl) {
442 FAIL_IF(push_inst(compiler, MOVZ | RD(dst) | ((imm & 0xffff) << 5)));
443 return push_inst(compiler, MOVK | RD(dst) | ((imm & 0xffff0000l) >> (16 - 5)) | (1 << 21));
444 }
445
446 if (simm >= -0x100000000l && simm < 0) {
447 FAIL_IF(push_inst(compiler, MOVN | RD(dst) | ((~imm & 0xffff) << 5)));
448 return push_inst(compiler, MOVK | RD(dst) | ((imm & 0xffff0000l) >> (16 - 5)) | (1 << 21));
449 }
450
451 /* A large amount of number can be constructed from ORR and MOVx,
452 but computing them is costly. We don't */
453
454 zeros = 0;
455 ones = 0;
456 for (i = 4; i > 0; i--) {
457 if ((simm & 0xffff) == 0)
458 zeros++;
459 if ((simm & 0xffff) == 0xffff)
460 ones++;
461 simm >>= 16;
462 }
463
464 simm = (sljit_sw)imm;
465 first = 1;
466 if (ones > zeros) {
467 simm = ~simm;
468 for (i = 0; i < 4; i++) {
469 if (!(simm & 0xffff)) {
470 simm >>= 16;
471 continue;
472 }
473 if (first) {
474 first = 0;
475 FAIL_IF(push_inst(compiler, MOVN | RD(dst) | ((simm & 0xffff) << 5) | (i << 21)));
476 }
477 else
478 FAIL_IF(push_inst(compiler, MOVK | RD(dst) | ((~simm & 0xffff) << 5) | (i << 21)));
479 simm >>= 16;
480 }
481 return SLJIT_SUCCESS;
482 }
483
484 for (i = 0; i < 4; i++) {
485 if (!(simm & 0xffff)) {
486 simm >>= 16;
487 continue;
488 }
489 if (first) {
490 first = 0;
491 FAIL_IF(push_inst(compiler, MOVZ | RD(dst) | ((simm & 0xffff) << 5) | (i << 21)));
492 }
493 else
494 FAIL_IF(push_inst(compiler, MOVK | RD(dst) | ((simm & 0xffff) << 5) | (i << 21)));
495 simm >>= 16;
496 }
497 return SLJIT_SUCCESS;
498 }
499
500 #define ARG1_IMM 0x0010000
501 #define ARG2_IMM 0x0020000
502 #define INT_OP 0x0040000
503 #define SET_FLAGS 0x0080000
504 #define UNUSED_RETURN 0x0100000
505 #define SLOW_DEST 0x0200000
506 #define SLOW_SRC1 0x0400000
507 #define SLOW_SRC2 0x0800000
508
509 #define CHECK_FLAGS(flag_bits) \
510 if (flags & SET_FLAGS) { \
511 inv_bits |= flag_bits; \
512 if (flags & UNUSED_RETURN) \
513 dst = TMP_ZERO; \
514 }
515
emit_op_imm(struct sljit_compiler * compiler,sljit_si flags,sljit_si dst,sljit_sw arg1,sljit_sw arg2)516 static sljit_si emit_op_imm(struct sljit_compiler *compiler, sljit_si flags, sljit_si dst, sljit_sw arg1, sljit_sw arg2)
517 {
518 /* dst must be register, TMP_REG1
519 arg1 must be register, TMP_REG1, imm
520 arg2 must be register, TMP_REG2, imm */
521 sljit_ins inv_bits = (flags & INT_OP) ? (1 << 31) : 0;
522 sljit_ins inst_bits;
523 sljit_si op = (flags & 0xffff);
524 sljit_si reg;
525 sljit_sw imm, nimm;
526
527 if (SLJIT_UNLIKELY((flags & (ARG1_IMM | ARG2_IMM)) == (ARG1_IMM | ARG2_IMM))) {
528 /* Both are immediates. */
529 flags &= ~ARG1_IMM;
530 if (arg1 == 0 && op != SLJIT_ADD && op != SLJIT_SUB)
531 arg1 = TMP_ZERO;
532 else {
533 FAIL_IF(load_immediate(compiler, TMP_REG1, arg1));
534 arg1 = TMP_REG1;
535 }
536 }
537
538 if (flags & (ARG1_IMM | ARG2_IMM)) {
539 reg = (flags & ARG2_IMM) ? arg1 : arg2;
540 imm = (flags & ARG2_IMM) ? arg2 : arg1;
541
542 switch (op) {
543 case SLJIT_MUL:
544 case SLJIT_NEG:
545 case SLJIT_CLZ:
546 case SLJIT_ADDC:
547 case SLJIT_SUBC:
548 /* No form with immediate operand (except imm 0, which
549 is represented by a ZERO register). */
550 break;
551 case SLJIT_MOV:
552 SLJIT_ASSERT(!(flags & SET_FLAGS) && (flags & ARG2_IMM) && arg1 == TMP_REG1);
553 return load_immediate(compiler, dst, imm);
554 case SLJIT_NOT:
555 SLJIT_ASSERT(flags & ARG2_IMM);
556 FAIL_IF(load_immediate(compiler, dst, (flags & INT_OP) ? (~imm & 0xffffffff) : ~imm));
557 goto set_flags;
558 case SLJIT_SUB:
559 if (flags & ARG1_IMM)
560 break;
561 imm = -imm;
562 /* Fall through. */
563 case SLJIT_ADD:
564 if (imm == 0) {
565 CHECK_FLAGS(1 << 29);
566 return push_inst(compiler, ((op == SLJIT_ADD ? ADDI : SUBI) ^ inv_bits) | RD(dst) | RN(reg));
567 }
568 if (imm > 0 && imm <= 0xfff) {
569 CHECK_FLAGS(1 << 29);
570 return push_inst(compiler, (ADDI ^ inv_bits) | RD(dst) | RN(reg) | (imm << 10));
571 }
572 nimm = -imm;
573 if (nimm > 0 && nimm <= 0xfff) {
574 CHECK_FLAGS(1 << 29);
575 return push_inst(compiler, (SUBI ^ inv_bits) | RD(dst) | RN(reg) | (nimm << 10));
576 }
577 if (imm > 0 && imm <= 0xffffff && !(imm & 0xfff)) {
578 CHECK_FLAGS(1 << 29);
579 return push_inst(compiler, (ADDI ^ inv_bits) | RD(dst) | RN(reg) | ((imm >> 12) << 10) | (1 << 22));
580 }
581 if (nimm > 0 && nimm <= 0xffffff && !(nimm & 0xfff)) {
582 CHECK_FLAGS(1 << 29);
583 return push_inst(compiler, (SUBI ^ inv_bits) | RD(dst) | RN(reg) | ((nimm >> 12) << 10) | (1 << 22));
584 }
585 if (imm > 0 && imm <= 0xffffff && !(flags & SET_FLAGS)) {
586 FAIL_IF(push_inst(compiler, (ADDI ^ inv_bits) | RD(dst) | RN(reg) | ((imm >> 12) << 10) | (1 << 22)));
587 return push_inst(compiler, (ADDI ^ inv_bits) | RD(dst) | RN(dst) | ((imm & 0xfff) << 10));
588 }
589 if (nimm > 0 && nimm <= 0xffffff && !(flags & SET_FLAGS)) {
590 FAIL_IF(push_inst(compiler, (SUBI ^ inv_bits) | RD(dst) | RN(reg) | ((nimm >> 12) << 10) | (1 << 22)));
591 return push_inst(compiler, (SUBI ^ inv_bits) | RD(dst) | RN(dst) | ((nimm & 0xfff) << 10));
592 }
593 break;
594 case SLJIT_AND:
595 inst_bits = logical_imm(imm, LOGICAL_IMM_CHECK | ((flags & INT_OP) ? 16 : 32));
596 if (!inst_bits)
597 break;
598 CHECK_FLAGS(3 << 29);
599 return push_inst(compiler, (ANDI ^ inv_bits) | RD(dst) | RN(reg) | inst_bits);
600 case SLJIT_OR:
601 case SLJIT_XOR:
602 inst_bits = logical_imm(imm, LOGICAL_IMM_CHECK | ((flags & INT_OP) ? 16 : 32));
603 if (!inst_bits)
604 break;
605 if (op == SLJIT_OR)
606 inst_bits |= ORRI;
607 else
608 inst_bits |= EORI;
609 FAIL_IF(push_inst(compiler, (inst_bits ^ inv_bits) | RD(dst) | RN(reg)));
610 goto set_flags;
611 case SLJIT_SHL:
612 if (flags & ARG1_IMM)
613 break;
614 if (flags & INT_OP) {
615 imm &= 0x1f;
616 FAIL_IF(push_inst(compiler, (UBFM ^ inv_bits) | RD(dst) | RN(arg1) | ((-imm & 0x1f) << 16) | ((31 - imm) << 10)));
617 }
618 else {
619 imm &= 0x3f;
620 FAIL_IF(push_inst(compiler, (UBFM ^ inv_bits) | RD(dst) | RN(arg1) | (1 << 22) | ((-imm & 0x3f) << 16) | ((63 - imm) << 10)));
621 }
622 goto set_flags;
623 case SLJIT_LSHR:
624 case SLJIT_ASHR:
625 if (flags & ARG1_IMM)
626 break;
627 if (op == SLJIT_ASHR)
628 inv_bits |= 1 << 30;
629 if (flags & INT_OP) {
630 imm &= 0x1f;
631 FAIL_IF(push_inst(compiler, (UBFM ^ inv_bits) | RD(dst) | RN(arg1) | (imm << 16) | (31 << 10)));
632 }
633 else {
634 imm &= 0x3f;
635 FAIL_IF(push_inst(compiler, (UBFM ^ inv_bits) | RD(dst) | RN(arg1) | (1 << 22) | (imm << 16) | (63 << 10)));
636 }
637 goto set_flags;
638 default:
639 SLJIT_ASSERT_STOP();
640 break;
641 }
642
643 if (flags & ARG2_IMM) {
644 if (arg2 == 0)
645 arg2 = TMP_ZERO;
646 else {
647 FAIL_IF(load_immediate(compiler, TMP_REG2, arg2));
648 arg2 = TMP_REG2;
649 }
650 }
651 else {
652 if (arg1 == 0)
653 arg1 = TMP_ZERO;
654 else {
655 FAIL_IF(load_immediate(compiler, TMP_REG1, arg1));
656 arg1 = TMP_REG1;
657 }
658 }
659 }
660
661 /* Both arguments are registers. */
662 switch (op) {
663 case SLJIT_MOV:
664 case SLJIT_MOV_P:
665 case SLJIT_MOVU:
666 case SLJIT_MOVU_P:
667 SLJIT_ASSERT(!(flags & SET_FLAGS) && arg1 == TMP_REG1);
668 if (dst == arg2)
669 return SLJIT_SUCCESS;
670 return push_inst(compiler, ORR | RD(dst) | RN(TMP_ZERO) | RM(arg2));
671 case SLJIT_MOV_UB:
672 case SLJIT_MOVU_UB:
673 SLJIT_ASSERT(!(flags & SET_FLAGS) && arg1 == TMP_REG1);
674 return push_inst(compiler, (UBFM ^ (1 << 31)) | RD(dst) | RN(arg2) | (7 << 10));
675 case SLJIT_MOV_SB:
676 case SLJIT_MOVU_SB:
677 SLJIT_ASSERT(!(flags & SET_FLAGS) && arg1 == TMP_REG1);
678 if (!(flags & INT_OP))
679 inv_bits |= 1 << 22;
680 return push_inst(compiler, (SBFM ^ inv_bits) | RD(dst) | RN(arg2) | (7 << 10));
681 case SLJIT_MOV_UH:
682 case SLJIT_MOVU_UH:
683 SLJIT_ASSERT(!(flags & SET_FLAGS) && arg1 == TMP_REG1);
684 return push_inst(compiler, (UBFM ^ (1 << 31)) | RD(dst) | RN(arg2) | (15 << 10));
685 case SLJIT_MOV_SH:
686 case SLJIT_MOVU_SH:
687 SLJIT_ASSERT(!(flags & SET_FLAGS) && arg1 == TMP_REG1);
688 if (!(flags & INT_OP))
689 inv_bits |= 1 << 22;
690 return push_inst(compiler, (SBFM ^ inv_bits) | RD(dst) | RN(arg2) | (15 << 10));
691 case SLJIT_MOV_UI:
692 case SLJIT_MOVU_UI:
693 SLJIT_ASSERT(!(flags & SET_FLAGS) && arg1 == TMP_REG1);
694 if ((flags & INT_OP) && dst == arg2)
695 return SLJIT_SUCCESS;
696 return push_inst(compiler, (ORR ^ (1 << 31)) | RD(dst) | RN(TMP_ZERO) | RM(arg2));
697 case SLJIT_MOV_SI:
698 case SLJIT_MOVU_SI:
699 SLJIT_ASSERT(!(flags & SET_FLAGS) && arg1 == TMP_REG1);
700 if ((flags & INT_OP) && dst == arg2)
701 return SLJIT_SUCCESS;
702 return push_inst(compiler, SBFM | (1 << 22) | RD(dst) | RN(arg2) | (31 << 10));
703 case SLJIT_NOT:
704 SLJIT_ASSERT(arg1 == TMP_REG1);
705 FAIL_IF(push_inst(compiler, (ORN ^ inv_bits) | RD(dst) | RN(TMP_ZERO) | RM(arg2)));
706 goto set_flags;
707 case SLJIT_NEG:
708 SLJIT_ASSERT(arg1 == TMP_REG1);
709 if (flags & SET_FLAGS)
710 inv_bits |= 1 << 29;
711 return push_inst(compiler, (SUB ^ inv_bits) | RD(dst) | RN(TMP_ZERO) | RM(arg2));
712 case SLJIT_CLZ:
713 SLJIT_ASSERT(arg1 == TMP_REG1);
714 FAIL_IF(push_inst(compiler, (CLZ ^ inv_bits) | RD(dst) | RN(arg2)));
715 goto set_flags;
716 case SLJIT_ADD:
717 CHECK_FLAGS(1 << 29);
718 return push_inst(compiler, (ADD ^ inv_bits) | RD(dst) | RN(arg1) | RM(arg2));
719 case SLJIT_ADDC:
720 CHECK_FLAGS(1 << 29);
721 return push_inst(compiler, (ADC ^ inv_bits) | RD(dst) | RN(arg1) | RM(arg2));
722 case SLJIT_SUB:
723 CHECK_FLAGS(1 << 29);
724 return push_inst(compiler, (SUB ^ inv_bits) | RD(dst) | RN(arg1) | RM(arg2));
725 case SLJIT_SUBC:
726 CHECK_FLAGS(1 << 29);
727 return push_inst(compiler, (SBC ^ inv_bits) | RD(dst) | RN(arg1) | RM(arg2));
728 case SLJIT_MUL:
729 if (!(flags & SET_FLAGS))
730 return push_inst(compiler, (MADD ^ inv_bits) | RD(dst) | RN(arg1) | RM(arg2) | RT2(TMP_ZERO));
731 if (flags & INT_OP) {
732 FAIL_IF(push_inst(compiler, SMADDL | RD(dst) | RN(arg1) | RM(arg2) | (31 << 10)));
733 FAIL_IF(push_inst(compiler, ADD | RD(TMP_REG4) | RN(TMP_ZERO) | RM(dst) | (2 << 22) | (31 << 10)));
734 return push_inst(compiler, SUBS | RD(TMP_ZERO) | RN(TMP_REG4) | RM(dst) | (2 << 22) | (63 << 10));
735 }
736 FAIL_IF(push_inst(compiler, SMULH | RD(TMP_REG4) | RN(arg1) | RM(arg2)));
737 FAIL_IF(push_inst(compiler, MADD | RD(dst) | RN(arg1) | RM(arg2) | RT2(TMP_ZERO)));
738 return push_inst(compiler, SUBS | RD(TMP_ZERO) | RN(TMP_REG4) | RM(dst) | (2 << 22) | (63 << 10));
739 case SLJIT_AND:
740 CHECK_FLAGS(3 << 29);
741 return push_inst(compiler, (AND ^ inv_bits) | RD(dst) | RN(arg1) | RM(arg2));
742 case SLJIT_OR:
743 FAIL_IF(push_inst(compiler, (ORR ^ inv_bits) | RD(dst) | RN(arg1) | RM(arg2)));
744 goto set_flags;
745 case SLJIT_XOR:
746 FAIL_IF(push_inst(compiler, (EOR ^ inv_bits) | RD(dst) | RN(arg1) | RM(arg2)));
747 goto set_flags;
748 case SLJIT_SHL:
749 FAIL_IF(push_inst(compiler, (LSLV ^ inv_bits) | RD(dst) | RN(arg1) | RM(arg2)));
750 goto set_flags;
751 case SLJIT_LSHR:
752 FAIL_IF(push_inst(compiler, (LSRV ^ inv_bits) | RD(dst) | RN(arg1) | RM(arg2)));
753 goto set_flags;
754 case SLJIT_ASHR:
755 FAIL_IF(push_inst(compiler, (ASRV ^ inv_bits) | RD(dst) | RN(arg1) | RM(arg2)));
756 goto set_flags;
757 }
758
759 SLJIT_ASSERT_STOP();
760 return SLJIT_SUCCESS;
761
762 set_flags:
763 if (flags & SET_FLAGS)
764 return push_inst(compiler, (SUBS ^ inv_bits) | RD(TMP_ZERO) | RN(dst) | RM(TMP_ZERO));
765 return SLJIT_SUCCESS;
766 }
767
768 #define STORE 0x01
769 #define SIGNED 0x02
770
771 #define UPDATE 0x04
772 #define ARG_TEST 0x08
773
774 #define BYTE_SIZE 0x000
775 #define HALF_SIZE 0x100
776 #define INT_SIZE 0x200
777 #define WORD_SIZE 0x300
778
779 #define MEM_SIZE_SHIFT(flags) ((flags) >> 8)
780
781 static SLJIT_CONST sljit_ins sljit_mem_imm[4] = {
782 /* u l */ 0x39400000 /* ldrb [reg,imm] */,
783 /* u s */ 0x39000000 /* strb [reg,imm] */,
784 /* s l */ 0x39800000 /* ldrsb [reg,imm] */,
785 /* s s */ 0x39000000 /* strb [reg,imm] */,
786 };
787
788 static SLJIT_CONST sljit_ins sljit_mem_simm[4] = {
789 /* u l */ 0x38400000 /* ldurb [reg,imm] */,
790 /* u s */ 0x38000000 /* sturb [reg,imm] */,
791 /* s l */ 0x38800000 /* ldursb [reg,imm] */,
792 /* s s */ 0x38000000 /* sturb [reg,imm] */,
793 };
794
795 static SLJIT_CONST sljit_ins sljit_mem_pre_simm[4] = {
796 /* u l */ 0x38400c00 /* ldrb [reg,imm]! */,
797 /* u s */ 0x38000c00 /* strb [reg,imm]! */,
798 /* s l */ 0x38800c00 /* ldrsb [reg,imm]! */,
799 /* s s */ 0x38000c00 /* strb [reg,imm]! */,
800 };
801
802 static SLJIT_CONST sljit_ins sljit_mem_reg[4] = {
803 /* u l */ 0x38606800 /* ldrb [reg,reg] */,
804 /* u s */ 0x38206800 /* strb [reg,reg] */,
805 /* s l */ 0x38a06800 /* ldrsb [reg,reg] */,
806 /* s s */ 0x38206800 /* strb [reg,reg] */,
807 };
808
809 /* Helper function. Dst should be reg + value, using at most 1 instruction, flags does not set. */
emit_set_delta(struct sljit_compiler * compiler,sljit_si dst,sljit_si reg,sljit_sw value)810 static sljit_si emit_set_delta(struct sljit_compiler *compiler, sljit_si dst, sljit_si reg, sljit_sw value)
811 {
812 if (value >= 0) {
813 if (value <= 0xfff)
814 return push_inst(compiler, ADDI | RD(dst) | RN(reg) | (value << 10));
815 if (value <= 0xffffff && !(value & 0xfff))
816 return push_inst(compiler, ADDI | (1 << 22) | RD(dst) | RN(reg) | (value >> 2));
817 }
818 else {
819 value = -value;
820 if (value <= 0xfff)
821 return push_inst(compiler, SUBI | RD(dst) | RN(reg) | (value << 10));
822 if (value <= 0xffffff && !(value & 0xfff))
823 return push_inst(compiler, SUBI | (1 << 22) | RD(dst) | RN(reg) | (value >> 2));
824 }
825 return SLJIT_ERR_UNSUPPORTED;
826 }
827
828 /* Can perform an operation using at most 1 instruction. */
getput_arg_fast(struct sljit_compiler * compiler,sljit_si flags,sljit_si reg,sljit_si arg,sljit_sw argw)829 static sljit_si getput_arg_fast(struct sljit_compiler *compiler, sljit_si flags, sljit_si reg, sljit_si arg, sljit_sw argw)
830 {
831 sljit_ui shift = MEM_SIZE_SHIFT(flags);
832
833 SLJIT_ASSERT(arg & SLJIT_MEM);
834
835 if (SLJIT_UNLIKELY(flags & UPDATE)) {
836 if ((arg & REG_MASK) && !(arg & OFFS_REG_MASK) && argw <= 255 && argw >= -256) {
837 if (SLJIT_UNLIKELY(flags & ARG_TEST))
838 return 1;
839
840 arg &= REG_MASK;
841 argw &= 0x1ff;
842 FAIL_IF(push_inst(compiler, sljit_mem_pre_simm[flags & 0x3]
843 | (shift << 30) | RT(reg) | RN(arg) | (argw << 12)));
844 return -1;
845 }
846 return 0;
847 }
848
849 if (SLJIT_UNLIKELY(arg & OFFS_REG_MASK)) {
850 argw &= 0x3;
851 if (argw && argw != shift)
852 return 0;
853
854 if (SLJIT_UNLIKELY(flags & ARG_TEST))
855 return 1;
856
857 FAIL_IF(push_inst(compiler, sljit_mem_reg[flags & 0x3] | (shift << 30) | RT(reg)
858 | RN(arg & REG_MASK) | RM(OFFS_REG(arg)) | (argw ? (1 << 12) : 0)));
859 return -1;
860 }
861
862 arg &= REG_MASK;
863 if (argw >= 0 && (argw >> shift) <= 0xfff && (argw & ((1 << shift) - 1)) == 0) {
864 if (SLJIT_UNLIKELY(flags & ARG_TEST))
865 return 1;
866
867 FAIL_IF(push_inst(compiler, sljit_mem_imm[flags & 0x3] | (shift << 30)
868 | RT(reg) | RN(arg) | (argw << (10 - shift))));
869 return -1;
870 }
871
872 if (argw > 255 || argw < -256)
873 return 0;
874
875 if (SLJIT_UNLIKELY(flags & ARG_TEST))
876 return 1;
877
878 FAIL_IF(push_inst(compiler, sljit_mem_simm[flags & 0x3] | (shift << 30)
879 | RT(reg) | RN(arg) | ((argw & 0x1ff) << 12)));
880 return -1;
881 }
882
883 /* see getput_arg below.
884 Note: can_cache is called only for binary operators. Those
885 operators always uses word arguments without write back. */
can_cache(sljit_si arg,sljit_sw argw,sljit_si next_arg,sljit_sw next_argw)886 static sljit_si can_cache(sljit_si arg, sljit_sw argw, sljit_si next_arg, sljit_sw next_argw)
887 {
888 sljit_sw diff;
889 if ((arg & OFFS_REG_MASK) || !(next_arg & SLJIT_MEM))
890 return 0;
891
892 if (!(arg & REG_MASK)) {
893 diff = argw - next_argw;
894 if (diff <= 0xfff && diff >= -0xfff)
895 return 1;
896 return 0;
897 }
898
899 if (argw == next_argw)
900 return 1;
901
902 diff = argw - next_argw;
903 if (arg == next_arg && diff <= 0xfff && diff >= -0xfff)
904 return 1;
905
906 return 0;
907 }
908
909 /* Emit the necessary instructions. See can_cache above. */
getput_arg(struct sljit_compiler * compiler,sljit_si flags,sljit_si reg,sljit_si arg,sljit_sw argw,sljit_si next_arg,sljit_sw next_argw)910 static sljit_si getput_arg(struct sljit_compiler *compiler, sljit_si flags, sljit_si reg,
911 sljit_si arg, sljit_sw argw, sljit_si next_arg, sljit_sw next_argw)
912 {
913 sljit_ui shift = MEM_SIZE_SHIFT(flags);
914 sljit_si tmp_r, other_r;
915 sljit_sw diff;
916
917 SLJIT_ASSERT(arg & SLJIT_MEM);
918 if (!(next_arg & SLJIT_MEM)) {
919 next_arg = 0;
920 next_argw = 0;
921 }
922
923 tmp_r = (flags & STORE) ? TMP_REG3 : reg;
924
925 if (SLJIT_UNLIKELY((flags & UPDATE) && (arg & REG_MASK))) {
926 /* Update only applies if a base register exists. */
927 other_r = OFFS_REG(arg);
928 if (!other_r) {
929 other_r = arg & REG_MASK;
930 if (other_r != reg && argw >= 0 && argw <= 0xffffff) {
931 if ((argw & 0xfff) != 0)
932 FAIL_IF(push_inst(compiler, ADDI | RD(other_r) | RN(other_r) | ((argw & 0xfff) << 10)));
933 if (argw >> 12)
934 FAIL_IF(push_inst(compiler, ADDI | (1 << 22) | RD(other_r) | RN(other_r) | ((argw >> 12) << 10)));
935 return push_inst(compiler, sljit_mem_imm[flags & 0x3] | (shift << 30) | RT(reg) | RN(other_r));
936 }
937 else if (other_r != reg && argw < 0 && argw >= -0xffffff) {
938 argw = -argw;
939 if ((argw & 0xfff) != 0)
940 FAIL_IF(push_inst(compiler, SUBI | RD(other_r) | RN(other_r) | ((argw & 0xfff) << 10)));
941 if (argw >> 12)
942 FAIL_IF(push_inst(compiler, SUBI | (1 << 22) | RD(other_r) | RN(other_r) | ((argw >> 12) << 10)));
943 return push_inst(compiler, sljit_mem_imm[flags & 0x3] | (shift << 30) | RT(reg) | RN(other_r));
944 }
945
946 if (compiler->cache_arg == SLJIT_MEM) {
947 if (argw == compiler->cache_argw) {
948 other_r = TMP_REG3;
949 argw = 0;
950 }
951 else if (emit_set_delta(compiler, TMP_REG3, TMP_REG3, argw - compiler->cache_argw) != SLJIT_ERR_UNSUPPORTED) {
952 FAIL_IF(compiler->error);
953 compiler->cache_argw = argw;
954 other_r = TMP_REG3;
955 argw = 0;
956 }
957 }
958
959 if (argw) {
960 FAIL_IF(load_immediate(compiler, TMP_REG3, argw));
961 compiler->cache_arg = SLJIT_MEM;
962 compiler->cache_argw = argw;
963 other_r = TMP_REG3;
964 argw = 0;
965 }
966 }
967
968 /* No caching here. */
969 arg &= REG_MASK;
970 argw &= 0x3;
971 if (!argw || argw == shift) {
972 FAIL_IF(push_inst(compiler, sljit_mem_reg[flags & 0x3] | (shift << 30) | RT(reg) | RN(arg) | RM(other_r) | (argw ? (1 << 12) : 0)));
973 return push_inst(compiler, ADD | RD(arg) | RN(arg) | RM(other_r) | (argw << 10));
974 }
975 if (arg != reg) {
976 FAIL_IF(push_inst(compiler, ADD | RD(arg) | RN(arg) | RM(other_r) | (argw << 10)));
977 return push_inst(compiler, sljit_mem_imm[flags & 0x3] | (shift << 30) | RT(reg) | RN(arg));
978 }
979 FAIL_IF(push_inst(compiler, ADD | RD(TMP_REG4) | RN(arg) | RM(other_r) | (argw << 10)));
980 FAIL_IF(push_inst(compiler, sljit_mem_imm[flags & 0x3] | (shift << 30) | RT(reg) | RN(TMP_REG4)));
981 return push_inst(compiler, ORR | RD(arg) | RN(TMP_ZERO) | RM(TMP_REG4));
982 }
983
984 if (arg & OFFS_REG_MASK) {
985 other_r = OFFS_REG(arg);
986 arg &= REG_MASK;
987 FAIL_IF(push_inst(compiler, ADD | RD(tmp_r) | RN(arg) | RM(other_r) | ((argw & 0x3) << 10)));
988 return push_inst(compiler, sljit_mem_imm[flags & 0x3] | (shift << 30) | RT(reg) | RN(tmp_r));
989 }
990
991 if (compiler->cache_arg == arg) {
992 diff = argw - compiler->cache_argw;
993 if (diff <= 255 && diff >= -256)
994 return push_inst(compiler, sljit_mem_simm[flags & 0x3] | (shift << 30)
995 | RT(reg) | RN(TMP_REG3) | ((diff & 0x1ff) << 12));
996 if (emit_set_delta(compiler, TMP_REG3, TMP_REG3, diff) != SLJIT_ERR_UNSUPPORTED) {
997 FAIL_IF(compiler->error);
998 return push_inst(compiler, sljit_mem_imm[flags & 0x3] | (shift << 30) | RT(reg) | RN(arg));
999 }
1000 }
1001
1002 if (argw >= 0 && argw <= 0xffffff && (argw & ((1 << shift) - 1)) == 0) {
1003 FAIL_IF(push_inst(compiler, ADDI | (1 << 22) | RD(tmp_r) | RN(arg & REG_MASK) | ((argw >> 12) << 10)));
1004 return push_inst(compiler, sljit_mem_imm[flags & 0x3] | (shift << 30)
1005 | RT(reg) | RN(tmp_r) | ((argw & 0xfff) << (10 - shift)));
1006 }
1007
1008 diff = argw - next_argw;
1009 next_arg = (arg & REG_MASK) && (arg == next_arg) && diff <= 0xfff && diff >= -0xfff && diff != 0;
1010 arg &= REG_MASK;
1011
1012 if (arg && compiler->cache_arg == SLJIT_MEM) {
1013 if (compiler->cache_argw == argw)
1014 return push_inst(compiler, sljit_mem_reg[flags & 0x3] | (shift << 30) | RT(reg) | RN(arg) | RM(TMP_REG3));
1015 if (emit_set_delta(compiler, TMP_REG3, TMP_REG3, argw - compiler->cache_argw) != SLJIT_ERR_UNSUPPORTED) {
1016 FAIL_IF(compiler->error);
1017 compiler->cache_argw = argw;
1018 return push_inst(compiler, sljit_mem_reg[flags & 0x3] | (shift << 30) | RT(reg) | RN(arg) | RM(TMP_REG3));
1019 }
1020 }
1021
1022 compiler->cache_argw = argw;
1023 if (next_arg && emit_set_delta(compiler, TMP_REG3, arg, argw) != SLJIT_ERR_UNSUPPORTED) {
1024 FAIL_IF(compiler->error);
1025 compiler->cache_arg = SLJIT_MEM | arg;
1026 arg = 0;
1027 }
1028 else {
1029 FAIL_IF(load_immediate(compiler, TMP_REG3, argw));
1030 compiler->cache_arg = SLJIT_MEM;
1031
1032 if (next_arg) {
1033 FAIL_IF(push_inst(compiler, ADD | RD(TMP_REG3) | RN(TMP_REG3) | RM(arg)));
1034 compiler->cache_arg = SLJIT_MEM | arg;
1035 arg = 0;
1036 }
1037 }
1038
1039 if (arg)
1040 return push_inst(compiler, sljit_mem_reg[flags & 0x3] | (shift << 30) | RT(reg) | RN(arg) | RM(TMP_REG3));
1041 return push_inst(compiler, sljit_mem_imm[flags & 0x3] | (shift << 30) | RT(reg) | RN(TMP_REG3));
1042 }
1043
emit_op_mem(struct sljit_compiler * compiler,sljit_si flags,sljit_si reg,sljit_si arg,sljit_sw argw)1044 static SLJIT_INLINE sljit_si emit_op_mem(struct sljit_compiler *compiler, sljit_si flags, sljit_si reg, sljit_si arg, sljit_sw argw)
1045 {
1046 if (getput_arg_fast(compiler, flags, reg, arg, argw))
1047 return compiler->error;
1048 compiler->cache_arg = 0;
1049 compiler->cache_argw = 0;
1050 return getput_arg(compiler, flags, reg, arg, argw, 0, 0);
1051 }
1052
emit_op_mem2(struct sljit_compiler * compiler,sljit_si flags,sljit_si reg,sljit_si arg1,sljit_sw arg1w,sljit_si arg2,sljit_sw arg2w)1053 static SLJIT_INLINE sljit_si emit_op_mem2(struct sljit_compiler *compiler, sljit_si flags, sljit_si reg, sljit_si arg1, sljit_sw arg1w, sljit_si arg2, sljit_sw arg2w)
1054 {
1055 if (getput_arg_fast(compiler, flags, reg, arg1, arg1w))
1056 return compiler->error;
1057 return getput_arg(compiler, flags, reg, arg1, arg1w, arg2, arg2w);
1058 }
1059
1060 /* --------------------------------------------------------------------- */
1061 /* Entry, exit */
1062 /* --------------------------------------------------------------------- */
1063
sljit_emit_enter(struct sljit_compiler * compiler,sljit_si options,sljit_si args,sljit_si scratches,sljit_si saveds,sljit_si fscratches,sljit_si fsaveds,sljit_si local_size)1064 SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_enter(struct sljit_compiler *compiler,
1065 sljit_si options, sljit_si args, sljit_si scratches, sljit_si saveds,
1066 sljit_si fscratches, sljit_si fsaveds, sljit_si local_size)
1067 {
1068 sljit_si i, tmp, offs, prev;
1069
1070 CHECK_ERROR();
1071 check_sljit_emit_enter(compiler, options, args, scratches, saveds, fscratches, fsaveds, local_size);
1072
1073 compiler->options = options;
1074 compiler->scratches = scratches;
1075 compiler->saveds = saveds;
1076 compiler->fscratches = fscratches;
1077 compiler->fsaveds = fsaveds;
1078 #if (defined SLJIT_DEBUG && SLJIT_DEBUG)
1079 compiler->logical_local_size = local_size;
1080 #endif
1081 compiler->locals_offset = GET_SAVED_REGISTERS_SIZE(scratches, saveds, 2);
1082 local_size = (compiler->locals_offset + local_size + 15) & ~15;
1083 compiler->local_size = local_size;
1084
1085 if (local_size <= (64 << 3))
1086 FAIL_IF(push_inst(compiler, STP_PRE | 29 | RT2(TMP_LR)
1087 | RN(TMP_SP) | ((-(local_size >> 3) & 0x7f) << 15)));
1088 else {
1089 local_size -= (64 << 3);
1090 if (local_size > 0xfff) {
1091 FAIL_IF(push_inst(compiler, SUBI | RD(TMP_SP) | RN(TMP_SP) | ((local_size >> 12) << 10) | (1 << 22)));
1092 local_size &= 0xfff;
1093 }
1094 if (local_size)
1095 FAIL_IF(push_inst(compiler, SUBI | RD(TMP_SP) | RN(TMP_SP) | (local_size << 10)));
1096 FAIL_IF(push_inst(compiler, STP_PRE | 29 | RT2(TMP_LR) | RN(TMP_SP) | (0x40 << 15)));
1097 }
1098
1099 FAIL_IF(push_inst(compiler, ADDI | RD(SLJIT_SP) | RN(TMP_SP)));
1100
1101 tmp = saveds < SLJIT_NUMBER_OF_SAVED_REGISTERS ? (SLJIT_S0 + 1 - saveds) : SLJIT_FIRST_SAVED_REG;
1102 offs = 2 << 15;
1103 prev = -1;
1104 for (i = SLJIT_S0; i >= tmp; i--) {
1105 if (prev == -1) {
1106 prev = i;
1107 continue;
1108 }
1109 FAIL_IF(push_inst(compiler, STP | RT(prev) | RT2(i) | RN(TMP_SP) | offs));
1110 offs += 2 << 15;
1111 prev = -1;
1112 }
1113
1114 for (i = scratches; i >= SLJIT_FIRST_SAVED_REG; i--) {
1115 if (prev == -1) {
1116 prev = i;
1117 continue;
1118 }
1119 FAIL_IF(push_inst(compiler, STP | RT(prev) | RT2(i) | RN(TMP_SP) | offs));
1120 offs += 2 << 15;
1121 prev = -1;
1122 }
1123
1124 if (prev != -1)
1125 FAIL_IF(push_inst(compiler, STRI | RT(prev) | RN(TMP_SP) | (offs >> 5)));
1126
1127 if (args >= 1)
1128 FAIL_IF(push_inst(compiler, ORR | RD(SLJIT_S0) | RN(TMP_ZERO) | RM(SLJIT_R0)));
1129 if (args >= 2)
1130 FAIL_IF(push_inst(compiler, ORR | RD(SLJIT_S1) | RN(TMP_ZERO) | RM(SLJIT_R1)));
1131 if (args >= 3)
1132 FAIL_IF(push_inst(compiler, ORR | RD(SLJIT_S2) | RN(TMP_ZERO) | RM(SLJIT_R2)));
1133
1134 return SLJIT_SUCCESS;
1135 }
1136
sljit_set_context(struct sljit_compiler * compiler,sljit_si options,sljit_si args,sljit_si scratches,sljit_si saveds,sljit_si fscratches,sljit_si fsaveds,sljit_si local_size)1137 SLJIT_API_FUNC_ATTRIBUTE void sljit_set_context(struct sljit_compiler *compiler,
1138 sljit_si options, sljit_si args, sljit_si scratches, sljit_si saveds,
1139 sljit_si fscratches, sljit_si fsaveds, sljit_si local_size)
1140 {
1141 CHECK_ERROR_VOID();
1142 check_sljit_set_context(compiler, options, args, scratches, saveds, fscratches, fsaveds, local_size);
1143
1144 compiler->options = options;
1145 compiler->scratches = scratches;
1146 compiler->saveds = saveds;
1147 compiler->fscratches = fscratches;
1148 compiler->fsaveds = fsaveds;
1149 #if (defined SLJIT_DEBUG && SLJIT_DEBUG)
1150 compiler->logical_local_size = local_size;
1151 #endif
1152 compiler->locals_offset = GET_SAVED_REGISTERS_SIZE(scratches, saveds, 2);
1153 compiler->local_size = (compiler->locals_offset + local_size + 15) & ~15;
1154 }
1155
sljit_emit_return(struct sljit_compiler * compiler,sljit_si op,sljit_si src,sljit_sw srcw)1156 SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_return(struct sljit_compiler *compiler, sljit_si op, sljit_si src, sljit_sw srcw)
1157 {
1158 sljit_si local_size;
1159 sljit_si i, tmp, offs, prev;
1160
1161 CHECK_ERROR();
1162 check_sljit_emit_return(compiler, op, src, srcw);
1163
1164 FAIL_IF(emit_mov_before_return(compiler, op, src, srcw));
1165
1166 tmp = compiler->saveds < SLJIT_NUMBER_OF_SAVED_REGISTERS ? (SLJIT_S0 + 1 - compiler->saveds) : SLJIT_FIRST_SAVED_REG;
1167 offs = 2 << 15;
1168 prev = -1;
1169 for (i = SLJIT_S0; i >= tmp; i--) {
1170 if (prev == -1) {
1171 prev = i;
1172 continue;
1173 }
1174 FAIL_IF(push_inst(compiler, LDP | RT(prev) | RT2(i) | RN(TMP_SP) | offs));
1175 offs += 2 << 15;
1176 prev = -1;
1177 }
1178
1179 for (i = compiler->scratches; i >= SLJIT_FIRST_SAVED_REG; i--) {
1180 if (prev == -1) {
1181 prev = i;
1182 continue;
1183 }
1184 FAIL_IF(push_inst(compiler, LDP | RT(prev) | RT2(i) | RN(TMP_SP) | offs));
1185 offs += 2 << 15;
1186 prev = -1;
1187 }
1188
1189 if (prev != -1)
1190 FAIL_IF(push_inst(compiler, LDRI | RT(prev) | RN(TMP_SP) | (offs >> 5)));
1191
1192 local_size = compiler->local_size;
1193
1194 if (local_size <= (62 << 3))
1195 FAIL_IF(push_inst(compiler, LDP_PST | 29 | RT2(TMP_LR)
1196 | RN(TMP_SP) | (((local_size >> 3) & 0x7f) << 15)));
1197 else {
1198 FAIL_IF(push_inst(compiler, LDP_PST | 29 | RT2(TMP_LR) | RN(TMP_SP) | (0x3e << 15)));
1199 local_size -= (62 << 3);
1200 if (local_size > 0xfff) {
1201 FAIL_IF(push_inst(compiler, ADDI | RD(TMP_SP) | RN(TMP_SP) | ((local_size >> 12) << 10) | (1 << 22)));
1202 local_size &= 0xfff;
1203 }
1204 if (local_size)
1205 FAIL_IF(push_inst(compiler, ADDI | RD(TMP_SP) | RN(TMP_SP) | (local_size << 10)));
1206 }
1207
1208 FAIL_IF(push_inst(compiler, RET | RN(TMP_LR)));
1209 return SLJIT_SUCCESS;
1210 }
1211
1212 /* --------------------------------------------------------------------- */
1213 /* Operators */
1214 /* --------------------------------------------------------------------- */
1215
sljit_emit_op0(struct sljit_compiler * compiler,sljit_si op)1216 SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_op0(struct sljit_compiler *compiler, sljit_si op)
1217 {
1218 sljit_ins inv_bits = (op & SLJIT_INT_OP) ? (1 << 31) : 0;
1219
1220 CHECK_ERROR();
1221 check_sljit_emit_op0(compiler, op);
1222
1223 op = GET_OPCODE(op);
1224 switch (op) {
1225 case SLJIT_BREAKPOINT:
1226 return push_inst(compiler, BRK);
1227 case SLJIT_NOP:
1228 return push_inst(compiler, NOP);
1229 case SLJIT_UMUL:
1230 case SLJIT_SMUL:
1231 FAIL_IF(push_inst(compiler, ORR | RD(TMP_REG1) | RN(TMP_ZERO) | RM(SLJIT_R0)));
1232 FAIL_IF(push_inst(compiler, MADD | RD(SLJIT_R0) | RN(SLJIT_R0) | RM(SLJIT_R1) | RT2(TMP_ZERO)));
1233 return push_inst(compiler, (op == SLJIT_SMUL ? SMULH : UMULH) | RD(SLJIT_R1) | RN(TMP_REG1) | RM(SLJIT_R1));
1234 case SLJIT_UDIV:
1235 case SLJIT_SDIV:
1236 FAIL_IF(push_inst(compiler, (ORR ^ inv_bits) | RD(TMP_REG1) | RN(TMP_ZERO) | RM(SLJIT_R0)));
1237 FAIL_IF(push_inst(compiler, ((op == SLJIT_SDIV ? SDIV : UDIV) ^ inv_bits) | RD(SLJIT_R0) | RN(SLJIT_R0) | RM(SLJIT_R1)));
1238 FAIL_IF(push_inst(compiler, (MADD ^ inv_bits) | RD(SLJIT_R1) | RN(SLJIT_R0) | RM(SLJIT_R1) | RT2(TMP_ZERO)));
1239 return push_inst(compiler, (SUB ^ inv_bits) | RD(SLJIT_R1) | RN(TMP_REG1) | RM(SLJIT_R1));
1240 }
1241
1242 return SLJIT_SUCCESS;
1243 }
1244
sljit_emit_op1(struct sljit_compiler * compiler,sljit_si op,sljit_si dst,sljit_sw dstw,sljit_si src,sljit_sw srcw)1245 SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_op1(struct sljit_compiler *compiler, sljit_si op,
1246 sljit_si dst, sljit_sw dstw,
1247 sljit_si src, sljit_sw srcw)
1248 {
1249 sljit_si dst_r, flags, mem_flags;
1250 sljit_si op_flags = GET_ALL_FLAGS(op);
1251
1252 CHECK_ERROR();
1253 check_sljit_emit_op1(compiler, op, dst, dstw, src, srcw);
1254 ADJUST_LOCAL_OFFSET(dst, dstw);
1255 ADJUST_LOCAL_OFFSET(src, srcw);
1256
1257 compiler->cache_arg = 0;
1258 compiler->cache_argw = 0;
1259
1260 dst_r = SLOW_IS_REG(dst) ? dst : TMP_REG1;
1261
1262 op = GET_OPCODE(op);
1263 if (op >= SLJIT_MOV && op <= SLJIT_MOVU_P) {
1264 switch (op) {
1265 case SLJIT_MOV:
1266 case SLJIT_MOV_P:
1267 flags = WORD_SIZE;
1268 break;
1269 case SLJIT_MOV_UB:
1270 flags = BYTE_SIZE;
1271 if (src & SLJIT_IMM)
1272 srcw = (sljit_ub)srcw;
1273 break;
1274 case SLJIT_MOV_SB:
1275 flags = BYTE_SIZE | SIGNED;
1276 if (src & SLJIT_IMM)
1277 srcw = (sljit_sb)srcw;
1278 break;
1279 case SLJIT_MOV_UH:
1280 flags = HALF_SIZE;
1281 if (src & SLJIT_IMM)
1282 srcw = (sljit_uh)srcw;
1283 break;
1284 case SLJIT_MOV_SH:
1285 flags = HALF_SIZE | SIGNED;
1286 if (src & SLJIT_IMM)
1287 srcw = (sljit_sh)srcw;
1288 break;
1289 case SLJIT_MOV_UI:
1290 flags = INT_SIZE;
1291 if (src & SLJIT_IMM)
1292 srcw = (sljit_ui)srcw;
1293 break;
1294 case SLJIT_MOV_SI:
1295 flags = INT_SIZE | SIGNED;
1296 if (src & SLJIT_IMM)
1297 srcw = (sljit_si)srcw;
1298 break;
1299 case SLJIT_MOVU:
1300 case SLJIT_MOVU_P:
1301 flags = WORD_SIZE | UPDATE;
1302 break;
1303 case SLJIT_MOVU_UB:
1304 flags = BYTE_SIZE | UPDATE;
1305 if (src & SLJIT_IMM)
1306 srcw = (sljit_ub)srcw;
1307 break;
1308 case SLJIT_MOVU_SB:
1309 flags = BYTE_SIZE | SIGNED | UPDATE;
1310 if (src & SLJIT_IMM)
1311 srcw = (sljit_sb)srcw;
1312 break;
1313 case SLJIT_MOVU_UH:
1314 flags = HALF_SIZE | UPDATE;
1315 if (src & SLJIT_IMM)
1316 srcw = (sljit_uh)srcw;
1317 break;
1318 case SLJIT_MOVU_SH:
1319 flags = HALF_SIZE | SIGNED | UPDATE;
1320 if (src & SLJIT_IMM)
1321 srcw = (sljit_sh)srcw;
1322 break;
1323 case SLJIT_MOVU_UI:
1324 flags = INT_SIZE | UPDATE;
1325 if (src & SLJIT_IMM)
1326 srcw = (sljit_ui)srcw;
1327 break;
1328 case SLJIT_MOVU_SI:
1329 flags = INT_SIZE | SIGNED | UPDATE;
1330 if (src & SLJIT_IMM)
1331 srcw = (sljit_si)srcw;
1332 break;
1333 default:
1334 SLJIT_ASSERT_STOP();
1335 flags = 0;
1336 break;
1337 }
1338
1339 if (src & SLJIT_IMM)
1340 FAIL_IF(emit_op_imm(compiler, SLJIT_MOV | ARG2_IMM, dst_r, TMP_REG1, srcw));
1341 else if (src & SLJIT_MEM) {
1342 if (getput_arg_fast(compiler, flags, dst_r, src, srcw))
1343 FAIL_IF(compiler->error);
1344 else
1345 FAIL_IF(getput_arg(compiler, flags, dst_r, src, srcw, dst, dstw));
1346 } else {
1347 if (dst_r != TMP_REG1)
1348 return emit_op_imm(compiler, op | ((op_flags & SLJIT_INT_OP) ? INT_OP : 0), dst_r, TMP_REG1, src);
1349 dst_r = src;
1350 }
1351
1352 if (dst & SLJIT_MEM) {
1353 if (getput_arg_fast(compiler, flags | STORE, dst_r, dst, dstw))
1354 return compiler->error;
1355 else
1356 return getput_arg(compiler, flags | STORE, dst_r, dst, dstw, 0, 0);
1357 }
1358 return SLJIT_SUCCESS;
1359 }
1360
1361 flags = GET_FLAGS(op_flags) ? SET_FLAGS : 0;
1362 mem_flags = WORD_SIZE;
1363 if (op_flags & SLJIT_INT_OP) {
1364 flags |= INT_OP;
1365 mem_flags = INT_SIZE;
1366 }
1367
1368 if (dst == SLJIT_UNUSED)
1369 flags |= UNUSED_RETURN;
1370
1371 if (src & SLJIT_MEM) {
1372 if (getput_arg_fast(compiler, mem_flags, TMP_REG2, src, srcw))
1373 FAIL_IF(compiler->error);
1374 else
1375 FAIL_IF(getput_arg(compiler, mem_flags, TMP_REG2, src, srcw, dst, dstw));
1376 src = TMP_REG2;
1377 }
1378
1379 if (src & SLJIT_IMM) {
1380 flags |= ARG2_IMM;
1381 if (op_flags & SLJIT_INT_OP)
1382 srcw = (sljit_si)srcw;
1383 } else
1384 srcw = src;
1385
1386 emit_op_imm(compiler, flags | op, dst_r, TMP_REG1, srcw);
1387
1388 if (dst & SLJIT_MEM) {
1389 if (getput_arg_fast(compiler, mem_flags | STORE, dst_r, dst, dstw))
1390 return compiler->error;
1391 else
1392 return getput_arg(compiler, mem_flags | STORE, dst_r, dst, dstw, 0, 0);
1393 }
1394 return SLJIT_SUCCESS;
1395 }
1396
sljit_emit_op2(struct sljit_compiler * compiler,sljit_si op,sljit_si dst,sljit_sw dstw,sljit_si src1,sljit_sw src1w,sljit_si src2,sljit_sw src2w)1397 SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_op2(struct sljit_compiler *compiler, sljit_si op,
1398 sljit_si dst, sljit_sw dstw,
1399 sljit_si src1, sljit_sw src1w,
1400 sljit_si src2, sljit_sw src2w)
1401 {
1402 sljit_si dst_r, flags, mem_flags;
1403
1404 CHECK_ERROR();
1405 check_sljit_emit_op2(compiler, op, dst, dstw, src1, src1w, src2, src2w);
1406 ADJUST_LOCAL_OFFSET(dst, dstw);
1407 ADJUST_LOCAL_OFFSET(src1, src1w);
1408 ADJUST_LOCAL_OFFSET(src2, src2w);
1409
1410 compiler->cache_arg = 0;
1411 compiler->cache_argw = 0;
1412
1413 dst_r = SLOW_IS_REG(dst) ? dst : TMP_REG1;
1414 flags = GET_FLAGS(op) ? SET_FLAGS : 0;
1415 mem_flags = WORD_SIZE;
1416 if (op & SLJIT_INT_OP) {
1417 flags |= INT_OP;
1418 mem_flags = INT_SIZE;
1419 }
1420
1421 if (dst == SLJIT_UNUSED)
1422 flags |= UNUSED_RETURN;
1423
1424 if ((dst & SLJIT_MEM) && !getput_arg_fast(compiler, mem_flags | STORE | ARG_TEST, TMP_REG1, dst, dstw))
1425 flags |= SLOW_DEST;
1426
1427 if (src1 & SLJIT_MEM) {
1428 if (getput_arg_fast(compiler, mem_flags, TMP_REG1, src1, src1w))
1429 FAIL_IF(compiler->error);
1430 else
1431 flags |= SLOW_SRC1;
1432 }
1433 if (src2 & SLJIT_MEM) {
1434 if (getput_arg_fast(compiler, mem_flags, TMP_REG2, src2, src2w))
1435 FAIL_IF(compiler->error);
1436 else
1437 flags |= SLOW_SRC2;
1438 }
1439
1440 if ((flags & (SLOW_SRC1 | SLOW_SRC2)) == (SLOW_SRC1 | SLOW_SRC2)) {
1441 if (!can_cache(src1, src1w, src2, src2w) && can_cache(src1, src1w, dst, dstw)) {
1442 FAIL_IF(getput_arg(compiler, mem_flags, TMP_REG2, src2, src2w, src1, src1w));
1443 FAIL_IF(getput_arg(compiler, mem_flags, TMP_REG1, src1, src1w, dst, dstw));
1444 }
1445 else {
1446 FAIL_IF(getput_arg(compiler, mem_flags, TMP_REG1, src1, src1w, src2, src2w));
1447 FAIL_IF(getput_arg(compiler, mem_flags, TMP_REG2, src2, src2w, dst, dstw));
1448 }
1449 }
1450 else if (flags & SLOW_SRC1)
1451 FAIL_IF(getput_arg(compiler, mem_flags, TMP_REG1, src1, src1w, dst, dstw));
1452 else if (flags & SLOW_SRC2)
1453 FAIL_IF(getput_arg(compiler, mem_flags, TMP_REG2, src2, src2w, dst, dstw));
1454
1455 if (src1 & SLJIT_MEM)
1456 src1 = TMP_REG1;
1457 if (src2 & SLJIT_MEM)
1458 src2 = TMP_REG2;
1459
1460 if (src1 & SLJIT_IMM)
1461 flags |= ARG1_IMM;
1462 else
1463 src1w = src1;
1464 if (src2 & SLJIT_IMM)
1465 flags |= ARG2_IMM;
1466 else
1467 src2w = src2;
1468
1469 emit_op_imm(compiler, flags | GET_OPCODE(op), dst_r, src1w, src2w);
1470
1471 if (dst & SLJIT_MEM) {
1472 if (!(flags & SLOW_DEST)) {
1473 getput_arg_fast(compiler, mem_flags | STORE, dst_r, dst, dstw);
1474 return compiler->error;
1475 }
1476 return getput_arg(compiler, mem_flags | STORE, TMP_REG1, dst, dstw, 0, 0);
1477 }
1478
1479 return SLJIT_SUCCESS;
1480 }
1481
sljit_get_register_index(sljit_si reg)1482 SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_get_register_index(sljit_si reg)
1483 {
1484 check_sljit_get_register_index(reg);
1485 return reg_map[reg];
1486 }
1487
sljit_get_float_register_index(sljit_si reg)1488 SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_get_float_register_index(sljit_si reg)
1489 {
1490 check_sljit_get_float_register_index(reg);
1491 return reg;
1492 }
1493
sljit_emit_op_custom(struct sljit_compiler * compiler,void * instruction,sljit_si size)1494 SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_op_custom(struct sljit_compiler *compiler,
1495 void *instruction, sljit_si size)
1496 {
1497 CHECK_ERROR();
1498 check_sljit_emit_op_custom(compiler, instruction, size);
1499 SLJIT_ASSERT(size == 4);
1500
1501 return push_inst(compiler, *(sljit_ins*)instruction);
1502 }
1503
1504 /* --------------------------------------------------------------------- */
1505 /* Floating point operators */
1506 /* --------------------------------------------------------------------- */
1507
sljit_is_fpu_available(void)1508 SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_is_fpu_available(void)
1509 {
1510 #ifdef SLJIT_IS_FPU_AVAILABLE
1511 return SLJIT_IS_FPU_AVAILABLE;
1512 #else
1513 /* Available by default. */
1514 return 1;
1515 #endif
1516 }
1517
emit_fop_mem(struct sljit_compiler * compiler,sljit_si flags,sljit_si reg,sljit_si arg,sljit_sw argw)1518 static sljit_si emit_fop_mem(struct sljit_compiler *compiler, sljit_si flags, sljit_si reg, sljit_si arg, sljit_sw argw)
1519 {
1520 sljit_ui shift = MEM_SIZE_SHIFT(flags);
1521 sljit_ins ins_bits = (shift << 30);
1522 sljit_si other_r;
1523 sljit_sw diff;
1524
1525 SLJIT_ASSERT(arg & SLJIT_MEM);
1526
1527 if (!(flags & STORE))
1528 ins_bits |= 1 << 22;
1529
1530 if (arg & OFFS_REG_MASK) {
1531 argw &= 3;
1532 if (!argw || argw == shift)
1533 return push_inst(compiler, STR_FR | ins_bits | VT(reg)
1534 | RN(arg & REG_MASK) | RM(OFFS_REG(arg)) | (argw ? (1 << 12) : 0));
1535 other_r = OFFS_REG(arg);
1536 arg &= REG_MASK;
1537 FAIL_IF(push_inst(compiler, ADD | RD(TMP_REG1) | RN(arg) | RM(other_r) | (argw << 10)));
1538 arg = TMP_REG1;
1539 argw = 0;
1540 }
1541
1542 arg &= REG_MASK;
1543 if (arg && argw >= 0 && ((argw >> shift) <= 0xfff) && (argw & ((1 << shift) - 1)) == 0)
1544 return push_inst(compiler, STR_FI | ins_bits | VT(reg) | RN(arg) | (argw << (10 - shift)));
1545
1546 if (arg && argw <= 255 && argw >= -256)
1547 return push_inst(compiler, STUR_FI | ins_bits | VT(reg) | RN(arg) | ((argw & 0x1ff) << 12));
1548
1549 /* Slow cases */
1550 if (compiler->cache_arg == SLJIT_MEM && argw != compiler->cache_argw) {
1551 diff = argw - compiler->cache_argw;
1552 if (!arg && diff <= 255 && diff >= -256)
1553 return push_inst(compiler, STUR_FI | ins_bits | VT(reg) | RN(TMP_REG3) | ((diff & 0x1ff) << 12));
1554 if (emit_set_delta(compiler, TMP_REG3, TMP_REG3, argw - compiler->cache_argw) != SLJIT_ERR_UNSUPPORTED) {
1555 FAIL_IF(compiler->error);
1556 compiler->cache_argw = argw;
1557 }
1558 }
1559
1560 if (compiler->cache_arg != SLJIT_MEM || argw != compiler->cache_argw) {
1561 compiler->cache_arg = SLJIT_MEM;
1562 compiler->cache_argw = argw;
1563 FAIL_IF(load_immediate(compiler, TMP_REG3, argw));
1564 }
1565
1566 if (arg & REG_MASK)
1567 return push_inst(compiler, STR_FR | ins_bits | VT(reg) | RN(arg) | RM(TMP_REG3));
1568 return push_inst(compiler, STR_FI | ins_bits | VT(reg) | RN(TMP_REG3));
1569 }
1570
sljit_emit_fop1_convw_fromd(struct sljit_compiler * compiler,sljit_si op,sljit_si dst,sljit_sw dstw,sljit_si src,sljit_sw srcw)1571 static SLJIT_INLINE sljit_si sljit_emit_fop1_convw_fromd(struct sljit_compiler *compiler, sljit_si op,
1572 sljit_si dst, sljit_sw dstw,
1573 sljit_si src, sljit_sw srcw)
1574 {
1575 sljit_si dst_r = SLOW_IS_REG(dst) ? dst : TMP_REG1;
1576 sljit_ins inv_bits = (op & SLJIT_SINGLE_OP) ? (1 << 22) : 0;
1577
1578 if (GET_OPCODE(op) == SLJIT_CONVI_FROMD)
1579 inv_bits |= (1 << 31);
1580
1581 if (src & SLJIT_MEM) {
1582 emit_fop_mem(compiler, (op & SLJIT_SINGLE_OP) ? INT_SIZE : WORD_SIZE, TMP_FREG1, src, srcw);
1583 src = TMP_FREG1;
1584 }
1585
1586 FAIL_IF(push_inst(compiler, (FCVTZS ^ inv_bits) | RD(dst_r) | VN(src)));
1587
1588 if (dst_r == TMP_REG1 && dst != SLJIT_UNUSED)
1589 return emit_op_mem(compiler, ((GET_OPCODE(op) == SLJIT_CONVI_FROMD) ? INT_SIZE : WORD_SIZE) | STORE, TMP_REG1, dst, dstw);
1590 return SLJIT_SUCCESS;
1591 }
1592
sljit_emit_fop1_convd_fromw(struct sljit_compiler * compiler,sljit_si op,sljit_si dst,sljit_sw dstw,sljit_si src,sljit_sw srcw)1593 static SLJIT_INLINE sljit_si sljit_emit_fop1_convd_fromw(struct sljit_compiler *compiler, sljit_si op,
1594 sljit_si dst, sljit_sw dstw,
1595 sljit_si src, sljit_sw srcw)
1596 {
1597 sljit_si dst_r = FAST_IS_REG(dst) ? dst : TMP_FREG1;
1598 sljit_ins inv_bits = (op & SLJIT_SINGLE_OP) ? (1 << 22) : 0;
1599
1600 if (GET_OPCODE(op) == SLJIT_CONVD_FROMI)
1601 inv_bits |= (1 << 31);
1602
1603 if (src & SLJIT_MEM) {
1604 emit_op_mem(compiler, ((GET_OPCODE(op) == SLJIT_CONVD_FROMI) ? INT_SIZE : WORD_SIZE), TMP_REG1, src, srcw);
1605 src = TMP_REG1;
1606 } else if (src & SLJIT_IMM) {
1607 #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
1608 if (GET_OPCODE(op) == SLJIT_CONVD_FROMI)
1609 srcw = (sljit_si)srcw;
1610 #endif
1611 FAIL_IF(load_immediate(compiler, TMP_REG1, srcw));
1612 src = TMP_REG1;
1613 }
1614
1615 FAIL_IF(push_inst(compiler, (SCVTF ^ inv_bits) | VD(dst_r) | RN(src)));
1616
1617 if (dst & SLJIT_MEM)
1618 return emit_fop_mem(compiler, ((op & SLJIT_SINGLE_OP) ? INT_SIZE : WORD_SIZE) | STORE, TMP_FREG1, dst, dstw);
1619 return SLJIT_SUCCESS;
1620 }
1621
sljit_emit_fop1_cmp(struct sljit_compiler * compiler,sljit_si op,sljit_si src1,sljit_sw src1w,sljit_si src2,sljit_sw src2w)1622 static SLJIT_INLINE sljit_si sljit_emit_fop1_cmp(struct sljit_compiler *compiler, sljit_si op,
1623 sljit_si src1, sljit_sw src1w,
1624 sljit_si src2, sljit_sw src2w)
1625 {
1626 sljit_si mem_flags = (op & SLJIT_SINGLE_OP) ? INT_SIZE : WORD_SIZE;
1627 sljit_ins inv_bits = (op & SLJIT_SINGLE_OP) ? (1 << 22) : 0;
1628
1629 if (src1 & SLJIT_MEM) {
1630 emit_fop_mem(compiler, mem_flags, TMP_FREG1, src1, src1w);
1631 src1 = TMP_FREG1;
1632 }
1633
1634 if (src2 & SLJIT_MEM) {
1635 emit_fop_mem(compiler, mem_flags, TMP_FREG2, src2, src2w);
1636 src2 = TMP_FREG2;
1637 }
1638
1639 return push_inst(compiler, (FCMP ^ inv_bits) | VN(src1) | VM(src2));
1640 }
1641
sljit_emit_fop1(struct sljit_compiler * compiler,sljit_si op,sljit_si dst,sljit_sw dstw,sljit_si src,sljit_sw srcw)1642 SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_fop1(struct sljit_compiler *compiler, sljit_si op,
1643 sljit_si dst, sljit_sw dstw,
1644 sljit_si src, sljit_sw srcw)
1645 {
1646 sljit_si dst_r, mem_flags = (op & SLJIT_SINGLE_OP) ? INT_SIZE : WORD_SIZE;
1647 sljit_ins inv_bits;
1648
1649 CHECK_ERROR();
1650 compiler->cache_arg = 0;
1651 compiler->cache_argw = 0;
1652
1653 SLJIT_COMPILE_ASSERT((INT_SIZE ^ 0x100) == WORD_SIZE, must_be_one_bit_difference);
1654 SELECT_FOP1_OPERATION_WITH_CHECKS(compiler, op, dst, dstw, src, srcw);
1655
1656 inv_bits = (op & SLJIT_SINGLE_OP) ? (1 << 22) : 0;
1657 dst_r = FAST_IS_REG(dst) ? dst : TMP_FREG1;
1658
1659 if (src & SLJIT_MEM) {
1660 emit_fop_mem(compiler, (GET_OPCODE(op) == SLJIT_CONVD_FROMS) ? (mem_flags ^ 0x100) : mem_flags, dst_r, src, srcw);
1661 src = dst_r;
1662 }
1663
1664 switch (GET_OPCODE(op)) {
1665 case SLJIT_MOVD:
1666 if (src != dst_r) {
1667 if (dst_r != TMP_FREG1)
1668 FAIL_IF(push_inst(compiler, (FMOV ^ inv_bits) | VD(dst_r) | VN(src)));
1669 else
1670 dst_r = src;
1671 }
1672 break;
1673 case SLJIT_NEGD:
1674 FAIL_IF(push_inst(compiler, (FNEG ^ inv_bits) | VD(dst_r) | VN(src)));
1675 break;
1676 case SLJIT_ABSD:
1677 FAIL_IF(push_inst(compiler, (FABS ^ inv_bits) | VD(dst_r) | VN(src)));
1678 break;
1679 case SLJIT_CONVD_FROMS:
1680 FAIL_IF(push_inst(compiler, FCVT | ((op & SLJIT_SINGLE_OP) ? (1 << 22) : (1 << 15)) | VD(dst_r) | VN(src)));
1681 break;
1682 }
1683
1684 if (dst & SLJIT_MEM)
1685 return emit_fop_mem(compiler, mem_flags | STORE, dst_r, dst, dstw);
1686 return SLJIT_SUCCESS;
1687 }
1688
sljit_emit_fop2(struct sljit_compiler * compiler,sljit_si op,sljit_si dst,sljit_sw dstw,sljit_si src1,sljit_sw src1w,sljit_si src2,sljit_sw src2w)1689 SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_fop2(struct sljit_compiler *compiler, sljit_si op,
1690 sljit_si dst, sljit_sw dstw,
1691 sljit_si src1, sljit_sw src1w,
1692 sljit_si src2, sljit_sw src2w)
1693 {
1694 sljit_si dst_r, mem_flags = (op & SLJIT_SINGLE_OP) ? INT_SIZE : WORD_SIZE;
1695 sljit_ins inv_bits = (op & SLJIT_SINGLE_OP) ? (1 << 22) : 0;
1696
1697 CHECK_ERROR();
1698 check_sljit_emit_fop2(compiler, op, dst, dstw, src1, src1w, src2, src2w);
1699 ADJUST_LOCAL_OFFSET(dst, dstw);
1700 ADJUST_LOCAL_OFFSET(src1, src1w);
1701 ADJUST_LOCAL_OFFSET(src2, src2w);
1702
1703 compiler->cache_arg = 0;
1704 compiler->cache_argw = 0;
1705
1706 dst_r = FAST_IS_REG(dst) ? dst : TMP_FREG1;
1707 if (src1 & SLJIT_MEM) {
1708 emit_fop_mem(compiler, mem_flags, TMP_FREG1, src1, src1w);
1709 src1 = TMP_FREG1;
1710 }
1711 if (src2 & SLJIT_MEM) {
1712 emit_fop_mem(compiler, mem_flags, TMP_FREG2, src2, src2w);
1713 src2 = TMP_FREG2;
1714 }
1715
1716 switch (GET_OPCODE(op)) {
1717 case SLJIT_ADDD:
1718 FAIL_IF(push_inst(compiler, (FADD ^ inv_bits) | VD(dst_r) | VN(src1) | VM(src2)));
1719 break;
1720 case SLJIT_SUBD:
1721 FAIL_IF(push_inst(compiler, (FSUB ^ inv_bits) | VD(dst_r) | VN(src1) | VM(src2)));
1722 break;
1723 case SLJIT_MULD:
1724 FAIL_IF(push_inst(compiler, (FMUL ^ inv_bits) | VD(dst_r) | VN(src1) | VM(src2)));
1725 break;
1726 case SLJIT_DIVD:
1727 FAIL_IF(push_inst(compiler, (FDIV ^ inv_bits) | VD(dst_r) | VN(src1) | VM(src2)));
1728 break;
1729 }
1730
1731 if (!(dst & SLJIT_MEM))
1732 return SLJIT_SUCCESS;
1733 return emit_fop_mem(compiler, mem_flags | STORE, TMP_FREG1, dst, dstw);
1734 }
1735
1736 /* --------------------------------------------------------------------- */
1737 /* Other instructions */
1738 /* --------------------------------------------------------------------- */
1739
sljit_emit_fast_enter(struct sljit_compiler * compiler,sljit_si dst,sljit_sw dstw)1740 SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_fast_enter(struct sljit_compiler *compiler, sljit_si dst, sljit_sw dstw)
1741 {
1742 CHECK_ERROR();
1743 check_sljit_emit_fast_enter(compiler, dst, dstw);
1744 ADJUST_LOCAL_OFFSET(dst, dstw);
1745
1746 /* For UNUSED dst. Uncommon, but possible. */
1747 if (dst == SLJIT_UNUSED)
1748 return SLJIT_SUCCESS;
1749
1750 if (FAST_IS_REG(dst))
1751 return push_inst(compiler, ORR | RD(dst) | RN(TMP_ZERO) | RM(TMP_LR));
1752
1753 /* Memory. */
1754 return emit_op_mem(compiler, WORD_SIZE | STORE, TMP_LR, dst, dstw);
1755 }
1756
sljit_emit_fast_return(struct sljit_compiler * compiler,sljit_si src,sljit_sw srcw)1757 SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_fast_return(struct sljit_compiler *compiler, sljit_si src, sljit_sw srcw)
1758 {
1759 CHECK_ERROR();
1760 check_sljit_emit_fast_return(compiler, src, srcw);
1761 ADJUST_LOCAL_OFFSET(src, srcw);
1762
1763 if (FAST_IS_REG(src))
1764 FAIL_IF(push_inst(compiler, ORR | RD(TMP_LR) | RN(TMP_ZERO) | RM(src)));
1765 else if (src & SLJIT_MEM)
1766 FAIL_IF(emit_op_mem(compiler, WORD_SIZE, TMP_LR, src, srcw));
1767 else if (src & SLJIT_IMM)
1768 FAIL_IF(load_immediate(compiler, TMP_LR, srcw));
1769
1770 return push_inst(compiler, RET | RN(TMP_LR));
1771 }
1772
1773 /* --------------------------------------------------------------------- */
1774 /* Conditional instructions */
1775 /* --------------------------------------------------------------------- */
1776
get_cc(sljit_si type)1777 static sljit_uw get_cc(sljit_si type)
1778 {
1779 switch (type) {
1780 case SLJIT_C_EQUAL:
1781 case SLJIT_C_MUL_NOT_OVERFLOW:
1782 case SLJIT_C_FLOAT_EQUAL:
1783 return 0x1;
1784
1785 case SLJIT_C_NOT_EQUAL:
1786 case SLJIT_C_MUL_OVERFLOW:
1787 case SLJIT_C_FLOAT_NOT_EQUAL:
1788 return 0x0;
1789
1790 case SLJIT_C_LESS:
1791 case SLJIT_C_FLOAT_LESS:
1792 return 0x2;
1793
1794 case SLJIT_C_GREATER_EQUAL:
1795 case SLJIT_C_FLOAT_GREATER_EQUAL:
1796 return 0x3;
1797
1798 case SLJIT_C_GREATER:
1799 case SLJIT_C_FLOAT_GREATER:
1800 return 0x9;
1801
1802 case SLJIT_C_LESS_EQUAL:
1803 case SLJIT_C_FLOAT_LESS_EQUAL:
1804 return 0x8;
1805
1806 case SLJIT_C_SIG_LESS:
1807 return 0xa;
1808
1809 case SLJIT_C_SIG_GREATER_EQUAL:
1810 return 0xb;
1811
1812 case SLJIT_C_SIG_GREATER:
1813 return 0xd;
1814
1815 case SLJIT_C_SIG_LESS_EQUAL:
1816 return 0xc;
1817
1818 case SLJIT_C_OVERFLOW:
1819 case SLJIT_C_FLOAT_UNORDERED:
1820 return 0x7;
1821
1822 case SLJIT_C_NOT_OVERFLOW:
1823 case SLJIT_C_FLOAT_ORDERED:
1824 return 0x6;
1825
1826 default:
1827 SLJIT_ASSERT_STOP();
1828 return 0xe;
1829 }
1830 }
1831
sljit_emit_label(struct sljit_compiler * compiler)1832 SLJIT_API_FUNC_ATTRIBUTE struct sljit_label* sljit_emit_label(struct sljit_compiler *compiler)
1833 {
1834 struct sljit_label *label;
1835
1836 CHECK_ERROR_PTR();
1837 check_sljit_emit_label(compiler);
1838
1839 if (compiler->last_label && compiler->last_label->size == compiler->size)
1840 return compiler->last_label;
1841
1842 label = (struct sljit_label*)ensure_abuf(compiler, sizeof(struct sljit_label));
1843 PTR_FAIL_IF(!label);
1844 set_label(label, compiler);
1845 return label;
1846 }
1847
sljit_emit_jump(struct sljit_compiler * compiler,sljit_si type)1848 SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_jump(struct sljit_compiler *compiler, sljit_si type)
1849 {
1850 struct sljit_jump *jump;
1851
1852 CHECK_ERROR_PTR();
1853 check_sljit_emit_jump(compiler, type);
1854
1855 jump = (struct sljit_jump*)ensure_abuf(compiler, sizeof(struct sljit_jump));
1856 PTR_FAIL_IF(!jump);
1857 set_jump(jump, compiler, type & SLJIT_REWRITABLE_JUMP);
1858 type &= 0xff;
1859
1860 if (type < SLJIT_JUMP) {
1861 jump->flags |= IS_COND;
1862 PTR_FAIL_IF(push_inst(compiler, B_CC | (6 << 5) | get_cc(type)));
1863 }
1864 else if (type >= SLJIT_FAST_CALL)
1865 jump->flags |= IS_BL;
1866
1867 PTR_FAIL_IF(emit_imm64_const(compiler, TMP_REG1, 0));
1868 jump->addr = compiler->size;
1869 PTR_FAIL_IF(push_inst(compiler, ((type >= SLJIT_FAST_CALL) ? BLR : BR) | RN(TMP_REG1)));
1870
1871 return jump;
1872 }
1873
emit_cmp_to0(struct sljit_compiler * compiler,sljit_si type,sljit_si src,sljit_sw srcw)1874 static SLJIT_INLINE struct sljit_jump* emit_cmp_to0(struct sljit_compiler *compiler, sljit_si type,
1875 sljit_si src, sljit_sw srcw)
1876 {
1877 struct sljit_jump *jump;
1878 sljit_ins inv_bits = (type & SLJIT_INT_OP) ? (1 << 31) : 0;
1879
1880 SLJIT_ASSERT((type & 0xff) == SLJIT_C_EQUAL || (type & 0xff) == SLJIT_C_NOT_EQUAL);
1881 ADJUST_LOCAL_OFFSET(src, srcw);
1882
1883 jump = (struct sljit_jump*)ensure_abuf(compiler, sizeof(struct sljit_jump));
1884 PTR_FAIL_IF(!jump);
1885 set_jump(jump, compiler, type & SLJIT_REWRITABLE_JUMP);
1886 jump->flags |= IS_CBZ | IS_COND;
1887
1888 if (src & SLJIT_MEM) {
1889 PTR_FAIL_IF(emit_op_mem(compiler, inv_bits ? INT_SIZE : WORD_SIZE, TMP_REG1, src, srcw));
1890 src = TMP_REG1;
1891 }
1892 else if (src & SLJIT_IMM) {
1893 PTR_FAIL_IF(load_immediate(compiler, TMP_REG1, srcw));
1894 src = TMP_REG1;
1895 }
1896 SLJIT_ASSERT(FAST_IS_REG(src));
1897
1898 if ((type & 0xff) == SLJIT_C_EQUAL)
1899 inv_bits |= 1 << 24;
1900
1901 PTR_FAIL_IF(push_inst(compiler, (CBZ ^ inv_bits) | (6 << 5) | RT(src)));
1902 PTR_FAIL_IF(emit_imm64_const(compiler, TMP_REG1, 0));
1903 jump->addr = compiler->size;
1904 PTR_FAIL_IF(push_inst(compiler, BR | RN(TMP_REG1)));
1905 return jump;
1906 }
1907
sljit_emit_ijump(struct sljit_compiler * compiler,sljit_si type,sljit_si src,sljit_sw srcw)1908 SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_ijump(struct sljit_compiler *compiler, sljit_si type, sljit_si src, sljit_sw srcw)
1909 {
1910 struct sljit_jump *jump;
1911
1912 CHECK_ERROR();
1913 check_sljit_emit_ijump(compiler, type, src, srcw);
1914 ADJUST_LOCAL_OFFSET(src, srcw);
1915
1916 /* In ARM, we don't need to touch the arguments. */
1917 if (!(src & SLJIT_IMM)) {
1918 if (src & SLJIT_MEM) {
1919 FAIL_IF(emit_op_mem(compiler, WORD_SIZE, TMP_REG1, src, srcw));
1920 src = TMP_REG1;
1921 }
1922 return push_inst(compiler, ((type >= SLJIT_FAST_CALL) ? BLR : BR) | RN(src));
1923 }
1924
1925 jump = (struct sljit_jump*)ensure_abuf(compiler, sizeof(struct sljit_jump));
1926 FAIL_IF(!jump);
1927 set_jump(jump, compiler, JUMP_ADDR | ((type >= SLJIT_FAST_CALL) ? IS_BL : 0));
1928 jump->u.target = srcw;
1929
1930 FAIL_IF(emit_imm64_const(compiler, TMP_REG1, 0));
1931 jump->addr = compiler->size;
1932 return push_inst(compiler, ((type >= SLJIT_FAST_CALL) ? BLR : BR) | RN(TMP_REG1));
1933 }
1934
sljit_emit_op_flags(struct sljit_compiler * compiler,sljit_si op,sljit_si dst,sljit_sw dstw,sljit_si src,sljit_sw srcw,sljit_si type)1935 SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_op_flags(struct sljit_compiler *compiler, sljit_si op,
1936 sljit_si dst, sljit_sw dstw,
1937 sljit_si src, sljit_sw srcw,
1938 sljit_si type)
1939 {
1940 sljit_si dst_r, flags, mem_flags;
1941 sljit_ins cc;
1942
1943 CHECK_ERROR();
1944 check_sljit_emit_op_flags(compiler, op, dst, dstw, src, srcw, type);
1945 ADJUST_LOCAL_OFFSET(dst, dstw);
1946 ADJUST_LOCAL_OFFSET(src, srcw);
1947
1948 if (dst == SLJIT_UNUSED)
1949 return SLJIT_SUCCESS;
1950
1951 cc = get_cc(type);
1952 dst_r = FAST_IS_REG(dst) ? dst : TMP_REG1;
1953
1954 if (GET_OPCODE(op) < SLJIT_ADD) {
1955 FAIL_IF(push_inst(compiler, CSINC | (cc << 12) | RD(dst_r) | RN(TMP_ZERO) | RM(TMP_ZERO)));
1956 if (dst_r != TMP_REG1)
1957 return SLJIT_SUCCESS;
1958 return emit_op_mem(compiler, (GET_OPCODE(op) == SLJIT_MOV ? WORD_SIZE : INT_SIZE) | STORE, TMP_REG1, dst, dstw);
1959 }
1960
1961 compiler->cache_arg = 0;
1962 compiler->cache_argw = 0;
1963 flags = GET_FLAGS(op) ? SET_FLAGS : 0;
1964 mem_flags = WORD_SIZE;
1965 if (op & SLJIT_INT_OP) {
1966 flags |= INT_OP;
1967 mem_flags = INT_SIZE;
1968 }
1969
1970 if (src & SLJIT_MEM) {
1971 FAIL_IF(emit_op_mem2(compiler, mem_flags, TMP_REG1, src, srcw, dst, dstw));
1972 src = TMP_REG1;
1973 srcw = 0;
1974 } else if (src & SLJIT_IMM)
1975 flags |= ARG1_IMM;
1976
1977 FAIL_IF(push_inst(compiler, CSINC | (cc << 12) | RD(TMP_REG2) | RN(TMP_ZERO) | RM(TMP_ZERO)));
1978 emit_op_imm(compiler, flags | GET_OPCODE(op), dst_r, src, TMP_REG2);
1979
1980 if (dst_r != TMP_REG1)
1981 return SLJIT_SUCCESS;
1982 return emit_op_mem2(compiler, mem_flags | STORE, TMP_REG1, dst, dstw, 0, 0);
1983 }
1984
sljit_emit_const(struct sljit_compiler * compiler,sljit_si dst,sljit_sw dstw,sljit_sw init_value)1985 SLJIT_API_FUNC_ATTRIBUTE struct sljit_const* sljit_emit_const(struct sljit_compiler *compiler, sljit_si dst, sljit_sw dstw, sljit_sw init_value)
1986 {
1987 struct sljit_const *const_;
1988 sljit_si dst_r;
1989
1990 CHECK_ERROR_PTR();
1991 check_sljit_emit_const(compiler, dst, dstw, init_value);
1992 ADJUST_LOCAL_OFFSET(dst, dstw);
1993
1994 const_ = (struct sljit_const*)ensure_abuf(compiler, sizeof(struct sljit_const));
1995 PTR_FAIL_IF(!const_);
1996 set_const(const_, compiler);
1997
1998 dst_r = SLOW_IS_REG(dst) ? dst : TMP_REG1;
1999 PTR_FAIL_IF(emit_imm64_const(compiler, dst_r, init_value));
2000
2001 if (dst & SLJIT_MEM)
2002 PTR_FAIL_IF(emit_op_mem(compiler, WORD_SIZE | STORE, dst_r, dst, dstw));
2003 return const_;
2004 }
2005
sljit_set_jump_addr(sljit_uw addr,sljit_uw new_addr)2006 SLJIT_API_FUNC_ATTRIBUTE void sljit_set_jump_addr(sljit_uw addr, sljit_uw new_addr)
2007 {
2008 sljit_ins* inst = (sljit_ins*)addr;
2009 modify_imm64_const(inst, new_addr);
2010 SLJIT_CACHE_FLUSH(inst, inst + 4);
2011 }
2012
sljit_set_const(sljit_uw addr,sljit_sw new_constant)2013 SLJIT_API_FUNC_ATTRIBUTE void sljit_set_const(sljit_uw addr, sljit_sw new_constant)
2014 {
2015 sljit_ins* inst = (sljit_ins*)addr;
2016 modify_imm64_const(inst, new_constant);
2017 SLJIT_CACHE_FLUSH(inst, inst + 4);
2018 }
2019