2 * Stack-less Just-In-Time compiler
4 * Copyright 2009-2012 Zoltan Herczeg (hzmester@freemail.hu). All rights reserved.
6 * Redistribution and use in source and binary forms, with or without modification, are
7 * permitted provided that the following conditions are met:
9 * 1. Redistributions of source code must retain the above copyright notice, this list of
10 * conditions and the following disclaimer.
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.
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.
27 SLJIT_API_FUNC_ATTRIBUTE const char* sljit_get_platform_name(void)
29 return "PowerPC" SLJIT_CPUINFO;
32 /* Length of an instruction word.
33 Both for ppc-32 and ppc-64. */
34 typedef sljit_u32 sljit_ins;
36 #if ((defined SLJIT_CONFIG_PPC_32 && SLJIT_CONFIG_PPC_32) && (defined _AIX)) \
37 || (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)
38 #define SLJIT_PPC_STACK_FRAME_V2 1
42 #include <sys/cache.h>
45 #if (defined SLJIT_LITTLE_ENDIAN && SLJIT_LITTLE_ENDIAN)
46 #define SLJIT_PASS_ENTRY_ADDR_TO_CALL 1
49 #if (defined SLJIT_CACHE_FLUSH_OWN_IMPL && SLJIT_CACHE_FLUSH_OWN_IMPL)
51 static void ppc_cache_flush(sljit_ins *from, sljit_ins *to)
54 _sync_cache_range((caddr_t)from, (int)((size_t)to - (size_t)from));
55 #elif defined(__GNUC__) || (defined(__IBM_GCC_ASM) && __IBM_GCC_ASM)
56 # if defined(_ARCH_PWR) || defined(_ARCH_PWR2)
57 /* Cache flush for POWER architecture. */
66 __asm__ volatile ( "ics" );
67 # elif defined(_ARCH_COM) && !defined(_ARCH_PPC)
68 # error "Cache flush is not implemented for PowerPC/POWER common mode."
70 /* Cache flush for PowerPC architecture. */
80 __asm__ volatile ( "isync" );
83 # warning "This file may fail to compile if -qfuncsect is used"
85 #elif defined(__xlc__)
86 #error "Please enable GCC syntax for inline assembly statements with -qasm=gcc"
88 #error "This platform requires a cache flush implementation."
92 #endif /* (defined SLJIT_CACHE_FLUSH_OWN_IMPL && SLJIT_CACHE_FLUSH_OWN_IMPL) */
94 #define TMP_REG1 (SLJIT_NUMBER_OF_REGISTERS + 2)
95 #define TMP_REG2 (SLJIT_NUMBER_OF_REGISTERS + 3)
96 #define TMP_REG3 (SLJIT_NUMBER_OF_REGISTERS + 4)
97 #define TMP_ZERO (SLJIT_NUMBER_OF_REGISTERS + 5)
99 #if (defined SLJIT_PASS_ENTRY_ADDR_TO_CALL && SLJIT_PASS_ENTRY_ADDR_TO_CALL)
100 #define TMP_CALL_REG (SLJIT_NUMBER_OF_REGISTERS + 6)
102 #define TMP_CALL_REG TMP_REG2
105 #define TMP_FREG1 (0)
106 #define TMP_FREG2 (SLJIT_NUMBER_OF_FLOAT_REGISTERS + 1)
108 static const sljit_u8 reg_map[SLJIT_NUMBER_OF_REGISTERS + 7] = {
109 0, 3, 4, 5, 6, 7, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 1, 8, 9, 10, 31, 12
112 /* --------------------------------------------------------------------- */
113 /* Instrucion forms */
114 /* --------------------------------------------------------------------- */
115 #define D(d) (reg_map[d] << 21)
116 #define S(s) (reg_map[s] << 21)
117 #define A(a) (reg_map[a] << 16)
118 #define B(b) (reg_map[b] << 11)
119 #define C(c) (reg_map[c] << 6)
120 #define FD(fd) ((fd) << 21)
121 #define FS(fs) ((fs) << 21)
122 #define FA(fa) ((fa) << 16)
123 #define FB(fb) ((fb) << 11)
124 #define FC(fc) ((fc) << 6)
125 #define IMM(imm) ((imm) & 0xffff)
126 #define CRD(d) ((d) << 21)
128 /* Instruction bit sections.
129 OE and Rc flag (see ALT_SET_FLAGS). */
130 #define OERC(flags) (((flags & ALT_SET_FLAGS) >> 10) | (flags & ALT_SET_FLAGS))
131 /* Rc flag (see ALT_SET_FLAGS). */
132 #define RC(flags) ((flags & ALT_SET_FLAGS) >> 10)
133 #define HI(opcode) ((opcode) << 26)
134 #define LO(opcode) ((opcode) << 1)
136 #define ADD (HI(31) | LO(266))
137 #define ADDC (HI(31) | LO(10))
138 #define ADDE (HI(31) | LO(138))
139 #define ADDI (HI(14))
140 #define ADDIC (HI(13))
141 #define ADDIS (HI(15))
142 #define ADDME (HI(31) | LO(234))
143 #define AND (HI(31) | LO(28))
144 #define ANDI (HI(28))
145 #define ANDIS (HI(29))
148 #define BCCTR (HI(19) | LO(528) | (3 << 11))
149 #define BLR (HI(19) | LO(16) | (0x14 << 21))
150 #define CNTLZD (HI(31) | LO(58))
151 #define CNTLZW (HI(31) | LO(26))
152 #define CMP (HI(31) | LO(0))
153 #define CMPI (HI(11))
154 #define CMPL (HI(31) | LO(32))
155 #define CMPLI (HI(10))
156 #define CROR (HI(19) | LO(449))
157 #define DIVD (HI(31) | LO(489))
158 #define DIVDU (HI(31) | LO(457))
159 #define DIVW (HI(31) | LO(491))
160 #define DIVWU (HI(31) | LO(459))
161 #define EXTSB (HI(31) | LO(954))
162 #define EXTSH (HI(31) | LO(922))
163 #define EXTSW (HI(31) | LO(986))
164 #define FABS (HI(63) | LO(264))
165 #define FADD (HI(63) | LO(21))
166 #define FADDS (HI(59) | LO(21))
167 #define FCFID (HI(63) | LO(846))
168 #define FCMPU (HI(63) | LO(0))
169 #define FCTIDZ (HI(63) | LO(815))
170 #define FCTIWZ (HI(63) | LO(15))
171 #define FDIV (HI(63) | LO(18))
172 #define FDIVS (HI(59) | LO(18))
173 #define FMR (HI(63) | LO(72))
174 #define FMUL (HI(63) | LO(25))
175 #define FMULS (HI(59) | LO(25))
176 #define FNEG (HI(63) | LO(40))
177 #define FRSP (HI(63) | LO(12))
178 #define FSUB (HI(63) | LO(20))
179 #define FSUBS (HI(59) | LO(20))
180 #define LD (HI(58) | 0)
182 #define MFCR (HI(31) | LO(19))
183 #define MFLR (HI(31) | LO(339) | 0x80000)
184 #define MFXER (HI(31) | LO(339) | 0x10000)
185 #define MTCTR (HI(31) | LO(467) | 0x90000)
186 #define MTLR (HI(31) | LO(467) | 0x80000)
187 #define MTXER (HI(31) | LO(467) | 0x10000)
188 #define MULHD (HI(31) | LO(73))
189 #define MULHDU (HI(31) | LO(9))
190 #define MULHW (HI(31) | LO(75))
191 #define MULHWU (HI(31) | LO(11))
192 #define MULLD (HI(31) | LO(233))
193 #define MULLI (HI(7))
194 #define MULLW (HI(31) | LO(235))
195 #define NEG (HI(31) | LO(104))
197 #define NOR (HI(31) | LO(124))
198 #define OR (HI(31) | LO(444))
200 #define ORIS (HI(25))
201 #define RLDICL (HI(30))
202 #define RLWINM (HI(21))
203 #define SLD (HI(31) | LO(27))
204 #define SLW (HI(31) | LO(24))
205 #define SRAD (HI(31) | LO(794))
206 #define SRADI (HI(31) | LO(413 << 1))
207 #define SRAW (HI(31) | LO(792))
208 #define SRAWI (HI(31) | LO(824))
209 #define SRD (HI(31) | LO(539))
210 #define SRW (HI(31) | LO(536))
211 #define STD (HI(62) | 0)
212 #define STDU (HI(62) | 1)
213 #define STDUX (HI(31) | LO(181))
214 #define STFIWX (HI(31) | LO(983))
216 #define STWU (HI(37))
217 #define STWUX (HI(31) | LO(183))
218 #define SUBF (HI(31) | LO(40))
219 #define SUBFC (HI(31) | LO(8))
220 #define SUBFE (HI(31) | LO(136))
221 #define SUBFIC (HI(8))
222 #define XOR (HI(31) | LO(316))
223 #define XORI (HI(26))
224 #define XORIS (HI(27))
226 #define SIMM_MAX (0x7fff)
227 #define SIMM_MIN (-0x8000)
228 #define UIMM_MAX (0xffff)
230 #if (defined SLJIT_INDIRECT_CALL && SLJIT_INDIRECT_CALL)
231 SLJIT_API_FUNC_ATTRIBUTE void sljit_set_function_context(void** func_ptr, struct sljit_function_context* context, sljit_sw addr, void* func)
235 *func_ptr = (void*)context;
236 ptrs = (sljit_sw*)func;
237 context->addr = addr ? addr : ptrs[0];
238 context->r2 = ptrs[1];
239 context->r11 = ptrs[2];
243 static sljit_s32 push_inst(struct sljit_compiler *compiler, sljit_ins ins)
245 sljit_ins *ptr = (sljit_ins*)ensure_buf(compiler, sizeof(sljit_ins));
249 return SLJIT_SUCCESS;
252 static SLJIT_INLINE sljit_s32 detect_jump_type(struct sljit_jump *jump, sljit_ins *code_ptr, sljit_ins *code)
255 sljit_uw target_addr;
256 sljit_sw extra_jump_flags;
258 #if (defined SLJIT_PASS_ENTRY_ADDR_TO_CALL && SLJIT_PASS_ENTRY_ADDR_TO_CALL) && (defined SLJIT_CONFIG_PPC_32 && SLJIT_CONFIG_PPC_32)
259 if (jump->flags & (SLJIT_REWRITABLE_JUMP | IS_CALL))
262 if (jump->flags & SLJIT_REWRITABLE_JUMP)
266 if (jump->flags & JUMP_ADDR)
267 target_addr = jump->u.target;
269 SLJIT_ASSERT(jump->flags & JUMP_LABEL);
270 target_addr = (sljit_uw)(code + jump->u.label->size);
273 #if (defined SLJIT_PASS_ENTRY_ADDR_TO_CALL && SLJIT_PASS_ENTRY_ADDR_TO_CALL) && (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)
274 if (jump->flags & IS_CALL)
278 diff = ((sljit_sw)target_addr - (sljit_sw)(code_ptr)) & ~0x3l;
280 extra_jump_flags = 0;
281 if (jump->flags & IS_COND) {
282 if (diff <= 0x7fff && diff >= -0x8000) {
283 jump->flags |= PATCH_B;
286 if (target_addr <= 0xffff) {
287 jump->flags |= PATCH_B | PATCH_ABS_B;
290 extra_jump_flags = REMOVE_COND;
292 diff -= sizeof(sljit_ins);
295 if (diff <= 0x01ffffff && diff >= -0x02000000) {
296 jump->flags |= PATCH_B | extra_jump_flags;
299 if (target_addr <= 0x03ffffff) {
300 jump->flags |= PATCH_B | PATCH_ABS_B | extra_jump_flags;
304 #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)
305 #if (defined SLJIT_PASS_ENTRY_ADDR_TO_CALL && SLJIT_PASS_ENTRY_ADDR_TO_CALL)
308 if (target_addr <= 0x7fffffff) {
309 jump->flags |= PATCH_ABS32;
312 if (target_addr <= 0x7fffffffffffl) {
313 jump->flags |= PATCH_ABS48;
321 SLJIT_API_FUNC_ATTRIBUTE void* sljit_generate_code(struct sljit_compiler *compiler)
323 struct sljit_memory_fragment *buf;
331 struct sljit_label *label;
332 struct sljit_jump *jump;
333 struct sljit_const *const_;
336 CHECK_PTR(check_sljit_generate_code(compiler));
337 reverse_buf(compiler);
339 #if (defined SLJIT_INDIRECT_CALL && SLJIT_INDIRECT_CALL)
340 #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)
341 compiler->size += (compiler->size & 0x1) + (sizeof(struct sljit_function_context) / sizeof(sljit_ins));
343 compiler->size += (sizeof(struct sljit_function_context) / sizeof(sljit_ins));
346 code = (sljit_ins*)SLJIT_MALLOC_EXEC(compiler->size * sizeof(sljit_ins));
347 PTR_FAIL_WITH_EXEC_IF(code);
352 label = compiler->labels;
353 jump = compiler->jumps;
354 const_ = compiler->consts;
356 buf_ptr = (sljit_ins*)buf->memory;
357 buf_end = buf_ptr + (buf->used_size >> 2);
359 *code_ptr = *buf_ptr++;
360 SLJIT_ASSERT(!label || label->size >= word_count);
361 SLJIT_ASSERT(!jump || jump->addr >= word_count);
362 SLJIT_ASSERT(!const_ || const_->addr >= word_count);
363 /* These structures are ordered by their address. */
364 if (label && label->size == word_count) {
365 /* Just recording the address. */
366 label->addr = (sljit_uw)code_ptr;
367 label->size = code_ptr - code;
370 if (jump && jump->addr == word_count) {
371 #if (defined SLJIT_CONFIG_PPC_32 && SLJIT_CONFIG_PPC_32)
372 jump->addr = (sljit_uw)(code_ptr - 3);
374 jump->addr = (sljit_uw)(code_ptr - 6);
376 if (detect_jump_type(jump, code_ptr, code)) {
377 #if (defined SLJIT_CONFIG_PPC_32 && SLJIT_CONFIG_PPC_32)
378 code_ptr[-3] = code_ptr[0];
381 if (jump->flags & PATCH_ABS32) {
383 code_ptr[-1] = code_ptr[2];
384 code_ptr[0] = code_ptr[3];
386 else if (jump->flags & PATCH_ABS48) {
388 code_ptr[-1] = code_ptr[0];
389 code_ptr[0] = code_ptr[1];
390 /* rldicr rX,rX,32,31 -> rX,rX,16,47 */
391 SLJIT_ASSERT((code_ptr[-3] & 0xfc00ffff) == 0x780007c6);
392 code_ptr[-3] ^= 0x8422;
394 code_ptr[-2] ^= 0x4000000;
397 code_ptr[-6] = code_ptr[0];
401 if (jump->flags & REMOVE_COND) {
402 code_ptr[0] = BCx | (2 << 2) | ((code_ptr[0] ^ (8 << 21)) & 0x03ff0001);
404 jump->addr += sizeof(sljit_ins);
406 jump->flags -= IS_COND;
411 if (const_ && const_->addr == word_count) {
412 const_->addr = (sljit_uw)code_ptr;
413 const_ = const_->next;
417 } while (buf_ptr < buf_end);
422 if (label && label->size == word_count) {
423 label->addr = (sljit_uw)code_ptr;
424 label->size = code_ptr - code;
428 SLJIT_ASSERT(!label);
430 SLJIT_ASSERT(!const_);
431 #if (defined SLJIT_INDIRECT_CALL && SLJIT_INDIRECT_CALL)
432 SLJIT_ASSERT(code_ptr - code <= (sljit_sw)compiler->size - (sizeof(struct sljit_function_context) / sizeof(sljit_ins)));
434 SLJIT_ASSERT(code_ptr - code <= (sljit_sw)compiler->size);
437 jump = compiler->jumps;
440 addr = (jump->flags & JUMP_LABEL) ? jump->u.label->addr : jump->u.target;
441 buf_ptr = (sljit_ins*)jump->addr;
442 if (jump->flags & PATCH_B) {
443 if (jump->flags & IS_COND) {
444 if (!(jump->flags & PATCH_ABS_B)) {
445 addr = addr - jump->addr;
446 SLJIT_ASSERT((sljit_sw)addr <= 0x7fff && (sljit_sw)addr >= -0x8000);
447 *buf_ptr = BCx | (addr & 0xfffc) | ((*buf_ptr) & 0x03ff0001);
450 SLJIT_ASSERT(addr <= 0xffff);
451 *buf_ptr = BCx | (addr & 0xfffc) | 0x2 | ((*buf_ptr) & 0x03ff0001);
455 if (!(jump->flags & PATCH_ABS_B)) {
456 addr = addr - jump->addr;
457 SLJIT_ASSERT((sljit_sw)addr <= 0x01ffffff && (sljit_sw)addr >= -0x02000000);
458 *buf_ptr = Bx | (addr & 0x03fffffc) | ((*buf_ptr) & 0x1);
461 SLJIT_ASSERT(addr <= 0x03ffffff);
462 *buf_ptr = Bx | (addr & 0x03fffffc) | 0x2 | ((*buf_ptr) & 0x1);
467 /* Set the fields of immediate loads. */
468 #if (defined SLJIT_CONFIG_PPC_32 && SLJIT_CONFIG_PPC_32)
469 buf_ptr[0] = (buf_ptr[0] & 0xffff0000) | ((addr >> 16) & 0xffff);
470 buf_ptr[1] = (buf_ptr[1] & 0xffff0000) | (addr & 0xffff);
472 if (jump->flags & PATCH_ABS32) {
473 SLJIT_ASSERT(addr <= 0x7fffffff);
474 buf_ptr[0] = (buf_ptr[0] & 0xffff0000) | ((addr >> 16) & 0xffff);
475 buf_ptr[1] = (buf_ptr[1] & 0xffff0000) | (addr & 0xffff);
478 if (jump->flags & PATCH_ABS48) {
479 SLJIT_ASSERT(addr <= 0x7fffffffffff);
480 buf_ptr[0] = (buf_ptr[0] & 0xffff0000) | ((addr >> 32) & 0xffff);
481 buf_ptr[1] = (buf_ptr[1] & 0xffff0000) | ((addr >> 16) & 0xffff);
482 buf_ptr[3] = (buf_ptr[3] & 0xffff0000) | (addr & 0xffff);
485 buf_ptr[0] = (buf_ptr[0] & 0xffff0000) | ((addr >> 48) & 0xffff);
486 buf_ptr[1] = (buf_ptr[1] & 0xffff0000) | ((addr >> 32) & 0xffff);
487 buf_ptr[3] = (buf_ptr[3] & 0xffff0000) | ((addr >> 16) & 0xffff);
488 buf_ptr[4] = (buf_ptr[4] & 0xffff0000) | (addr & 0xffff);
494 compiler->error = SLJIT_ERR_COMPILED;
495 compiler->executable_size = (code_ptr - code) * sizeof(sljit_ins);
496 SLJIT_CACHE_FLUSH(code, code_ptr);
498 #if (defined SLJIT_INDIRECT_CALL && SLJIT_INDIRECT_CALL)
499 #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)
500 if (((sljit_sw)code_ptr) & 0x4)
502 sljit_set_function_context(NULL, (struct sljit_function_context*)code_ptr, (sljit_sw)code, (void*)sljit_generate_code);
505 sljit_set_function_context(NULL, (struct sljit_function_context*)code_ptr, (sljit_sw)code, (void*)sljit_generate_code);
513 /* --------------------------------------------------------------------- */
515 /* --------------------------------------------------------------------- */
519 /* Creates an index in data_transfer_insts array. */
520 #define LOAD_DATA 0x01
522 #define WRITE_BACK 0x04
523 #define WORD_DATA 0x00
524 #define BYTE_DATA 0x08
525 #define HALF_DATA 0x10
526 #define INT_DATA 0x18
527 #define SIGNED_DATA 0x20
528 /* Separates integer and floating point registers */
530 #define DOUBLE_DATA 0x40
532 #define MEM_MASK 0x7f
534 /* Other inp_flags. */
536 #define ARG_TEST 0x000100
537 /* Integer opertion and set flags -> requires exts on 64 bit systems. */
538 #define ALT_SIGN_EXT 0x000200
539 /* This flag affects the RC() and OERC() macros. */
540 #define ALT_SET_FLAGS 0x000400
541 #define ALT_KEEP_CACHE 0x000800
542 #define ALT_FORM1 0x010000
543 #define ALT_FORM2 0x020000
544 #define ALT_FORM3 0x040000
545 #define ALT_FORM4 0x080000
546 #define ALT_FORM5 0x100000
547 #define ALT_FORM6 0x200000
549 /* Source and destination is register. */
550 #define REG_DEST 0x000001
551 #define REG1_SOURCE 0x000002
552 #define REG2_SOURCE 0x000004
553 /* getput_arg_fast returned true. */
554 #define FAST_DEST 0x000008
555 /* Multiple instructions are required. */
556 #define SLOW_DEST 0x000010
558 ALT_SIGN_EXT 0x000200
559 ALT_SET_FLAGS 0x000400
562 ALT_FORM6 0x200000 */
564 #if (defined SLJIT_CONFIG_PPC_32 && SLJIT_CONFIG_PPC_32)
565 #include "sljitNativePPC_32.c"
567 #include "sljitNativePPC_64.c"
570 #if (defined SLJIT_CONFIG_PPC_32 && SLJIT_CONFIG_PPC_32)
571 #define STACK_STORE STW
572 #define STACK_LOAD LWZ
574 #define STACK_STORE STD
575 #define STACK_LOAD LD
578 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_enter(struct sljit_compiler *compiler,
579 sljit_s32 options, sljit_s32 args, sljit_s32 scratches, sljit_s32 saveds,
580 sljit_s32 fscratches, sljit_s32 fsaveds, sljit_s32 local_size)
582 sljit_s32 i, tmp, offs;
585 CHECK(check_sljit_emit_enter(compiler, options, args, scratches, saveds, fscratches, fsaveds, local_size));
586 set_emit_enter(compiler, options, args, scratches, saveds, fscratches, fsaveds, local_size);
588 FAIL_IF(push_inst(compiler, MFLR | D(0)));
589 offs = -(sljit_s32)(sizeof(sljit_sw));
590 FAIL_IF(push_inst(compiler, STACK_STORE | S(TMP_ZERO) | A(SLJIT_SP) | IMM(offs)));
592 tmp = saveds < SLJIT_NUMBER_OF_SAVED_REGISTERS ? (SLJIT_S0 + 1 - saveds) : SLJIT_FIRST_SAVED_REG;
593 for (i = SLJIT_S0; i >= tmp; i--) {
594 offs -= (sljit_s32)(sizeof(sljit_sw));
595 FAIL_IF(push_inst(compiler, STACK_STORE | S(i) | A(SLJIT_SP) | IMM(offs)));
598 for (i = scratches; i >= SLJIT_FIRST_SAVED_REG; i--) {
599 offs -= (sljit_s32)(sizeof(sljit_sw));
600 FAIL_IF(push_inst(compiler, STACK_STORE | S(i) | A(SLJIT_SP) | IMM(offs)));
603 SLJIT_ASSERT(offs == -(sljit_s32)GET_SAVED_REGISTERS_SIZE(compiler->scratches, compiler->saveds, 1));
605 #if (defined SLJIT_PPC_STACK_FRAME_V2 && SLJIT_PPC_STACK_FRAME_V2)
606 FAIL_IF(push_inst(compiler, STACK_STORE | S(0) | A(SLJIT_SP) | IMM(2 * sizeof(sljit_sw))));
608 FAIL_IF(push_inst(compiler, STACK_STORE | S(0) | A(SLJIT_SP) | IMM(sizeof(sljit_sw))));
611 FAIL_IF(push_inst(compiler, ADDI | D(TMP_ZERO) | A(0) | 0));
613 FAIL_IF(push_inst(compiler, OR | S(SLJIT_R0) | A(SLJIT_S0) | B(SLJIT_R0)));
615 FAIL_IF(push_inst(compiler, OR | S(SLJIT_R1) | A(SLJIT_S1) | B(SLJIT_R1)));
617 FAIL_IF(push_inst(compiler, OR | S(SLJIT_R2) | A(SLJIT_S2) | B(SLJIT_R2)));
619 local_size += GET_SAVED_REGISTERS_SIZE(scratches, saveds, 1) + SLJIT_LOCALS_OFFSET;
620 local_size = (local_size + 15) & ~0xf;
621 compiler->local_size = local_size;
623 #if (defined SLJIT_CONFIG_PPC_32 && SLJIT_CONFIG_PPC_32)
624 if (local_size <= SIMM_MAX)
625 FAIL_IF(push_inst(compiler, STWU | S(SLJIT_SP) | A(SLJIT_SP) | IMM(-local_size)));
627 FAIL_IF(load_immediate(compiler, 0, -local_size));
628 FAIL_IF(push_inst(compiler, STWUX | S(SLJIT_SP) | A(SLJIT_SP) | B(0)));
631 if (local_size <= SIMM_MAX)
632 FAIL_IF(push_inst(compiler, STDU | S(SLJIT_SP) | A(SLJIT_SP) | IMM(-local_size)));
634 FAIL_IF(load_immediate(compiler, 0, -local_size));
635 FAIL_IF(push_inst(compiler, STDUX | S(SLJIT_SP) | A(SLJIT_SP) | B(0)));
639 return SLJIT_SUCCESS;
642 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_set_context(struct sljit_compiler *compiler,
643 sljit_s32 options, sljit_s32 args, sljit_s32 scratches, sljit_s32 saveds,
644 sljit_s32 fscratches, sljit_s32 fsaveds, sljit_s32 local_size)
647 CHECK(check_sljit_set_context(compiler, options, args, scratches, saveds, fscratches, fsaveds, local_size));
648 set_set_context(compiler, options, args, scratches, saveds, fscratches, fsaveds, local_size);
650 local_size += GET_SAVED_REGISTERS_SIZE(scratches, saveds, 1) + SLJIT_LOCALS_OFFSET;
651 compiler->local_size = (local_size + 15) & ~0xf;
652 return SLJIT_SUCCESS;
655 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_return(struct sljit_compiler *compiler, sljit_s32 op, sljit_s32 src, sljit_sw srcw)
657 sljit_s32 i, tmp, offs;
660 CHECK(check_sljit_emit_return(compiler, op, src, srcw));
662 FAIL_IF(emit_mov_before_return(compiler, op, src, srcw));
664 if (compiler->local_size <= SIMM_MAX)
665 FAIL_IF(push_inst(compiler, ADDI | D(SLJIT_SP) | A(SLJIT_SP) | IMM(compiler->local_size)));
667 FAIL_IF(load_immediate(compiler, 0, compiler->local_size));
668 FAIL_IF(push_inst(compiler, ADD | D(SLJIT_SP) | A(SLJIT_SP) | B(0)));
671 #if (defined SLJIT_PPC_STACK_FRAME_V2 && SLJIT_PPC_STACK_FRAME_V2)
672 FAIL_IF(push_inst(compiler, STACK_LOAD | D(0) | A(SLJIT_SP) | IMM(2 * sizeof(sljit_sw))));
674 FAIL_IF(push_inst(compiler, STACK_LOAD | D(0) | A(SLJIT_SP) | IMM(sizeof(sljit_sw))));
677 offs = -(sljit_s32)GET_SAVED_REGISTERS_SIZE(compiler->scratches, compiler->saveds, 1);
679 tmp = compiler->scratches;
680 for (i = SLJIT_FIRST_SAVED_REG; i <= tmp; i++) {
681 FAIL_IF(push_inst(compiler, STACK_LOAD | D(i) | A(SLJIT_SP) | IMM(offs)));
682 offs += (sljit_s32)(sizeof(sljit_sw));
685 tmp = compiler->saveds < SLJIT_NUMBER_OF_SAVED_REGISTERS ? (SLJIT_S0 + 1 - compiler->saveds) : SLJIT_FIRST_SAVED_REG;
686 for (i = tmp; i <= SLJIT_S0; i++) {
687 FAIL_IF(push_inst(compiler, STACK_LOAD | D(i) | A(SLJIT_SP) | IMM(offs)));
688 offs += (sljit_s32)(sizeof(sljit_sw));
691 FAIL_IF(push_inst(compiler, STACK_LOAD | D(TMP_ZERO) | A(SLJIT_SP) | IMM(offs)));
692 SLJIT_ASSERT(offs == -(sljit_sw)(sizeof(sljit_sw)));
694 FAIL_IF(push_inst(compiler, MTLR | S(0)));
695 FAIL_IF(push_inst(compiler, BLR));
697 return SLJIT_SUCCESS;
703 /* --------------------------------------------------------------------- */
705 /* --------------------------------------------------------------------- */
707 /* i/x - immediate/indexed form
708 n/w - no write-back / write-back (1 bit)
709 s/l - store/load (1 bit)
710 u/s - signed/unsigned (1 bit)
711 w/b/h/i - word/byte/half/int allowed (2 bit)
712 It contans 32 items, but not all are different. */
714 /* 64 bit only: [reg+imm] must be aligned to 4 bytes. */
715 #define INT_ALIGNED 0x10000
716 /* 64-bit only: there is no lwau instruction. */
717 #define UPDATE_REQ 0x20000
719 #if (defined SLJIT_CONFIG_PPC_32 && SLJIT_CONFIG_PPC_32)
720 #define ARCH_32_64(a, b) a
721 #define INST_CODE_AND_DST(inst, flags, reg) \
722 ((inst) | (((flags) & MEM_MASK) <= GPR_REG ? D(reg) : FD(reg)))
724 #define ARCH_32_64(a, b) b
725 #define INST_CODE_AND_DST(inst, flags, reg) \
726 (((inst) & ~(INT_ALIGNED | UPDATE_REQ)) | (((flags) & MEM_MASK) <= GPR_REG ? D(reg) : FD(reg)))
729 static const sljit_ins data_transfer_insts[64 + 8] = {
731 /* -------- Unsigned -------- */
735 /* u w n i s */ ARCH_32_64(HI(36) /* stw */, HI(62) | INT_ALIGNED | 0x0 /* std */),
736 /* u w n i l */ ARCH_32_64(HI(32) /* lwz */, HI(58) | INT_ALIGNED | 0x0 /* ld */),
737 /* u w n x s */ ARCH_32_64(HI(31) | LO(151) /* stwx */, HI(31) | LO(149) /* stdx */),
738 /* u w n x l */ ARCH_32_64(HI(31) | LO(23) /* lwzx */, HI(31) | LO(21) /* ldx */),
740 /* u w w i s */ ARCH_32_64(HI(37) /* stwu */, HI(62) | INT_ALIGNED | 0x1 /* stdu */),
741 /* u w w i l */ ARCH_32_64(HI(33) /* lwzu */, HI(58) | INT_ALIGNED | 0x1 /* ldu */),
742 /* u w w x s */ ARCH_32_64(HI(31) | LO(183) /* stwux */, HI(31) | LO(181) /* stdux */),
743 /* u w w x l */ ARCH_32_64(HI(31) | LO(55) /* lwzux */, HI(31) | LO(53) /* ldux */),
747 /* u b n i s */ HI(38) /* stb */,
748 /* u b n i l */ HI(34) /* lbz */,
749 /* u b n x s */ HI(31) | LO(215) /* stbx */,
750 /* u b n x l */ HI(31) | LO(87) /* lbzx */,
752 /* u b w i s */ HI(39) /* stbu */,
753 /* u b w i l */ HI(35) /* lbzu */,
754 /* u b w x s */ HI(31) | LO(247) /* stbux */,
755 /* u b w x l */ HI(31) | LO(119) /* lbzux */,
759 /* u h n i s */ HI(44) /* sth */,
760 /* u h n i l */ HI(40) /* lhz */,
761 /* u h n x s */ HI(31) | LO(407) /* sthx */,
762 /* u h n x l */ HI(31) | LO(279) /* lhzx */,
764 /* u h w i s */ HI(45) /* sthu */,
765 /* u h w i l */ HI(41) /* lhzu */,
766 /* u h w x s */ HI(31) | LO(439) /* sthux */,
767 /* u h w x l */ HI(31) | LO(311) /* lhzux */,
771 /* u i n i s */ HI(36) /* stw */,
772 /* u i n i l */ HI(32) /* lwz */,
773 /* u i n x s */ HI(31) | LO(151) /* stwx */,
774 /* u i n x l */ HI(31) | LO(23) /* lwzx */,
776 /* u i w i s */ HI(37) /* stwu */,
777 /* u i w i l */ HI(33) /* lwzu */,
778 /* u i w x s */ HI(31) | LO(183) /* stwux */,
779 /* u i w x l */ HI(31) | LO(55) /* lwzux */,
781 /* -------- Signed -------- */
785 /* s w n i s */ ARCH_32_64(HI(36) /* stw */, HI(62) | INT_ALIGNED | 0x0 /* std */),
786 /* s w n i l */ ARCH_32_64(HI(32) /* lwz */, HI(58) | INT_ALIGNED | 0x0 /* ld */),
787 /* s w n x s */ ARCH_32_64(HI(31) | LO(151) /* stwx */, HI(31) | LO(149) /* stdx */),
788 /* s w n x l */ ARCH_32_64(HI(31) | LO(23) /* lwzx */, HI(31) | LO(21) /* ldx */),
790 /* s w w i s */ ARCH_32_64(HI(37) /* stwu */, HI(62) | INT_ALIGNED | 0x1 /* stdu */),
791 /* s w w i l */ ARCH_32_64(HI(33) /* lwzu */, HI(58) | INT_ALIGNED | 0x1 /* ldu */),
792 /* s w w x s */ ARCH_32_64(HI(31) | LO(183) /* stwux */, HI(31) | LO(181) /* stdux */),
793 /* s w w x l */ ARCH_32_64(HI(31) | LO(55) /* lwzux */, HI(31) | LO(53) /* ldux */),
797 /* s b n i s */ HI(38) /* stb */,
798 /* s b n i l */ HI(34) /* lbz */ /* EXTS_REQ */,
799 /* s b n x s */ HI(31) | LO(215) /* stbx */,
800 /* s b n x l */ HI(31) | LO(87) /* lbzx */ /* EXTS_REQ */,
802 /* s b w i s */ HI(39) /* stbu */,
803 /* s b w i l */ HI(35) /* lbzu */ /* EXTS_REQ */,
804 /* s b w x s */ HI(31) | LO(247) /* stbux */,
805 /* s b w x l */ HI(31) | LO(119) /* lbzux */ /* EXTS_REQ */,
809 /* s h n i s */ HI(44) /* sth */,
810 /* s h n i l */ HI(42) /* lha */,
811 /* s h n x s */ HI(31) | LO(407) /* sthx */,
812 /* s h n x l */ HI(31) | LO(343) /* lhax */,
814 /* s h w i s */ HI(45) /* sthu */,
815 /* s h w i l */ HI(43) /* lhau */,
816 /* s h w x s */ HI(31) | LO(439) /* sthux */,
817 /* s h w x l */ HI(31) | LO(375) /* lhaux */,
821 /* s i n i s */ HI(36) /* stw */,
822 /* s i n i l */ ARCH_32_64(HI(32) /* lwz */, HI(58) | INT_ALIGNED | 0x2 /* lwa */),
823 /* s i n x s */ HI(31) | LO(151) /* stwx */,
824 /* s i n x l */ ARCH_32_64(HI(31) | LO(23) /* lwzx */, HI(31) | LO(341) /* lwax */),
826 /* s i w i s */ HI(37) /* stwu */,
827 /* s i w i l */ ARCH_32_64(HI(33) /* lwzu */, HI(58) | INT_ALIGNED | UPDATE_REQ | 0x2 /* lwa */),
828 /* s i w x s */ HI(31) | LO(183) /* stwux */,
829 /* s i w x l */ ARCH_32_64(HI(31) | LO(55) /* lwzux */, HI(31) | LO(373) /* lwaux */),
831 /* -------- Double -------- */
833 /* d n i s */ HI(54) /* stfd */,
834 /* d n i l */ HI(50) /* lfd */,
835 /* d n x s */ HI(31) | LO(727) /* stfdx */,
836 /* d n x l */ HI(31) | LO(599) /* lfdx */,
838 /* s n i s */ HI(52) /* stfs */,
839 /* s n i l */ HI(48) /* lfs */,
840 /* s n x s */ HI(31) | LO(663) /* stfsx */,
841 /* s n x l */ HI(31) | LO(535) /* lfsx */,
847 /* Simple cases, (no caching is required). */
848 static sljit_s32 getput_arg_fast(struct sljit_compiler *compiler, sljit_s32 inp_flags, sljit_s32 reg, sljit_s32 arg, sljit_sw argw)
852 /* Should work when (arg & REG_MASK) == 0. */
853 SLJIT_COMPILE_ASSERT(A(0) == 0, a0_must_be_0);
854 SLJIT_ASSERT(arg & SLJIT_MEM);
856 if (arg & OFFS_REG_MASK) {
859 if (inp_flags & ARG_TEST)
862 inst = data_transfer_insts[(inp_flags | INDEXED) & MEM_MASK];
863 SLJIT_ASSERT(!(inst & (INT_ALIGNED | UPDATE_REQ)));
864 FAIL_IF(push_inst(compiler, INST_CODE_AND_DST(inst, inp_flags, reg) | A(arg & REG_MASK) | B(OFFS_REG(arg))));
868 if (SLJIT_UNLIKELY(!(arg & REG_MASK)))
869 inp_flags &= ~WRITE_BACK;
871 #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)
872 inst = data_transfer_insts[inp_flags & MEM_MASK];
873 SLJIT_ASSERT((arg & REG_MASK) || !(inst & UPDATE_REQ));
875 if (argw > SIMM_MAX || argw < SIMM_MIN || ((inst & INT_ALIGNED) && (argw & 0x3)) || (inst & UPDATE_REQ))
877 if (inp_flags & ARG_TEST)
881 #if (defined SLJIT_CONFIG_PPC_32 && SLJIT_CONFIG_PPC_32)
882 if (argw > SIMM_MAX || argw < SIMM_MIN)
884 if (inp_flags & ARG_TEST)
887 inst = data_transfer_insts[inp_flags & MEM_MASK];
888 SLJIT_ASSERT(!(inst & (INT_ALIGNED | UPDATE_REQ)));
891 FAIL_IF(push_inst(compiler, INST_CODE_AND_DST(inst, inp_flags, reg) | A(arg & REG_MASK) | IMM(argw)));
895 /* See getput_arg below.
896 Note: can_cache is called only for binary operators. Those operator always
897 uses word arguments without write back. */
898 static sljit_s32 can_cache(sljit_s32 arg, sljit_sw argw, sljit_s32 next_arg, sljit_sw next_argw)
900 sljit_sw high_short, next_high_short;
901 #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)
905 SLJIT_ASSERT((arg & SLJIT_MEM) && (next_arg & SLJIT_MEM));
907 if (arg & OFFS_REG_MASK)
908 return ((arg & OFFS_REG_MASK) == (next_arg & OFFS_REG_MASK) && (argw & 0x3) == (next_argw & 0x3));
910 if (next_arg & OFFS_REG_MASK)
913 #if (defined SLJIT_CONFIG_PPC_32 && SLJIT_CONFIG_PPC_32)
914 high_short = (argw + ((argw & 0x8000) << 1)) & ~0xffff;
915 next_high_short = (next_argw + ((next_argw & 0x8000) << 1)) & ~0xffff;
916 return high_short == next_high_short;
918 if (argw <= 0x7fffffffl && argw >= -0x80000000l) {
919 high_short = (argw + ((argw & 0x8000) << 1)) & ~0xffff;
920 next_high_short = (next_argw + ((next_argw & 0x8000) << 1)) & ~0xffff;
921 if (high_short == next_high_short)
925 diff = argw - next_argw;
926 if (!(arg & REG_MASK))
927 return diff <= SIMM_MAX && diff >= SIMM_MIN;
929 if (arg == next_arg && diff <= SIMM_MAX && diff >= SIMM_MIN)
936 #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)
937 #define ADJUST_CACHED_IMM(imm) \
938 if ((inst & INT_ALIGNED) && (imm & 0x3)) { \
939 /* Adjust cached value. Fortunately this is really a rare case */ \
940 compiler->cache_argw += imm & 0x3; \
941 FAIL_IF(push_inst(compiler, ADDI | D(TMP_REG3) | A(TMP_REG3) | (imm & 0x3))); \
946 /* Emit the necessary instructions. See can_cache above. */
947 static sljit_s32 getput_arg(struct sljit_compiler *compiler, sljit_s32 inp_flags, sljit_s32 reg, sljit_s32 arg, sljit_sw argw, sljit_s32 next_arg, sljit_sw next_argw)
951 sljit_sw high_short, next_high_short;
952 #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)
956 SLJIT_ASSERT(arg & SLJIT_MEM);
958 tmp_r = ((inp_flags & LOAD_DATA) && ((inp_flags) & MEM_MASK) <= GPR_REG) ? reg : TMP_REG1;
959 /* Special case for "mov reg, [reg, ... ]". */
960 if ((arg & REG_MASK) == tmp_r)
963 if (SLJIT_UNLIKELY(arg & OFFS_REG_MASK)) {
965 /* Otherwise getput_arg_fast would capture it. */
968 if ((SLJIT_MEM | (arg & OFFS_REG_MASK)) == compiler->cache_arg && argw == compiler->cache_argw)
971 if ((arg & OFFS_REG_MASK) == (next_arg & OFFS_REG_MASK) && argw == (next_argw & 0x3)) {
972 compiler->cache_arg = SLJIT_MEM | (arg & OFFS_REG_MASK);
973 compiler->cache_argw = argw;
976 #if (defined SLJIT_CONFIG_PPC_32 && SLJIT_CONFIG_PPC_32)
977 FAIL_IF(push_inst(compiler, RLWINM | S(OFFS_REG(arg)) | A(tmp_r) | (argw << 11) | ((31 - argw) << 1)));
979 FAIL_IF(push_inst(compiler, RLDI(tmp_r, OFFS_REG(arg), argw, 63 - argw, 1)));
982 inst = data_transfer_insts[(inp_flags | INDEXED) & MEM_MASK];
983 SLJIT_ASSERT(!(inst & (INT_ALIGNED | UPDATE_REQ)));
984 return push_inst(compiler, INST_CODE_AND_DST(inst, inp_flags, reg) | A(arg & REG_MASK) | B(tmp_r));
987 if (SLJIT_UNLIKELY(!(arg & REG_MASK)))
988 inp_flags &= ~WRITE_BACK;
990 inst = data_transfer_insts[inp_flags & MEM_MASK];
991 SLJIT_ASSERT((arg & REG_MASK) || !(inst & UPDATE_REQ));
993 #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)
994 if (argw <= 0x7fff7fffl && argw >= -0x80000000l
995 && (!(inst & INT_ALIGNED) || !(argw & 0x3)) && !(inst & UPDATE_REQ)) {
999 high_short = (sljit_s32)(argw + ((argw & 0x8000) << 1)) & ~0xffff;
1000 /* The getput_arg_fast should handle this otherwise. */
1001 #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)
1002 SLJIT_ASSERT(high_short && high_short <= 0x7fffffffl && high_short >= -0x80000000l);
1004 SLJIT_ASSERT(high_short && !(inst & (INT_ALIGNED | UPDATE_REQ)));
1007 if (inp_flags & WRITE_BACK) {
1009 FAIL_IF(push_inst(compiler, OR | S(reg) | A(tmp_r) | B(reg)));
1013 FAIL_IF(push_inst(compiler, ADDIS | D(arg) | A(arg) | IMM(high_short >> 16)));
1015 else if (compiler->cache_arg != (SLJIT_MEM | arg) || high_short != compiler->cache_argw) {
1016 if ((next_arg & SLJIT_MEM) && !(next_arg & OFFS_REG_MASK)) {
1017 next_high_short = (sljit_s32)(next_argw + ((next_argw & 0x8000) << 1)) & ~0xffff;
1018 if (high_short == next_high_short) {
1019 compiler->cache_arg = SLJIT_MEM | arg;
1020 compiler->cache_argw = high_short;
1024 FAIL_IF(push_inst(compiler, ADDIS | D(tmp_r) | A(arg & REG_MASK) | IMM(high_short >> 16)));
1029 return push_inst(compiler, INST_CODE_AND_DST(inst, inp_flags, reg) | A(tmp_r) | IMM(argw));
1031 #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)
1034 /* Everything else is PPC-64 only. */
1035 if (SLJIT_UNLIKELY(!(arg & REG_MASK))) {
1036 diff = argw - compiler->cache_argw;
1037 if ((compiler->cache_arg & SLJIT_IMM) && diff <= SIMM_MAX && diff >= SIMM_MIN) {
1038 ADJUST_CACHED_IMM(diff);
1039 return push_inst(compiler, INST_CODE_AND_DST(inst, inp_flags, reg) | A(TMP_REG3) | IMM(diff));
1042 diff = argw - next_argw;
1043 if ((next_arg & SLJIT_MEM) && diff <= SIMM_MAX && diff >= SIMM_MIN) {
1044 SLJIT_ASSERT(inp_flags & LOAD_DATA);
1046 compiler->cache_arg = SLJIT_IMM;
1047 compiler->cache_argw = argw;
1051 FAIL_IF(load_immediate(compiler, tmp_r, argw));
1052 return push_inst(compiler, INST_CODE_AND_DST(inst, inp_flags, reg) | A(tmp_r));
1055 diff = argw - compiler->cache_argw;
1056 if (compiler->cache_arg == arg && diff <= SIMM_MAX && diff >= SIMM_MIN) {
1057 SLJIT_ASSERT(!(inp_flags & WRITE_BACK) && !(inst & UPDATE_REQ));
1058 ADJUST_CACHED_IMM(diff);
1059 return push_inst(compiler, INST_CODE_AND_DST(inst, inp_flags, reg) | A(TMP_REG3) | IMM(diff));
1062 if ((compiler->cache_arg & SLJIT_IMM) && diff <= SIMM_MAX && diff >= SIMM_MIN) {
1063 inst = data_transfer_insts[(inp_flags | INDEXED) & MEM_MASK];
1064 SLJIT_ASSERT(!(inst & (INT_ALIGNED | UPDATE_REQ)));
1065 if (compiler->cache_argw != argw) {
1066 FAIL_IF(push_inst(compiler, ADDI | D(TMP_REG3) | A(TMP_REG3) | IMM(diff)));
1067 compiler->cache_argw = argw;
1069 return push_inst(compiler, INST_CODE_AND_DST(inst, inp_flags, reg) | A(arg & REG_MASK) | B(TMP_REG3));
1072 if (argw == next_argw && (next_arg & SLJIT_MEM)) {
1073 SLJIT_ASSERT(inp_flags & LOAD_DATA);
1074 FAIL_IF(load_immediate(compiler, TMP_REG3, argw));
1076 compiler->cache_arg = SLJIT_IMM;
1077 compiler->cache_argw = argw;
1079 inst = data_transfer_insts[(inp_flags | INDEXED) & MEM_MASK];
1080 SLJIT_ASSERT(!(inst & (INT_ALIGNED | UPDATE_REQ)));
1081 return push_inst(compiler, INST_CODE_AND_DST(inst, inp_flags, reg) | A(arg & REG_MASK) | B(TMP_REG3));
1084 diff = argw - next_argw;
1085 if (arg == next_arg && !(inp_flags & WRITE_BACK) && diff <= SIMM_MAX && diff >= SIMM_MIN) {
1086 SLJIT_ASSERT(inp_flags & LOAD_DATA);
1087 FAIL_IF(load_immediate(compiler, TMP_REG3, argw));
1088 FAIL_IF(push_inst(compiler, ADD | D(TMP_REG3) | A(TMP_REG3) | B(arg & REG_MASK)));
1090 compiler->cache_arg = arg;
1091 compiler->cache_argw = argw;
1093 return push_inst(compiler, INST_CODE_AND_DST(inst, inp_flags, reg) | A(TMP_REG3));
1096 if ((next_arg & SLJIT_MEM) && !(next_arg & OFFS_REG_MASK) && diff <= SIMM_MAX && diff >= SIMM_MIN) {
1097 SLJIT_ASSERT(inp_flags & LOAD_DATA);
1098 FAIL_IF(load_immediate(compiler, TMP_REG3, argw));
1100 compiler->cache_arg = SLJIT_IMM;
1101 compiler->cache_argw = argw;
1105 FAIL_IF(load_immediate(compiler, tmp_r, argw));
1107 /* Get the indexed version instead of the normal one. */
1108 inst = data_transfer_insts[(inp_flags | INDEXED) & MEM_MASK];
1109 SLJIT_ASSERT(!(inst & (INT_ALIGNED | UPDATE_REQ)));
1110 return push_inst(compiler, INST_CODE_AND_DST(inst, inp_flags, reg) | A(arg & REG_MASK) | B(tmp_r));
1114 static SLJIT_INLINE sljit_s32 emit_op_mem2(struct sljit_compiler *compiler, sljit_s32 flags, sljit_s32 reg, sljit_s32 arg1, sljit_sw arg1w, sljit_s32 arg2, sljit_sw arg2w)
1116 if (getput_arg_fast(compiler, flags, reg, arg1, arg1w))
1117 return compiler->error;
1118 return getput_arg(compiler, flags, reg, arg1, arg1w, arg2, arg2w);
1121 static sljit_s32 emit_op(struct sljit_compiler *compiler, sljit_s32 op, sljit_s32 input_flags,
1122 sljit_s32 dst, sljit_sw dstw,
1123 sljit_s32 src1, sljit_sw src1w,
1124 sljit_s32 src2, sljit_sw src2w)
1126 /* arg1 goes to TMP_REG1 or src reg
1127 arg2 goes to TMP_REG2, imm or src reg
1128 TMP_REG3 can be used for caching
1129 result goes to TMP_REG2, so put result can use TMP_REG1 and TMP_REG3. */
1133 sljit_s32 sugg_src2_r = TMP_REG2;
1134 sljit_s32 flags = input_flags & (ALT_FORM1 | ALT_FORM2 | ALT_FORM3 | ALT_FORM4 | ALT_FORM5 | ALT_FORM6 | ALT_SIGN_EXT | ALT_SET_FLAGS);
1136 if (!(input_flags & ALT_KEEP_CACHE)) {
1137 compiler->cache_arg = 0;
1138 compiler->cache_argw = 0;
1141 /* Destination check. */
1142 if (SLJIT_UNLIKELY(dst == SLJIT_UNUSED)) {
1143 if (op >= SLJIT_MOV && op <= SLJIT_MOVU_S32 && !(src2 & SLJIT_MEM))
1144 return SLJIT_SUCCESS;
1147 else if (FAST_IS_REG(dst)) {
1150 if (op >= SLJIT_MOV && op <= SLJIT_MOVU_S32)
1151 sugg_src2_r = dst_r;
1154 SLJIT_ASSERT(dst & SLJIT_MEM);
1155 if (getput_arg_fast(compiler, input_flags | ARG_TEST, TMP_REG2, dst, dstw)) {
1166 if (FAST_IS_REG(src1)) {
1168 flags |= REG1_SOURCE;
1170 else if (src1 & SLJIT_IMM) {
1171 FAIL_IF(load_immediate(compiler, TMP_REG1, src1w));
1174 else if (getput_arg_fast(compiler, input_flags | LOAD_DATA, TMP_REG1, src1, src1w)) {
1175 FAIL_IF(compiler->error);
1182 if (FAST_IS_REG(src2)) {
1184 flags |= REG2_SOURCE;
1185 if (!(flags & REG_DEST) && op >= SLJIT_MOV && op <= SLJIT_MOVU_S32)
1188 else if (src2 & SLJIT_IMM) {
1189 FAIL_IF(load_immediate(compiler, sugg_src2_r, src2w));
1190 src2_r = sugg_src2_r;
1192 else if (getput_arg_fast(compiler, input_flags | LOAD_DATA, sugg_src2_r, src2, src2w)) {
1193 FAIL_IF(compiler->error);
1194 src2_r = sugg_src2_r;
1199 /* src1_r, src2_r and dst_r can be zero (=unprocessed).
1200 All arguments are complex addressing modes, and it is a binary operator. */
1201 if (src1_r == 0 && src2_r == 0 && dst_r == 0) {
1202 if (!can_cache(src1, src1w, src2, src2w) && can_cache(src1, src1w, dst, dstw)) {
1203 FAIL_IF(getput_arg(compiler, input_flags | LOAD_DATA, TMP_REG2, src2, src2w, src1, src1w));
1204 FAIL_IF(getput_arg(compiler, input_flags | LOAD_DATA, TMP_REG1, src1, src1w, dst, dstw));
1207 FAIL_IF(getput_arg(compiler, input_flags | LOAD_DATA, TMP_REG1, src1, src1w, src2, src2w));
1208 FAIL_IF(getput_arg(compiler, input_flags | LOAD_DATA, TMP_REG2, src2, src2w, dst, dstw));
1213 else if (src1_r == 0 && src2_r == 0) {
1214 FAIL_IF(getput_arg(compiler, input_flags | LOAD_DATA, TMP_REG1, src1, src1w, src2, src2w));
1217 else if (src1_r == 0 && dst_r == 0) {
1218 FAIL_IF(getput_arg(compiler, input_flags | LOAD_DATA, TMP_REG1, src1, src1w, dst, dstw));
1221 else if (src2_r == 0 && dst_r == 0) {
1222 FAIL_IF(getput_arg(compiler, input_flags | LOAD_DATA, sugg_src2_r, src2, src2w, dst, dstw));
1223 src2_r = sugg_src2_r;
1230 FAIL_IF(getput_arg(compiler, input_flags | LOAD_DATA, TMP_REG1, src1, src1w, 0, 0));
1235 FAIL_IF(getput_arg(compiler, input_flags | LOAD_DATA, sugg_src2_r, src2, src2w, 0, 0));
1236 src2_r = sugg_src2_r;
1239 FAIL_IF(emit_single_op(compiler, op, flags, dst_r, src1_r, src2_r));
1241 if (flags & (FAST_DEST | SLOW_DEST)) {
1242 if (flags & FAST_DEST)
1243 FAIL_IF(getput_arg_fast(compiler, input_flags, dst_r, dst, dstw));
1245 FAIL_IF(getput_arg(compiler, input_flags, dst_r, dst, dstw, 0, 0));
1247 return SLJIT_SUCCESS;
1250 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_op0(struct sljit_compiler *compiler, sljit_s32 op)
1252 #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)
1253 sljit_s32 int_op = op & SLJIT_I32_OP;
1257 CHECK(check_sljit_emit_op0(compiler, op));
1259 op = GET_OPCODE(op);
1261 case SLJIT_BREAKPOINT:
1263 return push_inst(compiler, NOP);
1266 FAIL_IF(push_inst(compiler, OR | S(SLJIT_R0) | A(TMP_REG1) | B(SLJIT_R0)));
1267 #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)
1268 FAIL_IF(push_inst(compiler, MULLD | D(SLJIT_R0) | A(TMP_REG1) | B(SLJIT_R1)));
1269 return push_inst(compiler, (op == SLJIT_LMUL_UW ? MULHDU : MULHD) | D(SLJIT_R1) | A(TMP_REG1) | B(SLJIT_R1));
1271 FAIL_IF(push_inst(compiler, MULLW | D(SLJIT_R0) | A(TMP_REG1) | B(SLJIT_R1)));
1272 return push_inst(compiler, (op == SLJIT_LMUL_UW ? MULHWU : MULHW) | D(SLJIT_R1) | A(TMP_REG1) | B(SLJIT_R1));
1274 case SLJIT_DIVMOD_UW:
1275 case SLJIT_DIVMOD_SW:
1276 FAIL_IF(push_inst(compiler, OR | S(SLJIT_R0) | A(TMP_REG1) | B(SLJIT_R0)));
1277 #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)
1278 FAIL_IF(push_inst(compiler, (int_op ? (op == SLJIT_DIVMOD_UW ? DIVWU : DIVW) : (op == SLJIT_DIVMOD_UW ? DIVDU : DIVD)) | D(SLJIT_R0) | A(SLJIT_R0) | B(SLJIT_R1)));
1279 FAIL_IF(push_inst(compiler, (int_op ? MULLW : MULLD) | D(SLJIT_R1) | A(SLJIT_R0) | B(SLJIT_R1)));
1281 FAIL_IF(push_inst(compiler, (op == SLJIT_DIVMOD_UW ? DIVWU : DIVW) | D(SLJIT_R0) | A(SLJIT_R0) | B(SLJIT_R1)));
1282 FAIL_IF(push_inst(compiler, MULLW | D(SLJIT_R1) | A(SLJIT_R0) | B(SLJIT_R1)));
1284 return push_inst(compiler, SUBF | D(SLJIT_R1) | A(SLJIT_R1) | B(TMP_REG1));
1287 #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)
1288 return push_inst(compiler, (int_op ? (op == SLJIT_DIV_UW ? DIVWU : DIVW) : (op == SLJIT_DIV_UW ? DIVDU : DIVD)) | D(SLJIT_R0) | A(SLJIT_R0) | B(SLJIT_R1));
1290 return push_inst(compiler, (op == SLJIT_DIV_UW ? DIVWU : DIVW) | D(SLJIT_R0) | A(SLJIT_R0) | B(SLJIT_R1));
1294 return SLJIT_SUCCESS;
1297 #define EMIT_MOV(type, type_flags, type_cast) \
1298 emit_op(compiler, (src & SLJIT_IMM) ? SLJIT_MOV : type, flags | (type_flags), dst, dstw, TMP_REG1, 0, src, (src & SLJIT_IMM) ? type_cast srcw : srcw)
1300 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_op1(struct sljit_compiler *compiler, sljit_s32 op,
1301 sljit_s32 dst, sljit_sw dstw,
1302 sljit_s32 src, sljit_sw srcw)
1304 sljit_s32 flags = GET_FLAGS(op) ? ALT_SET_FLAGS : 0;
1305 sljit_s32 op_flags = GET_ALL_FLAGS(op);
1308 CHECK(check_sljit_emit_op1(compiler, op, dst, dstw, src, srcw));
1309 ADJUST_LOCAL_OFFSET(dst, dstw);
1310 ADJUST_LOCAL_OFFSET(src, srcw);
1312 op = GET_OPCODE(op);
1313 if ((src & SLJIT_IMM) && srcw == 0)
1316 if (op_flags & SLJIT_SET_O)
1317 FAIL_IF(push_inst(compiler, MTXER | S(TMP_ZERO)));
1319 if (op_flags & SLJIT_I32_OP) {
1320 if (op < SLJIT_NOT) {
1321 if (FAST_IS_REG(src) && src == dst) {
1322 if (!TYPE_CAST_NEEDED(op))
1323 return SLJIT_SUCCESS;
1325 #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)
1326 if (op == SLJIT_MOV_S32 && (src & SLJIT_MEM))
1328 if (op == SLJIT_MOVU_S32 && (src & SLJIT_MEM))
1329 op = SLJIT_MOVU_U32;
1330 if (op == SLJIT_MOV_U32 && (src & SLJIT_IMM))
1332 if (op == SLJIT_MOVU_U32 && (src & SLJIT_IMM))
1333 op = SLJIT_MOVU_S32;
1336 #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)
1338 /* Most operations expect sign extended arguments. */
1339 flags |= INT_DATA | SIGNED_DATA;
1340 if (src & SLJIT_IMM)
1341 srcw = (sljit_s32)srcw;
1349 #if (defined SLJIT_CONFIG_PPC_32 && SLJIT_CONFIG_PPC_32)
1353 return emit_op(compiler, SLJIT_MOV, flags | WORD_DATA, dst, dstw, TMP_REG1, 0, src, srcw);
1355 #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)
1357 return EMIT_MOV(SLJIT_MOV_U32, INT_DATA, (sljit_u32));
1360 return EMIT_MOV(SLJIT_MOV_S32, INT_DATA | SIGNED_DATA, (sljit_s32));
1364 return EMIT_MOV(SLJIT_MOV_U8, BYTE_DATA, (sljit_u8));
1367 return EMIT_MOV(SLJIT_MOV_S8, BYTE_DATA | SIGNED_DATA, (sljit_s8));
1370 return EMIT_MOV(SLJIT_MOV_U16, HALF_DATA, (sljit_u16));
1373 return EMIT_MOV(SLJIT_MOV_S16, HALF_DATA | SIGNED_DATA, (sljit_s16));
1377 #if (defined SLJIT_CONFIG_PPC_32 && SLJIT_CONFIG_PPC_32)
1378 case SLJIT_MOVU_U32:
1379 case SLJIT_MOVU_S32:
1381 return emit_op(compiler, SLJIT_MOV, flags | WORD_DATA | WRITE_BACK, dst, dstw, TMP_REG1, 0, src, srcw);
1383 #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)
1384 case SLJIT_MOVU_U32:
1385 return EMIT_MOV(SLJIT_MOV_U32, INT_DATA | WRITE_BACK, (sljit_u32));
1387 case SLJIT_MOVU_S32:
1388 return EMIT_MOV(SLJIT_MOV_S32, INT_DATA | SIGNED_DATA | WRITE_BACK, (sljit_s32));
1392 return EMIT_MOV(SLJIT_MOV_U8, BYTE_DATA | WRITE_BACK, (sljit_u8));
1395 return EMIT_MOV(SLJIT_MOV_S8, BYTE_DATA | SIGNED_DATA | WRITE_BACK, (sljit_s8));
1397 case SLJIT_MOVU_U16:
1398 return EMIT_MOV(SLJIT_MOV_U16, HALF_DATA | WRITE_BACK, (sljit_u16));
1400 case SLJIT_MOVU_S16:
1401 return EMIT_MOV(SLJIT_MOV_S16, HALF_DATA | SIGNED_DATA | WRITE_BACK, (sljit_s16));
1404 return emit_op(compiler, SLJIT_NOT, flags, dst, dstw, TMP_REG1, 0, src, srcw);
1407 return emit_op(compiler, SLJIT_NEG, flags, dst, dstw, TMP_REG1, 0, src, srcw);
1410 #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)
1411 return emit_op(compiler, SLJIT_CLZ, flags | (!(op_flags & SLJIT_I32_OP) ? 0 : ALT_FORM1), dst, dstw, TMP_REG1, 0, src, srcw);
1413 return emit_op(compiler, SLJIT_CLZ, flags, dst, dstw, TMP_REG1, 0, src, srcw);
1417 return SLJIT_SUCCESS;
1422 #define TEST_SL_IMM(src, srcw) \
1423 (((src) & SLJIT_IMM) && (srcw) <= SIMM_MAX && (srcw) >= SIMM_MIN)
1425 #define TEST_UL_IMM(src, srcw) \
1426 (((src) & SLJIT_IMM) && !((srcw) & ~0xffff))
1428 #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)
1429 #define TEST_SH_IMM(src, srcw) \
1430 (((src) & SLJIT_IMM) && !((srcw) & 0xffff) && (srcw) <= 0x7fffffffl && (srcw) >= -0x80000000l)
1432 #define TEST_SH_IMM(src, srcw) \
1433 (((src) & SLJIT_IMM) && !((srcw) & 0xffff))
1436 #define TEST_UH_IMM(src, srcw) \
1437 (((src) & SLJIT_IMM) && !((srcw) & ~0xffff0000))
1439 #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)
1440 #define TEST_ADD_IMM(src, srcw) \
1441 (((src) & SLJIT_IMM) && (srcw) <= 0x7fff7fffl && (srcw) >= -0x80000000l)
1443 #define TEST_ADD_IMM(src, srcw) \
1447 #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)
1448 #define TEST_UI_IMM(src, srcw) \
1449 (((src) & SLJIT_IMM) && !((srcw) & ~0xffffffff))
1451 #define TEST_UI_IMM(src, srcw) \
1455 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_op2(struct sljit_compiler *compiler, sljit_s32 op,
1456 sljit_s32 dst, sljit_sw dstw,
1457 sljit_s32 src1, sljit_sw src1w,
1458 sljit_s32 src2, sljit_sw src2w)
1460 sljit_s32 flags = GET_FLAGS(op) ? ALT_SET_FLAGS : 0;
1463 CHECK(check_sljit_emit_op2(compiler, op, dst, dstw, src1, src1w, src2, src2w));
1464 ADJUST_LOCAL_OFFSET(dst, dstw);
1465 ADJUST_LOCAL_OFFSET(src1, src1w);
1466 ADJUST_LOCAL_OFFSET(src2, src2w);
1468 if ((src1 & SLJIT_IMM) && src1w == 0)
1470 if ((src2 & SLJIT_IMM) && src2w == 0)
1473 #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)
1474 if (op & SLJIT_I32_OP) {
1475 /* Most operations expect sign extended arguments. */
1476 flags |= INT_DATA | SIGNED_DATA;
1477 if (src1 & SLJIT_IMM)
1478 src1w = (sljit_s32)(src1w);
1479 if (src2 & SLJIT_IMM)
1480 src2w = (sljit_s32)(src2w);
1482 flags |= ALT_SIGN_EXT;
1485 if (op & SLJIT_SET_O)
1486 FAIL_IF(push_inst(compiler, MTXER | S(TMP_ZERO)));
1487 if (src2 == TMP_REG2)
1488 flags |= ALT_KEEP_CACHE;
1490 switch (GET_OPCODE(op)) {
1492 if (!GET_FLAGS(op) && ((src1 | src2) & SLJIT_IMM)) {
1493 if (TEST_SL_IMM(src2, src2w)) {
1494 compiler->imm = src2w & 0xffff;
1495 return emit_op(compiler, SLJIT_ADD, flags | ALT_FORM1, dst, dstw, src1, src1w, TMP_REG2, 0);
1497 if (TEST_SL_IMM(src1, src1w)) {
1498 compiler->imm = src1w & 0xffff;
1499 return emit_op(compiler, SLJIT_ADD, flags | ALT_FORM1, dst, dstw, src2, src2w, TMP_REG2, 0);
1501 if (TEST_SH_IMM(src2, src2w)) {
1502 compiler->imm = (src2w >> 16) & 0xffff;
1503 return emit_op(compiler, SLJIT_ADD, flags | ALT_FORM2, dst, dstw, src1, src1w, TMP_REG2, 0);
1505 if (TEST_SH_IMM(src1, src1w)) {
1506 compiler->imm = (src1w >> 16) & 0xffff;
1507 return emit_op(compiler, SLJIT_ADD, flags | ALT_FORM2, dst, dstw, src2, src2w, TMP_REG2, 0);
1509 /* Range between -1 and -32768 is covered above. */
1510 if (TEST_ADD_IMM(src2, src2w)) {
1511 compiler->imm = src2w & 0xffffffff;
1512 return emit_op(compiler, SLJIT_ADD, flags | ALT_FORM4, dst, dstw, src1, src1w, TMP_REG2, 0);
1514 if (TEST_ADD_IMM(src1, src1w)) {
1515 compiler->imm = src1w & 0xffffffff;
1516 return emit_op(compiler, SLJIT_ADD, flags | ALT_FORM4, dst, dstw, src2, src2w, TMP_REG2, 0);
1519 if (!(GET_FLAGS(op) & (SLJIT_SET_E | SLJIT_SET_O))) {
1520 if (TEST_SL_IMM(src2, src2w)) {
1521 compiler->imm = src2w & 0xffff;
1522 return emit_op(compiler, SLJIT_ADD, flags | ALT_FORM3, dst, dstw, src1, src1w, TMP_REG2, 0);
1524 if (TEST_SL_IMM(src1, src1w)) {
1525 compiler->imm = src1w & 0xffff;
1526 return emit_op(compiler, SLJIT_ADD, flags | ALT_FORM3, dst, dstw, src2, src2w, TMP_REG2, 0);
1529 return emit_op(compiler, SLJIT_ADD, flags, dst, dstw, src1, src1w, src2, src2w);
1532 return emit_op(compiler, SLJIT_ADDC, flags | (!(op & SLJIT_KEEP_FLAGS) ? 0 : ALT_FORM1), dst, dstw, src1, src1w, src2, src2w);
1535 if (!GET_FLAGS(op) && ((src1 | src2) & SLJIT_IMM)) {
1536 if (TEST_SL_IMM(src2, -src2w)) {
1537 compiler->imm = (-src2w) & 0xffff;
1538 return emit_op(compiler, SLJIT_ADD, flags | ALT_FORM1, dst, dstw, src1, src1w, TMP_REG2, 0);
1540 if (TEST_SL_IMM(src1, src1w)) {
1541 compiler->imm = src1w & 0xffff;
1542 return emit_op(compiler, SLJIT_SUB, flags | ALT_FORM1, dst, dstw, src2, src2w, TMP_REG2, 0);
1544 if (TEST_SH_IMM(src2, -src2w)) {
1545 compiler->imm = ((-src2w) >> 16) & 0xffff;
1546 return emit_op(compiler, SLJIT_ADD, flags | ALT_FORM2, dst, dstw, src1, src1w, TMP_REG2, 0);
1548 /* Range between -1 and -32768 is covered above. */
1549 if (TEST_ADD_IMM(src2, -src2w)) {
1550 compiler->imm = -src2w & 0xffffffff;
1551 return emit_op(compiler, SLJIT_ADD, flags | ALT_FORM4, dst, dstw, src1, src1w, TMP_REG2, 0);
1554 if (dst == SLJIT_UNUSED && (op & (SLJIT_SET_E | SLJIT_SET_U | SLJIT_SET_S)) && !(op & (SLJIT_SET_O | SLJIT_SET_C))) {
1555 if (!(op & SLJIT_SET_U)) {
1556 /* We know ALT_SIGN_EXT is set if it is an SLJIT_I32_OP on 64 bit systems. */
1557 if (TEST_SL_IMM(src2, src2w)) {
1558 compiler->imm = src2w & 0xffff;
1559 return emit_op(compiler, SLJIT_SUB, flags | ALT_FORM2, dst, dstw, src1, src1w, TMP_REG2, 0);
1561 if (GET_FLAGS(op) == SLJIT_SET_E && TEST_SL_IMM(src1, src1w)) {
1562 compiler->imm = src1w & 0xffff;
1563 return emit_op(compiler, SLJIT_SUB, flags | ALT_FORM2, dst, dstw, src2, src2w, TMP_REG2, 0);
1566 if (!(op & (SLJIT_SET_E | SLJIT_SET_S))) {
1567 /* We know ALT_SIGN_EXT is set if it is an SLJIT_I32_OP on 64 bit systems. */
1568 if (TEST_UL_IMM(src2, src2w)) {
1569 compiler->imm = src2w & 0xffff;
1570 return emit_op(compiler, SLJIT_SUB, flags | ALT_FORM3, dst, dstw, src1, src1w, TMP_REG2, 0);
1572 return emit_op(compiler, SLJIT_SUB, flags | ALT_FORM4, dst, dstw, src1, src1w, src2, src2w);
1574 if ((src2 & SLJIT_IMM) && src2w >= 0 && src2w <= 0x7fff) {
1575 compiler->imm = src2w;
1576 return emit_op(compiler, SLJIT_SUB, flags | ALT_FORM2 | ALT_FORM3, dst, dstw, src1, src1w, TMP_REG2, 0);
1578 return emit_op(compiler, SLJIT_SUB, flags | ((op & SLJIT_SET_U) ? ALT_FORM4 : 0) | ((op & (SLJIT_SET_E | SLJIT_SET_S)) ? ALT_FORM5 : 0), dst, dstw, src1, src1w, src2, src2w);
1580 if (!(op & (SLJIT_SET_E | SLJIT_SET_U | SLJIT_SET_S | SLJIT_SET_O))) {
1581 if (TEST_SL_IMM(src2, -src2w)) {
1582 compiler->imm = (-src2w) & 0xffff;
1583 return emit_op(compiler, SLJIT_ADD, flags | ALT_FORM3, dst, dstw, src1, src1w, TMP_REG2, 0);
1586 /* We know ALT_SIGN_EXT is set if it is an SLJIT_I32_OP on 64 bit systems. */
1587 return emit_op(compiler, SLJIT_SUB, flags | (!(op & SLJIT_SET_U) ? 0 : ALT_FORM6), dst, dstw, src1, src1w, src2, src2w);
1590 return emit_op(compiler, SLJIT_SUBC, flags | (!(op & SLJIT_KEEP_FLAGS) ? 0 : ALT_FORM1), dst, dstw, src1, src1w, src2, src2w);
1593 #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)
1594 if (op & SLJIT_I32_OP)
1597 if (!GET_FLAGS(op)) {
1598 if (TEST_SL_IMM(src2, src2w)) {
1599 compiler->imm = src2w & 0xffff;
1600 return emit_op(compiler, SLJIT_MUL, flags | ALT_FORM1, dst, dstw, src1, src1w, TMP_REG2, 0);
1602 if (TEST_SL_IMM(src1, src1w)) {
1603 compiler->imm = src1w & 0xffff;
1604 return emit_op(compiler, SLJIT_MUL, flags | ALT_FORM1, dst, dstw, src2, src2w, TMP_REG2, 0);
1607 return emit_op(compiler, SLJIT_MUL, flags, dst, dstw, src1, src1w, src2, src2w);
1612 /* Commutative unsigned operations. */
1613 if (!GET_FLAGS(op) || GET_OPCODE(op) == SLJIT_AND) {
1614 if (TEST_UL_IMM(src2, src2w)) {
1615 compiler->imm = src2w;
1616 return emit_op(compiler, GET_OPCODE(op), flags | ALT_FORM1, dst, dstw, src1, src1w, TMP_REG2, 0);
1618 if (TEST_UL_IMM(src1, src1w)) {
1619 compiler->imm = src1w;
1620 return emit_op(compiler, GET_OPCODE(op), flags | ALT_FORM1, dst, dstw, src2, src2w, TMP_REG2, 0);
1622 if (TEST_UH_IMM(src2, src2w)) {
1623 compiler->imm = (src2w >> 16) & 0xffff;
1624 return emit_op(compiler, GET_OPCODE(op), flags | ALT_FORM2, dst, dstw, src1, src1w, TMP_REG2, 0);
1626 if (TEST_UH_IMM(src1, src1w)) {
1627 compiler->imm = (src1w >> 16) & 0xffff;
1628 return emit_op(compiler, GET_OPCODE(op), flags | ALT_FORM2, dst, dstw, src2, src2w, TMP_REG2, 0);
1631 if (!GET_FLAGS(op) && GET_OPCODE(op) != SLJIT_AND) {
1632 if (TEST_UI_IMM(src2, src2w)) {
1633 compiler->imm = src2w;
1634 return emit_op(compiler, GET_OPCODE(op), flags | ALT_FORM3, dst, dstw, src1, src1w, TMP_REG2, 0);
1636 if (TEST_UI_IMM(src1, src1w)) {
1637 compiler->imm = src1w;
1638 return emit_op(compiler, GET_OPCODE(op), flags | ALT_FORM3, dst, dstw, src2, src2w, TMP_REG2, 0);
1641 return emit_op(compiler, GET_OPCODE(op), flags, dst, dstw, src1, src1w, src2, src2w);
1644 if (op & SLJIT_KEEP_FLAGS)
1649 #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)
1650 if (op & SLJIT_I32_OP)
1653 if (src2 & SLJIT_IMM) {
1654 compiler->imm = src2w;
1655 return emit_op(compiler, GET_OPCODE(op), flags | ALT_FORM1, dst, dstw, src1, src1w, TMP_REG2, 0);
1657 return emit_op(compiler, GET_OPCODE(op), flags, dst, dstw, src1, src1w, src2, src2w);
1660 return SLJIT_SUCCESS;
1663 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_get_register_index(sljit_s32 reg)
1665 CHECK_REG_INDEX(check_sljit_get_register_index(reg));
1666 return reg_map[reg];
1669 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_get_float_register_index(sljit_s32 reg)
1671 CHECK_REG_INDEX(check_sljit_get_float_register_index(reg));
1675 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_op_custom(struct sljit_compiler *compiler,
1676 void *instruction, sljit_s32 size)
1679 CHECK(check_sljit_emit_op_custom(compiler, instruction, size));
1681 return push_inst(compiler, *(sljit_ins*)instruction);
1684 /* --------------------------------------------------------------------- */
1685 /* Floating point operators */
1686 /* --------------------------------------------------------------------- */
1688 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_is_fpu_available(void)
1690 #ifdef SLJIT_IS_FPU_AVAILABLE
1691 return SLJIT_IS_FPU_AVAILABLE;
1693 /* Available by default. */
1698 #define FLOAT_DATA(op) (DOUBLE_DATA | ((op & SLJIT_F32_OP) >> 6))
1699 #define SELECT_FOP(op, single, double) ((op & SLJIT_F32_OP) ? single : double)
1701 #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)
1702 #define FLOAT_TMP_MEM_OFFSET (6 * sizeof(sljit_sw))
1704 #define FLOAT_TMP_MEM_OFFSET (2 * sizeof(sljit_sw))
1706 #if (defined SLJIT_LITTLE_ENDIAN && SLJIT_LITTLE_ENDIAN)
1707 #define FLOAT_TMP_MEM_OFFSET_LOW (2 * sizeof(sljit_sw))
1708 #define FLOAT_TMP_MEM_OFFSET_HI (3 * sizeof(sljit_sw))
1710 #define FLOAT_TMP_MEM_OFFSET_LOW (3 * sizeof(sljit_sw))
1711 #define FLOAT_TMP_MEM_OFFSET_HI (2 * sizeof(sljit_sw))
1714 #endif /* SLJIT_CONFIG_PPC_64 */
1716 static SLJIT_INLINE sljit_s32 sljit_emit_fop1_conv_sw_from_f64(struct sljit_compiler *compiler, sljit_s32 op,
1717 sljit_s32 dst, sljit_sw dstw,
1718 sljit_s32 src, sljit_sw srcw)
1720 if (src & SLJIT_MEM) {
1721 /* We can ignore the temporary data store on the stack from caching point of view. */
1722 FAIL_IF(emit_op_mem2(compiler, FLOAT_DATA(op) | LOAD_DATA, TMP_FREG1, src, srcw, dst, dstw));
1726 #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)
1727 op = GET_OPCODE(op);
1728 FAIL_IF(push_inst(compiler, (op == SLJIT_CONV_S32_FROM_F64 ? FCTIWZ : FCTIDZ) | FD(TMP_FREG1) | FB(src)));
1730 if (dst == SLJIT_UNUSED)
1731 return SLJIT_SUCCESS;
1733 if (op == SLJIT_CONV_SW_FROM_F64) {
1734 if (FAST_IS_REG(dst)) {
1735 FAIL_IF(emit_op_mem2(compiler, DOUBLE_DATA, TMP_FREG1, SLJIT_MEM1(SLJIT_SP), FLOAT_TMP_MEM_OFFSET, 0, 0));
1736 return emit_op_mem2(compiler, WORD_DATA | LOAD_DATA, dst, SLJIT_MEM1(SLJIT_SP), FLOAT_TMP_MEM_OFFSET, 0, 0);
1738 return emit_op_mem2(compiler, DOUBLE_DATA, TMP_FREG1, dst, dstw, 0, 0);
1742 FAIL_IF(push_inst(compiler, FCTIWZ | FD(TMP_FREG1) | FB(src)));
1744 if (dst == SLJIT_UNUSED)
1745 return SLJIT_SUCCESS;
1748 if (FAST_IS_REG(dst)) {
1749 FAIL_IF(load_immediate(compiler, TMP_REG1, FLOAT_TMP_MEM_OFFSET));
1750 FAIL_IF(push_inst(compiler, STFIWX | FS(TMP_FREG1) | A(SLJIT_SP) | B(TMP_REG1)));
1751 return emit_op_mem2(compiler, INT_DATA | LOAD_DATA, dst, SLJIT_MEM1(SLJIT_SP), FLOAT_TMP_MEM_OFFSET, 0, 0);
1754 SLJIT_ASSERT(dst & SLJIT_MEM);
1756 if (dst & OFFS_REG_MASK) {
1759 #if (defined SLJIT_CONFIG_PPC_32 && SLJIT_CONFIG_PPC_32)
1760 FAIL_IF(push_inst(compiler, RLWINM | S(OFFS_REG(dst)) | A(TMP_REG1) | (dstw << 11) | ((31 - dstw) << 1)));
1762 FAIL_IF(push_inst(compiler, RLDI(TMP_REG1, OFFS_REG(dst), dstw, 63 - dstw, 1)));
1767 dstw = OFFS_REG(dst);
1770 if ((dst & REG_MASK) && !dstw) {
1771 dstw = dst & REG_MASK;
1775 /* This works regardless we have SLJIT_MEM1 or SLJIT_MEM0. */
1776 FAIL_IF(load_immediate(compiler, TMP_REG1, dstw));
1781 return push_inst(compiler, STFIWX | FS(TMP_FREG1) | A(dst & REG_MASK) | B(dstw));
1784 static SLJIT_INLINE sljit_s32 sljit_emit_fop1_conv_f64_from_sw(struct sljit_compiler *compiler, sljit_s32 op,
1785 sljit_s32 dst, sljit_sw dstw,
1786 sljit_s32 src, sljit_sw srcw)
1788 #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)
1790 sljit_s32 dst_r = FAST_IS_REG(dst) ? dst : TMP_FREG1;
1792 if (src & SLJIT_IMM) {
1793 if (GET_OPCODE(op) == SLJIT_CONV_F64_FROM_S32)
1794 srcw = (sljit_s32)srcw;
1795 FAIL_IF(load_immediate(compiler, TMP_REG1, srcw));
1798 else if (GET_OPCODE(op) == SLJIT_CONV_F64_FROM_S32) {
1799 if (FAST_IS_REG(src))
1800 FAIL_IF(push_inst(compiler, EXTSW | S(src) | A(TMP_REG1)));
1802 FAIL_IF(emit_op_mem2(compiler, INT_DATA | SIGNED_DATA | LOAD_DATA, TMP_REG1, src, srcw, SLJIT_MEM1(SLJIT_SP), FLOAT_TMP_MEM_OFFSET));
1806 if (FAST_IS_REG(src)) {
1807 FAIL_IF(emit_op_mem2(compiler, WORD_DATA, src, SLJIT_MEM1(SLJIT_SP), FLOAT_TMP_MEM_OFFSET, SLJIT_MEM1(SLJIT_SP), FLOAT_TMP_MEM_OFFSET));
1808 FAIL_IF(emit_op_mem2(compiler, DOUBLE_DATA | LOAD_DATA, TMP_FREG1, SLJIT_MEM1(SLJIT_SP), FLOAT_TMP_MEM_OFFSET, dst, dstw));
1811 FAIL_IF(emit_op_mem2(compiler, DOUBLE_DATA | LOAD_DATA, TMP_FREG1, src, srcw, dst, dstw));
1813 FAIL_IF(push_inst(compiler, FCFID | FD(dst_r) | FB(TMP_FREG1)));
1815 if (dst & SLJIT_MEM)
1816 return emit_op_mem2(compiler, FLOAT_DATA(op), TMP_FREG1, dst, dstw, 0, 0);
1817 if (op & SLJIT_F32_OP)
1818 return push_inst(compiler, FRSP | FD(dst_r) | FB(dst_r));
1819 return SLJIT_SUCCESS;
1823 sljit_s32 dst_r = FAST_IS_REG(dst) ? dst : TMP_FREG1;
1824 sljit_s32 invert_sign = 1;
1826 if (src & SLJIT_IMM) {
1827 FAIL_IF(load_immediate(compiler, TMP_REG1, srcw ^ 0x80000000));
1831 else if (!FAST_IS_REG(src)) {
1832 FAIL_IF(emit_op_mem2(compiler, WORD_DATA | SIGNED_DATA | LOAD_DATA, TMP_REG1, src, srcw, SLJIT_MEM1(SLJIT_SP), FLOAT_TMP_MEM_OFFSET_LOW));
1836 /* First, a special double floating point value is constructed: (2^53 + (input xor (2^31)))
1837 The double precision format has exactly 53 bit precision, so the lower 32 bit represents
1838 the lower 32 bit of such value. The result of xor 2^31 is the same as adding 0x80000000
1839 to the input, which shifts it into the 0 - 0xffffffff range. To get the converted floating
1840 point value, we need to substract 2^53 + 2^31 from the constructed value. */
1841 FAIL_IF(push_inst(compiler, ADDIS | D(TMP_REG2) | A(0) | 0x4330));
1843 FAIL_IF(push_inst(compiler, XORIS | S(src) | A(TMP_REG1) | 0x8000));
1844 FAIL_IF(emit_op_mem2(compiler, WORD_DATA, TMP_REG2, SLJIT_MEM1(SLJIT_SP), FLOAT_TMP_MEM_OFFSET_HI, SLJIT_MEM1(SLJIT_SP), FLOAT_TMP_MEM_OFFSET));
1845 FAIL_IF(emit_op_mem2(compiler, WORD_DATA, TMP_REG1, SLJIT_MEM1(SLJIT_SP), FLOAT_TMP_MEM_OFFSET_LOW, SLJIT_MEM1(SLJIT_SP), FLOAT_TMP_MEM_OFFSET_HI));
1846 FAIL_IF(push_inst(compiler, ADDIS | D(TMP_REG1) | A(0) | 0x8000));
1847 FAIL_IF(emit_op_mem2(compiler, DOUBLE_DATA | LOAD_DATA, TMP_FREG1, SLJIT_MEM1(SLJIT_SP), FLOAT_TMP_MEM_OFFSET, SLJIT_MEM1(SLJIT_SP), FLOAT_TMP_MEM_OFFSET_LOW));
1848 FAIL_IF(emit_op_mem2(compiler, WORD_DATA, TMP_REG1, SLJIT_MEM1(SLJIT_SP), FLOAT_TMP_MEM_OFFSET_LOW, SLJIT_MEM1(SLJIT_SP), FLOAT_TMP_MEM_OFFSET));
1849 FAIL_IF(emit_op_mem2(compiler, DOUBLE_DATA | LOAD_DATA, TMP_FREG2, SLJIT_MEM1(SLJIT_SP), FLOAT_TMP_MEM_OFFSET, SLJIT_MEM1(SLJIT_SP), FLOAT_TMP_MEM_OFFSET_LOW));
1851 FAIL_IF(push_inst(compiler, FSUB | FD(dst_r) | FA(TMP_FREG1) | FB(TMP_FREG2)));
1853 if (dst & SLJIT_MEM)
1854 return emit_op_mem2(compiler, FLOAT_DATA(op), TMP_FREG1, dst, dstw, 0, 0);
1855 if (op & SLJIT_F32_OP)
1856 return push_inst(compiler, FRSP | FD(dst_r) | FB(dst_r));
1857 return SLJIT_SUCCESS;
1862 static SLJIT_INLINE sljit_s32 sljit_emit_fop1_cmp(struct sljit_compiler *compiler, sljit_s32 op,
1863 sljit_s32 src1, sljit_sw src1w,
1864 sljit_s32 src2, sljit_sw src2w)
1866 if (src1 & SLJIT_MEM) {
1867 FAIL_IF(emit_op_mem2(compiler, FLOAT_DATA(op) | LOAD_DATA, TMP_FREG1, src1, src1w, src2, src2w));
1871 if (src2 & SLJIT_MEM) {
1872 FAIL_IF(emit_op_mem2(compiler, FLOAT_DATA(op) | LOAD_DATA, TMP_FREG2, src2, src2w, 0, 0));
1876 return push_inst(compiler, FCMPU | CRD(4) | FA(src1) | FB(src2));
1879 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_fop1(struct sljit_compiler *compiler, sljit_s32 op,
1880 sljit_s32 dst, sljit_sw dstw,
1881 sljit_s32 src, sljit_sw srcw)
1886 compiler->cache_arg = 0;
1887 compiler->cache_argw = 0;
1889 SLJIT_COMPILE_ASSERT((SLJIT_F32_OP == 0x100) && !(DOUBLE_DATA & 0x4), float_transfer_bit_error);
1890 SELECT_FOP1_OPERATION_WITH_CHECKS(compiler, op, dst, dstw, src, srcw);
1892 if (GET_OPCODE(op) == SLJIT_CONV_F64_FROM_F32)
1895 dst_r = FAST_IS_REG(dst) ? dst : TMP_FREG1;
1897 if (src & SLJIT_MEM) {
1898 FAIL_IF(emit_op_mem2(compiler, FLOAT_DATA(op) | LOAD_DATA, dst_r, src, srcw, dst, dstw));
1902 switch (GET_OPCODE(op)) {
1903 case SLJIT_CONV_F64_FROM_F32:
1905 if (op & SLJIT_F32_OP) {
1906 FAIL_IF(push_inst(compiler, FRSP | FD(dst_r) | FB(src)));
1912 if (dst_r != TMP_FREG1)
1913 FAIL_IF(push_inst(compiler, FMR | FD(dst_r) | FB(src)));
1919 FAIL_IF(push_inst(compiler, FNEG | FD(dst_r) | FB(src)));
1922 FAIL_IF(push_inst(compiler, FABS | FD(dst_r) | FB(src)));
1926 if (dst & SLJIT_MEM)
1927 FAIL_IF(emit_op_mem2(compiler, FLOAT_DATA(op), dst_r, dst, dstw, 0, 0));
1928 return SLJIT_SUCCESS;
1931 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_fop2(struct sljit_compiler *compiler, sljit_s32 op,
1932 sljit_s32 dst, sljit_sw dstw,
1933 sljit_s32 src1, sljit_sw src1w,
1934 sljit_s32 src2, sljit_sw src2w)
1936 sljit_s32 dst_r, flags = 0;
1939 CHECK(check_sljit_emit_fop2(compiler, op, dst, dstw, src1, src1w, src2, src2w));
1940 ADJUST_LOCAL_OFFSET(dst, dstw);
1941 ADJUST_LOCAL_OFFSET(src1, src1w);
1942 ADJUST_LOCAL_OFFSET(src2, src2w);
1944 compiler->cache_arg = 0;
1945 compiler->cache_argw = 0;
1947 dst_r = FAST_IS_REG(dst) ? dst : TMP_FREG2;
1949 if (src1 & SLJIT_MEM) {
1950 if (getput_arg_fast(compiler, FLOAT_DATA(op) | LOAD_DATA, TMP_FREG1, src1, src1w)) {
1951 FAIL_IF(compiler->error);
1957 if (src2 & SLJIT_MEM) {
1958 if (getput_arg_fast(compiler, FLOAT_DATA(op) | LOAD_DATA, TMP_FREG2, src2, src2w)) {
1959 FAIL_IF(compiler->error);
1965 if ((flags & (ALT_FORM1 | ALT_FORM2)) == (ALT_FORM1 | ALT_FORM2)) {
1966 if (!can_cache(src1, src1w, src2, src2w) && can_cache(src1, src1w, dst, dstw)) {
1967 FAIL_IF(getput_arg(compiler, FLOAT_DATA(op) | LOAD_DATA, TMP_FREG2, src2, src2w, src1, src1w));
1968 FAIL_IF(getput_arg(compiler, FLOAT_DATA(op) | LOAD_DATA, TMP_FREG1, src1, src1w, dst, dstw));
1971 FAIL_IF(getput_arg(compiler, FLOAT_DATA(op) | LOAD_DATA, TMP_FREG1, src1, src1w, src2, src2w));
1972 FAIL_IF(getput_arg(compiler, FLOAT_DATA(op) | LOAD_DATA, TMP_FREG2, src2, src2w, dst, dstw));
1975 else if (flags & ALT_FORM1)
1976 FAIL_IF(getput_arg(compiler, FLOAT_DATA(op) | LOAD_DATA, TMP_FREG1, src1, src1w, dst, dstw));
1977 else if (flags & ALT_FORM2)
1978 FAIL_IF(getput_arg(compiler, FLOAT_DATA(op) | LOAD_DATA, TMP_FREG2, src2, src2w, dst, dstw));
1980 if (flags & ALT_FORM1)
1982 if (flags & ALT_FORM2)
1985 switch (GET_OPCODE(op)) {
1987 FAIL_IF(push_inst(compiler, SELECT_FOP(op, FADDS, FADD) | FD(dst_r) | FA(src1) | FB(src2)));
1991 FAIL_IF(push_inst(compiler, SELECT_FOP(op, FSUBS, FSUB) | FD(dst_r) | FA(src1) | FB(src2)));
1995 FAIL_IF(push_inst(compiler, SELECT_FOP(op, FMULS, FMUL) | FD(dst_r) | FA(src1) | FC(src2) /* FMUL use FC as src2 */));
1999 FAIL_IF(push_inst(compiler, SELECT_FOP(op, FDIVS, FDIV) | FD(dst_r) | FA(src1) | FB(src2)));
2003 if (dst_r == TMP_FREG2)
2004 FAIL_IF(emit_op_mem2(compiler, FLOAT_DATA(op), TMP_FREG2, dst, dstw, 0, 0));
2006 return SLJIT_SUCCESS;
2012 /* --------------------------------------------------------------------- */
2013 /* Other instructions */
2014 /* --------------------------------------------------------------------- */
2016 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_fast_enter(struct sljit_compiler *compiler, sljit_s32 dst, sljit_sw dstw)
2019 CHECK(check_sljit_emit_fast_enter(compiler, dst, dstw));
2020 ADJUST_LOCAL_OFFSET(dst, dstw);
2022 /* For UNUSED dst. Uncommon, but possible. */
2023 if (dst == SLJIT_UNUSED)
2024 return SLJIT_SUCCESS;
2026 if (FAST_IS_REG(dst))
2027 return push_inst(compiler, MFLR | D(dst));
2030 FAIL_IF(push_inst(compiler, MFLR | D(TMP_REG2)));
2031 return emit_op(compiler, SLJIT_MOV, WORD_DATA, dst, dstw, TMP_REG1, 0, TMP_REG2, 0);
2034 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_fast_return(struct sljit_compiler *compiler, sljit_s32 src, sljit_sw srcw)
2037 CHECK(check_sljit_emit_fast_return(compiler, src, srcw));
2038 ADJUST_LOCAL_OFFSET(src, srcw);
2040 if (FAST_IS_REG(src))
2041 FAIL_IF(push_inst(compiler, MTLR | S(src)));
2043 if (src & SLJIT_MEM)
2044 FAIL_IF(emit_op(compiler, SLJIT_MOV, WORD_DATA, TMP_REG2, 0, TMP_REG1, 0, src, srcw));
2045 else if (src & SLJIT_IMM)
2046 FAIL_IF(load_immediate(compiler, TMP_REG2, srcw));
2047 FAIL_IF(push_inst(compiler, MTLR | S(TMP_REG2)));
2049 return push_inst(compiler, BLR);
2052 /* --------------------------------------------------------------------- */
2053 /* Conditional instructions */
2054 /* --------------------------------------------------------------------- */
2056 SLJIT_API_FUNC_ATTRIBUTE struct sljit_label* sljit_emit_label(struct sljit_compiler *compiler)
2058 struct sljit_label *label;
2061 CHECK_PTR(check_sljit_emit_label(compiler));
2063 if (compiler->last_label && compiler->last_label->size == compiler->size)
2064 return compiler->last_label;
2066 label = (struct sljit_label*)ensure_abuf(compiler, sizeof(struct sljit_label));
2067 PTR_FAIL_IF(!label);
2068 set_label(label, compiler);
2072 static sljit_ins get_bo_bi_flags(sljit_s32 type)
2076 return (12 << 21) | (2 << 16);
2078 case SLJIT_NOT_EQUAL:
2079 return (4 << 21) | (2 << 16);
2082 case SLJIT_LESS_F64:
2083 return (12 << 21) | ((4 + 0) << 16);
2085 case SLJIT_GREATER_EQUAL:
2086 case SLJIT_GREATER_EQUAL_F64:
2087 return (4 << 21) | ((4 + 0) << 16);
2090 case SLJIT_GREATER_F64:
2091 return (12 << 21) | ((4 + 1) << 16);
2093 case SLJIT_LESS_EQUAL:
2094 case SLJIT_LESS_EQUAL_F64:
2095 return (4 << 21) | ((4 + 1) << 16);
2097 case SLJIT_SIG_LESS:
2098 return (12 << 21) | (0 << 16);
2100 case SLJIT_SIG_GREATER_EQUAL:
2101 return (4 << 21) | (0 << 16);
2103 case SLJIT_SIG_GREATER:
2104 return (12 << 21) | (1 << 16);
2106 case SLJIT_SIG_LESS_EQUAL:
2107 return (4 << 21) | (1 << 16);
2109 case SLJIT_OVERFLOW:
2110 case SLJIT_MUL_OVERFLOW:
2111 return (12 << 21) | (3 << 16);
2113 case SLJIT_NOT_OVERFLOW:
2114 case SLJIT_MUL_NOT_OVERFLOW:
2115 return (4 << 21) | (3 << 16);
2117 case SLJIT_EQUAL_F64:
2118 return (12 << 21) | ((4 + 2) << 16);
2120 case SLJIT_NOT_EQUAL_F64:
2121 return (4 << 21) | ((4 + 2) << 16);
2123 case SLJIT_UNORDERED_F64:
2124 return (12 << 21) | ((4 + 3) << 16);
2126 case SLJIT_ORDERED_F64:
2127 return (4 << 21) | ((4 + 3) << 16);
2130 SLJIT_ASSERT(type >= SLJIT_JUMP && type <= SLJIT_CALL3);
2135 SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_jump(struct sljit_compiler *compiler, sljit_s32 type)
2137 struct sljit_jump *jump;
2138 sljit_ins bo_bi_flags;
2141 CHECK_PTR(check_sljit_emit_jump(compiler, type));
2143 bo_bi_flags = get_bo_bi_flags(type & 0xff);
2147 jump = (struct sljit_jump*)ensure_abuf(compiler, sizeof(struct sljit_jump));
2149 set_jump(jump, compiler, type & SLJIT_REWRITABLE_JUMP);
2152 /* In PPC, we don't need to touch the arguments. */
2153 if (type < SLJIT_JUMP)
2154 jump->flags |= IS_COND;
2155 #if (defined SLJIT_PASS_ENTRY_ADDR_TO_CALL && SLJIT_PASS_ENTRY_ADDR_TO_CALL)
2156 if (type >= SLJIT_CALL0)
2157 jump->flags |= IS_CALL;
2160 PTR_FAIL_IF(emit_const(compiler, TMP_CALL_REG, 0));
2161 PTR_FAIL_IF(push_inst(compiler, MTCTR | S(TMP_CALL_REG)));
2162 jump->addr = compiler->size;
2163 PTR_FAIL_IF(push_inst(compiler, BCCTR | bo_bi_flags | (type >= SLJIT_FAST_CALL ? 1 : 0)));
2167 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_ijump(struct sljit_compiler *compiler, sljit_s32 type, sljit_s32 src, sljit_sw srcw)
2169 struct sljit_jump *jump = NULL;
2173 CHECK(check_sljit_emit_ijump(compiler, type, src, srcw));
2174 ADJUST_LOCAL_OFFSET(src, srcw);
2176 if (FAST_IS_REG(src)) {
2177 #if (defined SLJIT_PASS_ENTRY_ADDR_TO_CALL && SLJIT_PASS_ENTRY_ADDR_TO_CALL)
2178 if (type >= SLJIT_CALL0) {
2179 FAIL_IF(push_inst(compiler, OR | S(src) | A(TMP_CALL_REG) | B(src)));
2180 src_r = TMP_CALL_REG;
2187 } else if (src & SLJIT_IMM) {
2188 jump = (struct sljit_jump*)ensure_abuf(compiler, sizeof(struct sljit_jump));
2190 set_jump(jump, compiler, JUMP_ADDR);
2191 jump->u.target = srcw;
2192 #if (defined SLJIT_PASS_ENTRY_ADDR_TO_CALL && SLJIT_PASS_ENTRY_ADDR_TO_CALL)
2193 if (type >= SLJIT_CALL0)
2194 jump->flags |= IS_CALL;
2196 FAIL_IF(emit_const(compiler, TMP_CALL_REG, 0));
2197 src_r = TMP_CALL_REG;
2200 FAIL_IF(emit_op(compiler, SLJIT_MOV, WORD_DATA, TMP_CALL_REG, 0, TMP_REG1, 0, src, srcw));
2201 src_r = TMP_CALL_REG;
2204 FAIL_IF(push_inst(compiler, MTCTR | S(src_r)));
2206 jump->addr = compiler->size;
2207 return push_inst(compiler, BCCTR | (20 << 21) | (type >= SLJIT_FAST_CALL ? 1 : 0));
2210 /* Get a bit from CR, all other bits are zeroed. */
2211 #define GET_CR_BIT(bit, dst) \
2212 FAIL_IF(push_inst(compiler, MFCR | D(dst))); \
2213 FAIL_IF(push_inst(compiler, RLWINM | S(dst) | A(dst) | ((1 + (bit)) << 11) | (31 << 6) | (31 << 1)));
2215 #define INVERT_BIT(dst) \
2216 FAIL_IF(push_inst(compiler, XORI | S(dst) | A(dst) | 0x1));
2218 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_op_flags(struct sljit_compiler *compiler, sljit_s32 op,
2219 sljit_s32 dst, sljit_sw dstw,
2220 sljit_s32 src, sljit_sw srcw,
2223 sljit_s32 reg, input_flags;
2224 sljit_s32 flags = GET_ALL_FLAGS(op);
2225 sljit_sw original_dstw = dstw;
2228 CHECK(check_sljit_emit_op_flags(compiler, op, dst, dstw, src, srcw, type));
2229 ADJUST_LOCAL_OFFSET(dst, dstw);
2231 if (dst == SLJIT_UNUSED)
2232 return SLJIT_SUCCESS;
2234 op = GET_OPCODE(op);
2235 reg = (op < SLJIT_ADD && FAST_IS_REG(dst)) ? dst : TMP_REG2;
2237 compiler->cache_arg = 0;
2238 compiler->cache_argw = 0;
2239 if (op >= SLJIT_ADD && (src & SLJIT_MEM)) {
2240 ADJUST_LOCAL_OFFSET(src, srcw);
2241 #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)
2242 input_flags = (flags & SLJIT_I32_OP) ? INT_DATA : WORD_DATA;
2244 input_flags = WORD_DATA;
2246 FAIL_IF(emit_op_mem2(compiler, input_flags | LOAD_DATA, TMP_REG1, src, srcw, dst, dstw));
2251 switch (type & 0xff) {
2256 case SLJIT_NOT_EQUAL:
2262 case SLJIT_LESS_F64:
2263 GET_CR_BIT(4 + 0, reg);
2266 case SLJIT_GREATER_EQUAL:
2267 case SLJIT_GREATER_EQUAL_F64:
2268 GET_CR_BIT(4 + 0, reg);
2273 case SLJIT_GREATER_F64:
2274 GET_CR_BIT(4 + 1, reg);
2277 case SLJIT_LESS_EQUAL:
2278 case SLJIT_LESS_EQUAL_F64:
2279 GET_CR_BIT(4 + 1, reg);
2283 case SLJIT_SIG_LESS:
2287 case SLJIT_SIG_GREATER_EQUAL:
2292 case SLJIT_SIG_GREATER:
2296 case SLJIT_SIG_LESS_EQUAL:
2301 case SLJIT_OVERFLOW:
2302 case SLJIT_MUL_OVERFLOW:
2306 case SLJIT_NOT_OVERFLOW:
2307 case SLJIT_MUL_NOT_OVERFLOW:
2312 case SLJIT_EQUAL_F64:
2313 GET_CR_BIT(4 + 2, reg);
2316 case SLJIT_NOT_EQUAL_F64:
2317 GET_CR_BIT(4 + 2, reg);
2321 case SLJIT_UNORDERED_F64:
2322 GET_CR_BIT(4 + 3, reg);
2325 case SLJIT_ORDERED_F64:
2326 GET_CR_BIT(4 + 3, reg);
2331 SLJIT_ASSERT_STOP();
2335 if (op < SLJIT_ADD) {
2336 #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)
2337 if (op == SLJIT_MOV)
2338 input_flags = WORD_DATA;
2341 input_flags = INT_DATA;
2345 input_flags = WORD_DATA;
2347 if (reg != TMP_REG2)
2348 return SLJIT_SUCCESS;
2349 return emit_op(compiler, op, input_flags, dst, dstw, TMP_REG1, 0, TMP_REG2, 0);
2352 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) \
2353 || (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
2354 compiler->skip_checks = 1;
2356 return sljit_emit_op2(compiler, op | flags, dst, original_dstw, src, srcw, TMP_REG2, 0);
2359 SLJIT_API_FUNC_ATTRIBUTE struct sljit_const* sljit_emit_const(struct sljit_compiler *compiler, sljit_s32 dst, sljit_sw dstw, sljit_sw init_value)
2361 struct sljit_const *const_;
2365 CHECK_PTR(check_sljit_emit_const(compiler, dst, dstw, init_value));
2366 ADJUST_LOCAL_OFFSET(dst, dstw);
2368 const_ = (struct sljit_const*)ensure_abuf(compiler, sizeof(struct sljit_const));
2369 PTR_FAIL_IF(!const_);
2370 set_const(const_, compiler);
2372 reg = SLOW_IS_REG(dst) ? dst : TMP_REG2;
2374 PTR_FAIL_IF(emit_const(compiler, reg, init_value));
2376 if (dst & SLJIT_MEM)
2377 PTR_FAIL_IF(emit_op(compiler, SLJIT_MOV, WORD_DATA, dst, dstw, TMP_REG1, 0, TMP_REG2, 0));