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 27 SLJIT_API_FUNC_ATTRIBUTE SLJIT_CONST char* sljit_get_platform_name(void) 28 { 29 return "PowerPC" SLJIT_CPUINFO; 30 } 31 32 /* Length of an instruction word. 33 Both for ppc-32 and ppc-64. */ 34 typedef sljit_ui sljit_ins; 35 36 #ifdef _AIX 37 #include <sys/cache.h> 38 #endif 39 40 #define TMP_REG1 (SLJIT_NO_REGISTERS + 1) 41 #define TMP_REG2 (SLJIT_NO_REGISTERS + 2) 42 #define TMP_REG3 (SLJIT_NO_REGISTERS + 3) 43 #define ZERO_REG (SLJIT_NO_REGISTERS + 4) 44 45 #define TMP_FREG1 (SLJIT_FLOAT_REG4 + 1) 46 #define TMP_FREG2 (SLJIT_FLOAT_REG4 + 2) 47 48 static SLJIT_CONST sljit_ub reg_map[SLJIT_NO_REGISTERS + 5] = { 49 0, 3, 4, 5, 6, 7, 30, 29, 28, 27, 26, 1, 8, 9, 10, 31 50 }; 51 52 /* --------------------------------------------------------------------- */ 53 /* Instrucion forms */ 54 /* --------------------------------------------------------------------- */ 55 #define D(d) (reg_map[d] << 21) 56 #define S(s) (reg_map[s] << 21) 57 #define A(a) (reg_map[a] << 16) 58 #define B(b) (reg_map[b] << 11) 59 #define C(c) (reg_map[c] << 6) 60 #define FD(fd) ((fd) << 21) 61 #define FA(fa) ((fa) << 16) 62 #define FB(fb) ((fb) << 11) 63 #define FC(fc) ((fc) << 6) 64 #define IMM(imm) ((imm) & 0xffff) 65 #define CRD(d) ((d) << 21) 66 67 /* Instruction bit sections. 68 OE and Rc flag (see ALT_SET_FLAGS). */ 69 #define OERC(flags) (((flags & ALT_SET_FLAGS) >> 10) | (flags & ALT_SET_FLAGS)) 70 /* Rc flag (see ALT_SET_FLAGS). */ 71 #define RC(flags) ((flags & ALT_SET_FLAGS) >> 10) 72 #define HI(opcode) ((opcode) << 26) 73 #define LO(opcode) ((opcode) << 1) 74 75 #define ADD (HI(31) | LO(266)) 76 #define ADDC (HI(31) | LO(10)) 77 #define ADDE (HI(31) | LO(138)) 78 #define ADDI (HI(14)) 79 #define ADDIC (HI(13)) 80 #define ADDIS (HI(15)) 81 #define ADDME (HI(31) | LO(234)) 82 #define AND (HI(31) | LO(28)) 83 #define ANDI (HI(28)) 84 #define ANDIS (HI(29)) 85 #define Bx (HI(18)) 86 #define BCx (HI(16)) 87 #define BCCTR (HI(19) | LO(528) | (3 << 11)) 88 #define BLR (HI(19) | LO(16) | (0x14 << 21)) 89 #define CNTLZD (HI(31) | LO(58)) 90 #define CNTLZW (HI(31) | LO(26)) 91 #define CMP (HI(31) | LO(0)) 92 #define CMPI (HI(11)) 93 #define CMPL (HI(31) | LO(32)) 94 #define CMPLI (HI(10)) 95 #define CROR (HI(19) | LO(449)) 96 #define DIVD (HI(31) | LO(489)) 97 #define DIVDU (HI(31) | LO(457)) 98 #define DIVW (HI(31) | LO(491)) 99 #define DIVWU (HI(31) | LO(459)) 100 #define EXTSB (HI(31) | LO(954)) 101 #define EXTSH (HI(31) | LO(922)) 102 #define EXTSW (HI(31) | LO(986)) 103 #define FABS (HI(63) | LO(264)) 104 #define FADD (HI(63) | LO(21)) 105 #define FCMPU (HI(63) | LO(0)) 106 #define FDIV (HI(63) | LO(18)) 107 #define FMR (HI(63) | LO(72)) 108 #define FMUL (HI(63) | LO(25)) 109 #define FNEG (HI(63) | LO(40)) 110 #define FSUB (HI(63) | LO(20)) 111 #define LD (HI(58) | 0) 112 #define LWZ (HI(32)) 113 #define MFCR (HI(31) | LO(19)) 114 #define MFLR (HI(31) | LO(339) | 0x80000) 115 #define MFXER (HI(31) | LO(339) | 0x10000) 116 #define MTCTR (HI(31) | LO(467) | 0x90000) 117 #define MTLR (HI(31) | LO(467) | 0x80000) 118 #define MTXER (HI(31) | LO(467) | 0x10000) 119 #define MULHD (HI(31) | LO(73)) 120 #define MULHDU (HI(31) | LO(9)) 121 #define MULHW (HI(31) | LO(75)) 122 #define MULHWU (HI(31) | LO(11)) 123 #define MULLD (HI(31) | LO(233)) 124 #define MULLI (HI(7)) 125 #define MULLW (HI(31) | LO(235)) 126 #define NEG (HI(31) | LO(104)) 127 #define NOP (HI(24)) 128 #define NOR (HI(31) | LO(124)) 129 #define OR (HI(31) | LO(444)) 130 #define ORI (HI(24)) 131 #define ORIS (HI(25)) 132 #define RLDICL (HI(30)) 133 #define RLWINM (HI(21)) 134 #define SLD (HI(31) | LO(27)) 135 #define SLW (HI(31) | LO(24)) 136 #define SRAD (HI(31) | LO(794)) 137 #define SRADI (HI(31) | LO(413 << 1)) 138 #define SRAW (HI(31) | LO(792)) 139 #define SRAWI (HI(31) | LO(824)) 140 #define SRD (HI(31) | LO(539)) 141 #define SRW (HI(31) | LO(536)) 142 #define STD (HI(62) | 0) 143 #define STDU (HI(62) | 1) 144 #define STDUX (HI(31) | LO(181)) 145 #define STW (HI(36)) 146 #define STWU (HI(37)) 147 #define STWUX (HI(31) | LO(183)) 148 #define SUBF (HI(31) | LO(40)) 149 #define SUBFC (HI(31) | LO(8)) 150 #define SUBFE (HI(31) | LO(136)) 151 #define SUBFIC (HI(8)) 152 #define XOR (HI(31) | LO(316)) 153 #define XORI (HI(26)) 154 #define XORIS (HI(27)) 155 156 #define SIMM_MAX (0x7fff) 157 #define SIMM_MIN (-0x8000) 158 #define UIMM_MAX (0xffff) 159 160 #if (defined SLJIT_INDIRECT_CALL && SLJIT_INDIRECT_CALL) 161 SLJIT_API_FUNC_ATTRIBUTE void sljit_set_function_context(void** func_ptr, struct sljit_function_context* context, sljit_w addr, void* func) 162 { 163 sljit_w* ptrs; 164 if (func_ptr) 165 *func_ptr = (void*)context; 166 ptrs = (sljit_w*)func; 167 context->addr = addr ? addr : ptrs[0]; 168 context->r2 = ptrs[1]; 169 context->r11 = ptrs[2]; 170 } 171 #endif 172 173 static int push_inst(struct sljit_compiler *compiler, sljit_ins ins) 174 { 175 sljit_ins *ptr = (sljit_ins*)ensure_buf(compiler, sizeof(sljit_ins)); 176 FAIL_IF(!ptr); 177 *ptr = ins; 178 compiler->size++; 179 return SLJIT_SUCCESS; 180 } 181 182 static SLJIT_INLINE int optimize_jump(struct sljit_jump *jump, sljit_ins *code_ptr, sljit_ins *code) 183 { 184 sljit_w diff; 185 sljit_uw target_addr; 186 187 if (jump->flags & SLJIT_REWRITABLE_JUMP) 188 return 0; 189 190 if (jump->flags & JUMP_ADDR) 191 target_addr = jump->u.target; 192 else { 193 SLJIT_ASSERT(jump->flags & JUMP_LABEL); 194 target_addr = (sljit_uw)(code + jump->u.label->size); 195 } 196 diff = ((sljit_w)target_addr - (sljit_w)(code_ptr)) & ~0x3l; 197 198 if (jump->flags & UNCOND_B) { 199 if (diff <= 0x01ffffff && diff >= -0x02000000) { 200 jump->flags |= PATCH_B; 201 return 1; 202 } 203 if (target_addr <= 0x03ffffff) { 204 jump->flags |= PATCH_B | ABSOLUTE_B; 205 return 1; 206 } 207 } 208 else { 209 if (diff <= 0x7fff && diff >= -0x8000) { 210 jump->flags |= PATCH_B; 211 return 1; 212 } 213 if (target_addr <= 0xffff) { 214 jump->flags |= PATCH_B | ABSOLUTE_B; 215 return 1; 216 } 217 } 218 return 0; 219 } 220 221 SLJIT_API_FUNC_ATTRIBUTE void* sljit_generate_code(struct sljit_compiler *compiler) 222 { 223 struct sljit_memory_fragment *buf; 224 sljit_ins *code; 225 sljit_ins *code_ptr; 226 sljit_ins *buf_ptr; 227 sljit_ins *buf_end; 228 sljit_uw word_count; 229 sljit_uw addr; 230 231 struct sljit_label *label; 232 struct sljit_jump *jump; 233 struct sljit_const *const_; 234 235 CHECK_ERROR_PTR(); 236 check_sljit_generate_code(compiler); 237 reverse_buf(compiler); 238 239 #if (defined SLJIT_INDIRECT_CALL && SLJIT_INDIRECT_CALL) 240 #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64) 241 compiler->size += (compiler->size & 0x1) + (sizeof(struct sljit_function_context) / sizeof(sljit_ins)); 242 #else 243 compiler->size += (sizeof(struct sljit_function_context) / sizeof(sljit_ins)); 244 #endif 245 #endif 246 code = (sljit_ins*)SLJIT_MALLOC_EXEC(compiler->size * sizeof(sljit_ins)); 247 PTR_FAIL_WITH_EXEC_IF(code); 248 buf = compiler->buf; 249 250 code_ptr = code; 251 word_count = 0; 252 label = compiler->labels; 253 jump = compiler->jumps; 254 const_ = compiler->consts; 255 do { 256 buf_ptr = (sljit_ins*)buf->memory; 257 buf_end = buf_ptr + (buf->used_size >> 2); 258 do { 259 *code_ptr = *buf_ptr++; 260 SLJIT_ASSERT(!label || label->size >= word_count); 261 SLJIT_ASSERT(!jump || jump->addr >= word_count); 262 SLJIT_ASSERT(!const_ || const_->addr >= word_count); 263 /* These structures are ordered by their address. */ 264 if (label && label->size == word_count) { 265 /* Just recording the address. */ 266 label->addr = (sljit_uw)code_ptr; 267 label->size = code_ptr - code; 268 label = label->next; 269 } 270 if (jump && jump->addr == word_count) { 271 #if (defined SLJIT_CONFIG_PPC_32 && SLJIT_CONFIG_PPC_32) 272 jump->addr = (sljit_uw)(code_ptr - 3); 273 #else 274 jump->addr = (sljit_uw)(code_ptr - 6); 275 #endif 276 if (optimize_jump(jump, code_ptr, code)) { 277 #if (defined SLJIT_CONFIG_PPC_32 && SLJIT_CONFIG_PPC_32) 278 code_ptr[-3] = code_ptr[0]; 279 code_ptr -= 3; 280 #else 281 code_ptr[-6] = code_ptr[0]; 282 code_ptr -= 6; 283 #endif 284 } 285 jump = jump->next; 286 } 287 if (const_ && const_->addr == word_count) { 288 /* Just recording the address. */ 289 const_->addr = (sljit_uw)code_ptr; 290 const_ = const_->next; 291 } 292 code_ptr ++; 293 word_count ++; 294 } while (buf_ptr < buf_end); 295 296 buf = buf->next; 297 } while (buf); 298 299 if (label && label->size == word_count) { 300 label->addr = (sljit_uw)code_ptr; 301 label->size = code_ptr - code; 302 label = label->next; 303 } 304 305 SLJIT_ASSERT(!label); 306 SLJIT_ASSERT(!jump); 307 SLJIT_ASSERT(!const_); 308 #if (defined SLJIT_INDIRECT_CALL && SLJIT_INDIRECT_CALL) 309 SLJIT_ASSERT(code_ptr - code <= (int)compiler->size - (sizeof(struct sljit_function_context) / sizeof(sljit_ins))); 310 #else 311 SLJIT_ASSERT(code_ptr - code <= (int)compiler->size); 312 #endif 313 314 jump = compiler->jumps; 315 while (jump) { 316 do { 317 addr = (jump->flags & JUMP_LABEL) ? jump->u.label->addr : jump->u.target; 318 buf_ptr = (sljit_ins*)jump->addr; 319 if (jump->flags & PATCH_B) { 320 if (jump->flags & UNCOND_B) { 321 if (!(jump->flags & ABSOLUTE_B)) { 322 addr = addr - jump->addr; 323 SLJIT_ASSERT((sljit_w)addr <= 0x01ffffff && (sljit_w)addr >= -0x02000000); 324 *buf_ptr = Bx | (addr & 0x03fffffc) | ((*buf_ptr) & 0x1); 325 } 326 else { 327 SLJIT_ASSERT(addr <= 0x03ffffff); 328 *buf_ptr = Bx | (addr & 0x03fffffc) | 0x2 | ((*buf_ptr) & 0x1); 329 } 330 } 331 else { 332 if (!(jump->flags & ABSOLUTE_B)) { 333 addr = addr - jump->addr; 334 SLJIT_ASSERT((sljit_w)addr <= 0x7fff && (sljit_w)addr >= -0x8000); 335 *buf_ptr = BCx | (addr & 0xfffc) | ((*buf_ptr) & 0x03ff0001); 336 } 337 else { 338 addr = addr & ~0x3l; 339 SLJIT_ASSERT(addr <= 0xffff); 340 *buf_ptr = BCx | (addr & 0xfffc) | 0x2 | ((*buf_ptr) & 0x03ff0001); 341 } 342 343 } 344 break; 345 } 346 /* Set the fields of immediate loads. */ 347 #if (defined SLJIT_CONFIG_PPC_32 && SLJIT_CONFIG_PPC_32) 348 buf_ptr[0] = (buf_ptr[0] & 0xffff0000) | ((addr >> 16) & 0xffff); 349 buf_ptr[1] = (buf_ptr[1] & 0xffff0000) | (addr & 0xffff); 350 #else 351 buf_ptr[0] = (buf_ptr[0] & 0xffff0000) | ((addr >> 48) & 0xffff); 352 buf_ptr[1] = (buf_ptr[1] & 0xffff0000) | ((addr >> 32) & 0xffff); 353 buf_ptr[3] = (buf_ptr[3] & 0xffff0000) | ((addr >> 16) & 0xffff); 354 buf_ptr[4] = (buf_ptr[4] & 0xffff0000) | (addr & 0xffff); 355 #endif 356 } while (0); 357 jump = jump->next; 358 } 359 360 SLJIT_CACHE_FLUSH(code, code_ptr); 361 compiler->error = SLJIT_ERR_COMPILED; 362 compiler->executable_size = compiler->size * sizeof(sljit_ins); 363 364 #if (defined SLJIT_INDIRECT_CALL && SLJIT_INDIRECT_CALL) 365 #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64) 366 if (((sljit_w)code_ptr) & 0x4) 367 code_ptr++; 368 sljit_set_function_context(NULL, (struct sljit_function_context*)code_ptr, (sljit_w)code, (void*)sljit_generate_code); 369 return code_ptr; 370 #else 371 sljit_set_function_context(NULL, (struct sljit_function_context*)code_ptr, (sljit_w)code, (void*)sljit_generate_code); 372 return code_ptr; 373 #endif 374 #else 375 return code; 376 #endif 377 } 378 379 /* --------------------------------------------------------------------- */ 380 /* Entry, exit */ 381 /* --------------------------------------------------------------------- */ 382 383 /* inp_flags: */ 384 385 /* Creates an index in data_transfer_insts array. */ 386 #define LOAD_DATA 0x01 387 #define INDEXED 0x02 388 #define WRITE_BACK 0x04 389 #define WORD_DATA 0x00 390 #define BYTE_DATA 0x08 391 #define HALF_DATA 0x10 392 #define INT_DATA 0x18 393 #define SIGNED_DATA 0x20 394 /* Separates integer and floating point registers */ 395 #define GPR_REG 0x3f 396 #define DOUBLE_DATA 0x40 397 398 #define MEM_MASK 0x7f 399 400 /* Other inp_flags. */ 401 402 #define ARG_TEST 0x000100 403 /* Integer opertion and set flags -> requires exts on 64 bit systems. */ 404 #define ALT_SIGN_EXT 0x000200 405 /* This flag affects the RC() and OERC() macros. */ 406 #define ALT_SET_FLAGS 0x000400 407 #define ALT_FORM1 0x010000 408 #define ALT_FORM2 0x020000 409 #define ALT_FORM3 0x040000 410 #define ALT_FORM4 0x080000 411 #define ALT_FORM5 0x100000 412 #define ALT_FORM6 0x200000 413 414 /* Source and destination is register. */ 415 #define REG_DEST 0x000001 416 #define REG1_SOURCE 0x000002 417 #define REG2_SOURCE 0x000004 418 /* getput_arg_fast returned true. */ 419 #define FAST_DEST 0x000008 420 /* Multiple instructions are required. */ 421 #define SLOW_DEST 0x000010 422 /* 423 ALT_SIGN_EXT 0x000200 424 ALT_SET_FLAGS 0x000400 425 ALT_FORM1 0x010000 426 ... 427 ALT_FORM6 0x200000 */ 428 429 #if (defined SLJIT_CONFIG_PPC_32 && SLJIT_CONFIG_PPC_32) 430 #include "sljitNativePPC_32.c" 431 #else 432 #include "sljitNativePPC_64.c" 433 #endif 434 435 #if (defined SLJIT_CONFIG_PPC_32 && SLJIT_CONFIG_PPC_32) 436 #define STACK_STORE STW 437 #define STACK_LOAD LWZ 438 #else 439 #define STACK_STORE STD 440 #define STACK_LOAD LD 441 #endif 442 443 SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_enter(struct sljit_compiler *compiler, int args, int temporaries, int saveds, int local_size) 444 { 445 CHECK_ERROR(); 446 check_sljit_emit_enter(compiler, args, temporaries, saveds, local_size); 447 448 compiler->temporaries = temporaries; 449 compiler->saveds = saveds; 450 #if (defined SLJIT_DEBUG && SLJIT_DEBUG) 451 compiler->logical_local_size = local_size; 452 #endif 453 454 FAIL_IF(push_inst(compiler, MFLR | D(0))); 455 FAIL_IF(push_inst(compiler, STACK_STORE | S(ZERO_REG) | A(SLJIT_LOCALS_REG) | IMM(-(int)(sizeof(sljit_w))) )); 456 if (saveds >= 1) 457 FAIL_IF(push_inst(compiler, STACK_STORE | S(SLJIT_SAVED_REG1) | A(SLJIT_LOCALS_REG) | IMM(-2 * (int)(sizeof(sljit_w))) )); 458 if (saveds >= 2) 459 FAIL_IF(push_inst(compiler, STACK_STORE | S(SLJIT_SAVED_REG2) | A(SLJIT_LOCALS_REG) | IMM(-3 * (int)(sizeof(sljit_w))) )); 460 if (saveds >= 3) 461 FAIL_IF(push_inst(compiler, STACK_STORE | S(SLJIT_SAVED_REG3) | A(SLJIT_LOCALS_REG) | IMM(-4 * (int)(sizeof(sljit_w))) )); 462 if (saveds >= 4) 463 FAIL_IF(push_inst(compiler, STACK_STORE | S(SLJIT_SAVED_EREG1) | A(SLJIT_LOCALS_REG) | IMM(-5 * (int)(sizeof(sljit_w))) )); 464 if (saveds >= 5) 465 FAIL_IF(push_inst(compiler, STACK_STORE | S(SLJIT_SAVED_EREG2) | A(SLJIT_LOCALS_REG) | IMM(-6 * (int)(sizeof(sljit_w))) )); 466 FAIL_IF(push_inst(compiler, STACK_STORE | S(0) | A(SLJIT_LOCALS_REG) | IMM(sizeof(sljit_w)) )); 467 468 FAIL_IF(push_inst(compiler, ADDI | D(ZERO_REG) | A(0) | 0)); 469 if (args >= 1) 470 FAIL_IF(push_inst(compiler, OR | S(SLJIT_TEMPORARY_REG1) | A(SLJIT_SAVED_REG1) | B(SLJIT_TEMPORARY_REG1))); 471 if (args >= 2) 472 FAIL_IF(push_inst(compiler, OR | S(SLJIT_TEMPORARY_REG2) | A(SLJIT_SAVED_REG2) | B(SLJIT_TEMPORARY_REG2))); 473 if (args >= 3) 474 FAIL_IF(push_inst(compiler, OR | S(SLJIT_TEMPORARY_REG3) | A(SLJIT_SAVED_REG3) | B(SLJIT_TEMPORARY_REG3))); 475 476 #if (defined SLJIT_INDIRECT_CALL && SLJIT_INDIRECT_CALL) 477 compiler->local_size = (1 + saveds + 6 + 8) * sizeof(sljit_w) + local_size; 478 #else 479 compiler->local_size = (1 + saveds + 2) * sizeof(sljit_w) + local_size; 480 #endif 481 compiler->local_size = (compiler->local_size + 15) & ~0xf; 482 483 #if (defined SLJIT_CONFIG_PPC_32 && SLJIT_CONFIG_PPC_32) 484 if (compiler->local_size <= SIMM_MAX) 485 FAIL_IF(push_inst(compiler, STWU | S(SLJIT_LOCALS_REG) | A(SLJIT_LOCALS_REG) | IMM(-compiler->local_size))); 486 else { 487 FAIL_IF(load_immediate(compiler, 0, -compiler->local_size)); 488 FAIL_IF(push_inst(compiler, STWUX | S(SLJIT_LOCALS_REG) | A(SLJIT_LOCALS_REG) | B(0))); 489 } 490 #else 491 if (compiler->local_size <= SIMM_MAX) 492 FAIL_IF(push_inst(compiler, STDU | S(SLJIT_LOCALS_REG) | A(SLJIT_LOCALS_REG) | IMM(-compiler->local_size))); 493 else { 494 FAIL_IF(load_immediate(compiler, 0, -compiler->local_size)); 495 FAIL_IF(push_inst(compiler, STDUX | S(SLJIT_LOCALS_REG) | A(SLJIT_LOCALS_REG) | B(0))); 496 } 497 #endif 498 499 return SLJIT_SUCCESS; 500 } 501 502 SLJIT_API_FUNC_ATTRIBUTE void sljit_set_context(struct sljit_compiler *compiler, int args, int temporaries, int saveds, int local_size) 503 { 504 CHECK_ERROR_VOID(); 505 check_sljit_set_context(compiler, args, temporaries, saveds, local_size); 506 507 compiler->temporaries = temporaries; 508 compiler->saveds = saveds; 509 #if (defined SLJIT_DEBUG && SLJIT_DEBUG) 510 compiler->logical_local_size = local_size; 511 #endif 512 513 #if (defined SLJIT_INDIRECT_CALL && SLJIT_INDIRECT_CALL) 514 compiler->local_size = (1 + saveds + 6 + 8) * sizeof(sljit_w) + local_size; 515 #else 516 compiler->local_size = (1 + saveds + 2) * sizeof(sljit_w) + local_size; 517 #endif 518 compiler->local_size = (compiler->local_size + 15) & ~0xf; 519 } 520 521 SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_return(struct sljit_compiler *compiler, int op, int src, sljit_w srcw) 522 { 523 CHECK_ERROR(); 524 check_sljit_emit_return(compiler, op, src, srcw); 525 526 FAIL_IF(emit_mov_before_return(compiler, op, src, srcw)); 527 528 if (compiler->local_size <= SIMM_MAX) 529 FAIL_IF(push_inst(compiler, ADDI | D(SLJIT_LOCALS_REG) | A(SLJIT_LOCALS_REG) | IMM(compiler->local_size))); 530 else { 531 FAIL_IF(load_immediate(compiler, 0, compiler->local_size)); 532 FAIL_IF(push_inst(compiler, ADD | D(SLJIT_LOCALS_REG) | A(SLJIT_LOCALS_REG) | B(0))); 533 } 534 535 FAIL_IF(push_inst(compiler, STACK_LOAD | D(0) | A(SLJIT_LOCALS_REG) | IMM(sizeof(sljit_w)))); 536 if (compiler->saveds >= 5) 537 FAIL_IF(push_inst(compiler, STACK_LOAD | D(SLJIT_SAVED_EREG2) | A(SLJIT_LOCALS_REG) | IMM(-6 * (int)(sizeof(sljit_w))) )); 538 if (compiler->saveds >= 4) 539 FAIL_IF(push_inst(compiler, STACK_LOAD | D(SLJIT_SAVED_EREG1) | A(SLJIT_LOCALS_REG) | IMM(-5 * (int)(sizeof(sljit_w))) )); 540 if (compiler->saveds >= 3) 541 FAIL_IF(push_inst(compiler, STACK_LOAD | D(SLJIT_SAVED_REG3) | A(SLJIT_LOCALS_REG) | IMM(-4 * (int)(sizeof(sljit_w))) )); 542 if (compiler->saveds >= 2) 543 FAIL_IF(push_inst(compiler, STACK_LOAD | D(SLJIT_SAVED_REG2) | A(SLJIT_LOCALS_REG) | IMM(-3 * (int)(sizeof(sljit_w))) )); 544 if (compiler->saveds >= 1) 545 FAIL_IF(push_inst(compiler, STACK_LOAD | D(SLJIT_SAVED_REG1) | A(SLJIT_LOCALS_REG) | IMM(-2 * (int)(sizeof(sljit_w))) )); 546 FAIL_IF(push_inst(compiler, STACK_LOAD | D(ZERO_REG) | A(SLJIT_LOCALS_REG) | IMM(-(int)(sizeof(sljit_w))) )); 547 548 FAIL_IF(push_inst(compiler, MTLR | S(0))); 549 FAIL_IF(push_inst(compiler, BLR)); 550 551 return SLJIT_SUCCESS; 552 } 553 554 #undef STACK_STORE 555 #undef STACK_LOAD 556 557 /* --------------------------------------------------------------------- */ 558 /* Operators */ 559 /* --------------------------------------------------------------------- */ 560 561 /* i/x - immediate/indexed form 562 n/w - no write-back / write-back (1 bit) 563 s/l - store/load (1 bit) 564 u/s - signed/unsigned (1 bit) 565 w/b/h/i - word/byte/half/int allowed (2 bit) 566 It contans 32 items, but not all are different. */ 567 568 /* 64 bit only: [reg+imm] must be aligned to 4 bytes. */ 569 #define ADDR_MODE2 0x10000 570 /* 64-bit only: there is no lwau instruction. */ 571 #define UPDATE_REQ 0x20000 572 573 #if (defined SLJIT_CONFIG_PPC_32 && SLJIT_CONFIG_PPC_32) 574 #define ARCH_32_64(a, b) a 575 #define INST_CODE_AND_DST(inst, flags, reg) \ 576 ((inst) | (((flags) & MEM_MASK) <= GPR_REG ? D(reg) : FD(reg))) 577 #else 578 #define ARCH_32_64(a, b) b 579 #define INST_CODE_AND_DST(inst, flags, reg) \ 580 (((inst) & ~(ADDR_MODE2 | UPDATE_REQ)) | (((flags) & MEM_MASK) <= GPR_REG ? D(reg) : FD(reg))) 581 #endif 582 583 static SLJIT_CONST sljit_ins data_transfer_insts[64 + 4] = { 584 585 /* -------- Unsigned -------- */ 586 587 /* Word. */ 588 589 /* u w n i s */ ARCH_32_64(HI(36) /* stw */, HI(62) | ADDR_MODE2 | 0x0 /* std */), 590 /* u w n i l */ ARCH_32_64(HI(32) /* lwz */, HI(58) | ADDR_MODE2 | 0x0 /* ld */), 591 /* u w n x s */ ARCH_32_64(HI(31) | LO(151) /* stwx */, HI(31) | LO(149) /* stdx */), 592 /* u w n x l */ ARCH_32_64(HI(31) | LO(23) /* lwzx */, HI(31) | LO(21) /* ldx */), 593 594 /* u w w i s */ ARCH_32_64(HI(37) /* stwu */, HI(62) | ADDR_MODE2 | 0x1 /* stdu */), 595 /* u w w i l */ ARCH_32_64(HI(33) /* lwzu */, HI(58) | ADDR_MODE2 | 0x1 /* ldu */), 596 /* u w w x s */ ARCH_32_64(HI(31) | LO(183) /* stwux */, HI(31) | LO(181) /* stdux */), 597 /* u w w x l */ ARCH_32_64(HI(31) | LO(55) /* lwzux */, HI(31) | LO(53) /* ldux */), 598 599 /* Byte. */ 600 601 /* u b n i s */ HI(38) /* stb */, 602 /* u b n i l */ HI(34) /* lbz */, 603 /* u b n x s */ HI(31) | LO(215) /* stbx */, 604 /* u b n x l */ HI(31) | LO(87) /* lbzx */, 605 606 /* u b w i s */ HI(39) /* stbu */, 607 /* u b w i l */ HI(35) /* lbzu */, 608 /* u b w x s */ HI(31) | LO(247) /* stbux */, 609 /* u b w x l */ HI(31) | LO(119) /* lbzux */, 610 611 /* Half. */ 612 613 /* u h n i s */ HI(44) /* sth */, 614 /* u h n i l */ HI(40) /* lhz */, 615 /* u h n x s */ HI(31) | LO(407) /* sthx */, 616 /* u h n x l */ HI(31) | LO(279) /* lhzx */, 617 618 /* u h w i s */ HI(45) /* sthu */, 619 /* u h w i l */ HI(41) /* lhzu */, 620 /* u h w x s */ HI(31) | LO(439) /* sthux */, 621 /* u h w x l */ HI(31) | LO(311) /* lhzux */, 622 623 /* Int. */ 624 625 /* u i n i s */ HI(36) /* stw */, 626 /* u i n i l */ HI(32) /* lwz */, 627 /* u i n x s */ HI(31) | LO(151) /* stwx */, 628 /* u i n x l */ HI(31) | LO(23) /* lwzx */, 629 630 /* u i w i s */ HI(37) /* stwu */, 631 /* u i w i l */ HI(33) /* lwzu */, 632 /* u i w x s */ HI(31) | LO(183) /* stwux */, 633 /* u i w x l */ HI(31) | LO(55) /* lwzux */, 634 635 /* -------- Signed -------- */ 636 637 /* Word. */ 638 639 /* s w n i s */ ARCH_32_64(HI(36) /* stw */, HI(62) | ADDR_MODE2 | 0x0 /* std */), 640 /* s w n i l */ ARCH_32_64(HI(32) /* lwz */, HI(58) | ADDR_MODE2 | 0x0 /* ld */), 641 /* s w n x s */ ARCH_32_64(HI(31) | LO(151) /* stwx */, HI(31) | LO(149) /* stdx */), 642 /* s w n x l */ ARCH_32_64(HI(31) | LO(23) /* lwzx */, HI(31) | LO(21) /* ldx */), 643 644 /* s w w i s */ ARCH_32_64(HI(37) /* stwu */, HI(62) | ADDR_MODE2 | 0x1 /* stdu */), 645 /* s w w i l */ ARCH_32_64(HI(33) /* lwzu */, HI(58) | ADDR_MODE2 | 0x1 /* ldu */), 646 /* s w w x s */ ARCH_32_64(HI(31) | LO(183) /* stwux */, HI(31) | LO(181) /* stdux */), 647 /* s w w x l */ ARCH_32_64(HI(31) | LO(55) /* lwzux */, HI(31) | LO(53) /* ldux */), 648 649 /* Byte. */ 650 651 /* s b n i s */ HI(38) /* stb */, 652 /* s b n i l */ HI(34) /* lbz */ /* EXTS_REQ */, 653 /* s b n x s */ HI(31) | LO(215) /* stbx */, 654 /* s b n x l */ HI(31) | LO(87) /* lbzx */ /* EXTS_REQ */, 655 656 /* s b w i s */ HI(39) /* stbu */, 657 /* s b w i l */ HI(35) /* lbzu */ /* EXTS_REQ */, 658 /* s b w x s */ HI(31) | LO(247) /* stbux */, 659 /* s b w x l */ HI(31) | LO(119) /* lbzux */ /* EXTS_REQ */, 660 661 /* Half. */ 662 663 /* s h n i s */ HI(44) /* sth */, 664 /* s h n i l */ HI(42) /* lha */, 665 /* s h n x s */ HI(31) | LO(407) /* sthx */, 666 /* s h n x l */ HI(31) | LO(343) /* lhax */, 667 668 /* s h w i s */ HI(45) /* sthu */, 669 /* s h w i l */ HI(43) /* lhau */, 670 /* s h w x s */ HI(31) | LO(439) /* sthux */, 671 /* s h w x l */ HI(31) | LO(375) /* lhaux */, 672 673 /* Int. */ 674 675 /* s i n i s */ HI(36) /* stw */, 676 /* s i n i l */ ARCH_32_64(HI(32) /* lwz */, HI(58) | ADDR_MODE2 | 0x2 /* lwa */), 677 /* s i n x s */ HI(31) | LO(151) /* stwx */, 678 /* s i n x l */ ARCH_32_64(HI(31) | LO(23) /* lwzx */, HI(31) | LO(341) /* lwax */), 679 680 /* s i w i s */ HI(37) /* stwu */, 681 /* s i w i l */ ARCH_32_64(HI(33) /* lwzu */, HI(58) | ADDR_MODE2 | UPDATE_REQ | 0x2 /* lwa */), 682 /* s i w x s */ HI(31) | LO(183) /* stwux */, 683 /* s i w x l */ ARCH_32_64(HI(31) | LO(55) /* lwzux */, HI(31) | LO(373) /* lwaux */), 684 685 /* -------- Double -------- */ 686 687 /* d n i s */ HI(54) /* stfd */, 688 /* d n i l */ HI(50) /* lfd */, 689 /* d n x s */ HI(31) | LO(727) /* stfdx */, 690 /* d n x l */ HI(31) | LO(599) /* lfdx */, 691 692 }; 693 694 #undef ARCH_32_64 695 696 /* Simple cases, (no caching is required). */ 697 static int getput_arg_fast(struct sljit_compiler *compiler, int inp_flags, int reg, int arg, sljit_w argw) 698 { 699 sljit_ins inst; 700 #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64) 701 int tmp_reg; 702 #endif 703 704 SLJIT_ASSERT(arg & SLJIT_MEM); 705 if (!(arg & 0xf)) { 706 #if (defined SLJIT_CONFIG_PPC_32 && SLJIT_CONFIG_PPC_32) 707 if (argw <= SIMM_MAX && argw >= SIMM_MIN) { 708 if (inp_flags & ARG_TEST) 709 return 1; 710 711 inst = data_transfer_insts[(inp_flags & ~WRITE_BACK) & MEM_MASK]; 712 SLJIT_ASSERT(!(inst & (ADDR_MODE2 | UPDATE_REQ))); 713 push_inst(compiler, INST_CODE_AND_DST(inst, inp_flags, reg) | IMM(argw)); 714 return -1; 715 } 716 #else 717 inst = data_transfer_insts[(inp_flags & ~WRITE_BACK) & MEM_MASK]; 718 if (argw <= SIMM_MAX && argw >= SIMM_MIN && 719 (!(inst & ADDR_MODE2) || (argw & 0x3) == 0)) { 720 if (inp_flags & ARG_TEST) 721 return 1; 722 723 push_inst(compiler, INST_CODE_AND_DST(inst, inp_flags, reg) | IMM(argw)); 724 return -1; 725 } 726 #endif 727 return 0; 728 } 729 730 if (!(arg & 0xf0)) { 731 #if (defined SLJIT_CONFIG_PPC_32 && SLJIT_CONFIG_PPC_32) 732 if (argw <= SIMM_MAX && argw >= SIMM_MIN) { 733 if (inp_flags & ARG_TEST) 734 return 1; 735 736 inst = data_transfer_insts[inp_flags & MEM_MASK]; 737 SLJIT_ASSERT(!(inst & (ADDR_MODE2 | UPDATE_REQ))); 738 push_inst(compiler, INST_CODE_AND_DST(inst, inp_flags, reg) | A(arg & 0xf) | IMM(argw)); 739 return -1; 740 } 741 #else 742 inst = data_transfer_insts[inp_flags & MEM_MASK]; 743 if (argw <= SIMM_MAX && argw >= SIMM_MIN && (!(inst & ADDR_MODE2) || (argw & 0x3) == 0)) { 744 if (inp_flags & ARG_TEST) 745 return 1; 746 747 if ((inp_flags & WRITE_BACK) && (inst & UPDATE_REQ)) { 748 tmp_reg = (inp_flags & LOAD_DATA) ? (arg & 0xf) : TMP_REG3; 749 if (push_inst(compiler, ADDI | D(tmp_reg) | A(arg & 0xf) | IMM(argw))) 750 return -1; 751 arg = tmp_reg | SLJIT_MEM; 752 argw = 0; 753 } 754 push_inst(compiler, INST_CODE_AND_DST(inst, inp_flags, reg) | A(arg & 0xf) | IMM(argw)); 755 return -1; 756 } 757 #endif 758 } 759 else if (!(argw & 0x3)) { 760 if (inp_flags & ARG_TEST) 761 return 1; 762 inst = data_transfer_insts[(inp_flags | INDEXED) & MEM_MASK]; 763 SLJIT_ASSERT(!(inst & (ADDR_MODE2 | UPDATE_REQ))); 764 push_inst(compiler, INST_CODE_AND_DST(inst, inp_flags, reg) | A(arg & 0xf) | B((arg >> 4) & 0xf)); 765 return -1; 766 } 767 return 0; 768 } 769 770 /* See getput_arg below. 771 Note: can_cache is called only for binary operators. Those operator always 772 uses word arguments without write back. */ 773 static int can_cache(int arg, sljit_w argw, int next_arg, sljit_w next_argw) 774 { 775 SLJIT_ASSERT((arg & SLJIT_MEM) && (next_arg & SLJIT_MEM)); 776 777 if (!(arg & 0xf)) 778 return (next_arg & SLJIT_MEM) && ((sljit_uw)argw - (sljit_uw)next_argw <= SIMM_MAX || (sljit_uw)next_argw - (sljit_uw)argw <= SIMM_MAX); 779 780 if (arg & 0xf0) 781 return ((arg & 0xf0) == (next_arg & 0xf0) && (argw & 0x3) == (next_argw & 0x3)); 782 783 if (argw <= SIMM_MAX && argw >= SIMM_MIN) { 784 if (arg == next_arg && (next_argw >= SIMM_MAX && next_argw <= SIMM_MIN)) 785 return 1; 786 } 787 788 if (arg == next_arg && ((sljit_uw)argw - (sljit_uw)next_argw <= SIMM_MAX || (sljit_uw)next_argw - (sljit_uw)argw <= SIMM_MAX)) 789 return 1; 790 791 return 0; 792 } 793 794 #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64) 795 #define ADJUST_CACHED_IMM(imm) \ 796 if ((inst & ADDR_MODE2) && (imm & 0x3)) { \ 797 /* Adjust cached value. Fortunately this is really a rare case */ \ 798 compiler->cache_argw += imm & 0x3; \ 799 FAIL_IF(push_inst(compiler, ADDI | D(TMP_REG3) | A(TMP_REG3) | (imm & 0x3))); \ 800 imm &= ~0x3; \ 801 } 802 #else 803 #define ADJUST_CACHED_IMM(imm) 804 #endif 805 806 /* Emit the necessary instructions. See can_cache above. */ 807 static int getput_arg(struct sljit_compiler *compiler, int inp_flags, int reg, int arg, sljit_w argw, int next_arg, sljit_w next_argw) 808 { 809 int tmp_r; 810 sljit_ins inst; 811 812 SLJIT_ASSERT(arg & SLJIT_MEM); 813 814 tmp_r = ((inp_flags & LOAD_DATA) && ((inp_flags) & MEM_MASK) <= GPR_REG) ? reg : TMP_REG1; 815 /* Special case for "mov reg, [reg, ... ]". */ 816 if ((arg & 0xf) == tmp_r) 817 tmp_r = TMP_REG1; 818 819 if (!(arg & 0xf)) { 820 inst = data_transfer_insts[(inp_flags & ~WRITE_BACK) & MEM_MASK]; 821 if ((compiler->cache_arg & SLJIT_IMM) && (((sljit_uw)argw - (sljit_uw)compiler->cache_argw) <= SIMM_MAX || ((sljit_uw)compiler->cache_argw - (sljit_uw)argw) <= SIMM_MAX)) { 822 argw = argw - compiler->cache_argw; 823 ADJUST_CACHED_IMM(argw); 824 SLJIT_ASSERT(!(inst & UPDATE_REQ)); 825 return push_inst(compiler, INST_CODE_AND_DST(inst, inp_flags, reg) | A(TMP_REG3) | IMM(argw)); 826 } 827 828 if ((next_arg & SLJIT_MEM) && (argw - next_argw <= SIMM_MAX || next_argw - argw <= SIMM_MAX)) { 829 SLJIT_ASSERT(inp_flags & LOAD_DATA); 830 831 compiler->cache_arg = SLJIT_IMM; 832 compiler->cache_argw = argw; 833 tmp_r = TMP_REG3; 834 } 835 836 FAIL_IF(load_immediate(compiler, tmp_r, argw)); 837 return push_inst(compiler, INST_CODE_AND_DST(inst, inp_flags, reg) | A(tmp_r)); 838 } 839 840 if (SLJIT_UNLIKELY(arg & 0xf0)) { 841 argw &= 0x3; 842 /* Otherwise getput_arg_fast would capture it. */ 843 SLJIT_ASSERT(argw); 844 845 if ((SLJIT_MEM | (arg & 0xf0)) == compiler->cache_arg && argw == compiler->cache_argw) 846 tmp_r = TMP_REG3; 847 else { 848 if ((arg & 0xf0) == (next_arg & 0xf0) && argw == (next_argw & 0x3)) { 849 compiler->cache_arg = SLJIT_MEM | (arg & 0xf0); 850 compiler->cache_argw = argw; 851 tmp_r = TMP_REG3; 852 } 853 #if (defined SLJIT_CONFIG_PPC_32 && SLJIT_CONFIG_PPC_32) 854 FAIL_IF(push_inst(compiler, RLWINM | S((arg >> 4) & 0xf) | A(tmp_r) | (argw << 11) | ((31 - argw) << 1))); 855 #else 856 FAIL_IF(push_inst(compiler, RLDI(tmp_r, (arg >> 4) & 0xf, argw, 63 - argw, 1))); 857 #endif 858 } 859 inst = data_transfer_insts[(inp_flags | INDEXED) & MEM_MASK]; 860 SLJIT_ASSERT(!(inst & (ADDR_MODE2 | UPDATE_REQ))); 861 return push_inst(compiler, INST_CODE_AND_DST(inst, inp_flags, reg) | A(arg & 0xf) | B(tmp_r)); 862 } 863 864 inst = data_transfer_insts[inp_flags & MEM_MASK]; 865 866 if (compiler->cache_arg == arg && ((sljit_uw)argw - (sljit_uw)compiler->cache_argw <= SIMM_MAX || (sljit_uw)compiler->cache_argw - (sljit_uw)argw <= SIMM_MAX)) { 867 SLJIT_ASSERT(!(inp_flags & WRITE_BACK)); 868 argw = argw - compiler->cache_argw; 869 ADJUST_CACHED_IMM(argw); 870 return push_inst(compiler, INST_CODE_AND_DST(inst, inp_flags, reg) | A(TMP_REG3) | IMM(argw)); 871 } 872 873 if ((compiler->cache_arg & SLJIT_IMM) && compiler->cache_argw == argw) { 874 inst = data_transfer_insts[(inp_flags | INDEXED) & MEM_MASK]; 875 SLJIT_ASSERT(!(inst & (ADDR_MODE2 | UPDATE_REQ))); 876 return push_inst(compiler, INST_CODE_AND_DST(inst, inp_flags, reg) | A(arg & 0xf) | B(TMP_REG3)); 877 } 878 879 if (argw == next_argw && (next_arg & SLJIT_MEM)) { 880 SLJIT_ASSERT(inp_flags & LOAD_DATA); 881 FAIL_IF(load_immediate(compiler, TMP_REG3, argw)); 882 883 compiler->cache_arg = SLJIT_IMM; 884 compiler->cache_argw = argw; 885 886 inst = data_transfer_insts[(inp_flags | INDEXED) & MEM_MASK]; 887 SLJIT_ASSERT(!(inst & (ADDR_MODE2 | UPDATE_REQ))); 888 return push_inst(compiler, INST_CODE_AND_DST(inst, inp_flags, reg) | A(arg & 0xf) | B(TMP_REG3)); 889 } 890 891 if (arg == next_arg && !(inp_flags & WRITE_BACK) && ((sljit_uw)argw - (sljit_uw)next_argw <= SIMM_MAX || (sljit_uw)next_argw - (sljit_uw)argw <= SIMM_MAX)) { 892 SLJIT_ASSERT(inp_flags & LOAD_DATA); 893 FAIL_IF(load_immediate(compiler, TMP_REG3, argw)); 894 FAIL_IF(push_inst(compiler, ADD | D(TMP_REG3) | A(TMP_REG3) | B(arg & 0xf))); 895 896 compiler->cache_arg = arg; 897 compiler->cache_argw = argw; 898 899 return push_inst(compiler, INST_CODE_AND_DST(inst, inp_flags, reg) | A(TMP_REG3)); 900 } 901 902 /* Get the indexed version instead of the normal one. */ 903 inst = data_transfer_insts[(inp_flags | INDEXED) & MEM_MASK]; 904 SLJIT_ASSERT(!(inst & (ADDR_MODE2 | UPDATE_REQ))); 905 FAIL_IF(load_immediate(compiler, tmp_r, argw)); 906 return push_inst(compiler, INST_CODE_AND_DST(inst, inp_flags, reg) | A(arg & 0xf) | B(tmp_r)); 907 } 908 909 static SLJIT_INLINE int emit_op_mem2(struct sljit_compiler *compiler, int flags, int reg, int arg1, sljit_w arg1w, int arg2, sljit_w arg2w) 910 { 911 if (getput_arg_fast(compiler, flags, reg, arg1, arg1w)) 912 return compiler->error; 913 return getput_arg(compiler, flags, reg, arg1, arg1w, arg2, arg2w); 914 } 915 916 static int emit_op(struct sljit_compiler *compiler, int op, int input_flags, 917 int dst, sljit_w dstw, 918 int src1, sljit_w src1w, 919 int src2, sljit_w src2w) 920 { 921 /* arg1 goes to TMP_REG1 or src reg 922 arg2 goes to TMP_REG2, imm or src reg 923 TMP_REG3 can be used for caching 924 result goes to TMP_REG2, so put result can use TMP_REG1 and TMP_REG3. */ 925 int dst_r; 926 int src1_r; 927 int src2_r; 928 int sugg_src2_r = TMP_REG2; 929 int flags = input_flags & (ALT_FORM1 | ALT_FORM2 | ALT_FORM3 | ALT_FORM4 | ALT_FORM5 | ALT_FORM6 | ALT_SIGN_EXT | ALT_SET_FLAGS); 930 931 compiler->cache_arg = 0; 932 compiler->cache_argw = 0; 933 934 /* Destination check. */ 935 if (dst >= SLJIT_TEMPORARY_REG1 && dst <= ZERO_REG) { 936 dst_r = dst; 937 flags |= REG_DEST; 938 if (op >= SLJIT_MOV && op <= SLJIT_MOVU_SI) 939 sugg_src2_r = dst_r; 940 } 941 else if (dst == SLJIT_UNUSED) { 942 if (op >= SLJIT_MOV && op <= SLJIT_MOVU_SI && !(src2 & SLJIT_MEM)) 943 return SLJIT_SUCCESS; 944 dst_r = TMP_REG2; 945 } 946 else { 947 SLJIT_ASSERT(dst & SLJIT_MEM); 948 if (getput_arg_fast(compiler, input_flags | ARG_TEST, TMP_REG2, dst, dstw)) { 949 flags |= FAST_DEST; 950 dst_r = TMP_REG2; 951 } 952 else { 953 flags |= SLOW_DEST; 954 dst_r = 0; 955 } 956 } 957 958 /* Source 1. */ 959 if (src1 >= SLJIT_TEMPORARY_REG1 && src1 <= ZERO_REG) { 960 src1_r = src1; 961 flags |= REG1_SOURCE; 962 } 963 else if (src1 & SLJIT_IMM) { 964 #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64) 965 SLJIT_COMPILE_ASSERT(INT_DATA == 0x18, int_data_check1); 966 if ((input_flags & 0x18) == INT_DATA) { 967 if (input_flags & SIGNED_DATA) 968 src1w = (signed int)src1w; 969 else 970 src1w = (unsigned int)src1w; 971 } 972 #endif 973 FAIL_IF(load_immediate(compiler, TMP_REG1, src1w)); 974 src1_r = TMP_REG1; 975 } 976 else if (getput_arg_fast(compiler, input_flags | LOAD_DATA, TMP_REG1, src1, src1w)) { 977 FAIL_IF(compiler->error); 978 src1_r = TMP_REG1; 979 } 980 else 981 src1_r = 0; 982 983 /* Source 2. */ 984 if (src2 >= SLJIT_TEMPORARY_REG1 && src2 <= ZERO_REG) { 985 src2_r = src2; 986 flags |= REG2_SOURCE; 987 if (!(flags & REG_DEST) && op >= SLJIT_MOV && op <= SLJIT_MOVU_SI) 988 dst_r = src2_r; 989 } 990 else if (src2 & SLJIT_IMM) { 991 #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64) 992 SLJIT_COMPILE_ASSERT(INT_DATA == 0x18, int_data_check2); 993 if ((input_flags & 0x18) == INT_DATA) { 994 if (input_flags & SIGNED_DATA) 995 src2w = (signed int)src2w; 996 else 997 src2w = (unsigned int)src2w; 998 } 999 #endif 1000 FAIL_IF(load_immediate(compiler, sugg_src2_r, src2w)); 1001 src2_r = sugg_src2_r; 1002 } 1003 else if (getput_arg_fast(compiler, input_flags | LOAD_DATA, sugg_src2_r, src2, src2w)) { 1004 FAIL_IF(compiler->error); 1005 src2_r = sugg_src2_r; 1006 } 1007 else 1008 src2_r = 0; 1009 1010 /* src1_r, src2_r and dst_r can be zero (=unprocessed). 1011 All arguments are complex addressing modes, and it is a binary operator. */ 1012 if (src1_r == 0 && src2_r == 0 && dst_r == 0) { 1013 if (!can_cache(src1, src1w, src2, src2w) && can_cache(src1, src1w, dst, dstw)) { 1014 FAIL_IF(getput_arg(compiler, input_flags | LOAD_DATA, TMP_REG2, src2, src2w, src1, src1w)); 1015 FAIL_IF(getput_arg(compiler, input_flags | LOAD_DATA, TMP_REG1, src1, src1w, dst, dstw)); 1016 } 1017 else { 1018 FAIL_IF(getput_arg(compiler, input_flags | LOAD_DATA, TMP_REG1, src1, src1w, src2, src2w)); 1019 FAIL_IF(getput_arg(compiler, input_flags | LOAD_DATA, TMP_REG2, src2, src2w, dst, dstw)); 1020 } 1021 src1_r = TMP_REG1; 1022 src2_r = TMP_REG2; 1023 } 1024 else if (src1_r == 0 && src2_r == 0) { 1025 FAIL_IF(getput_arg(compiler, input_flags | LOAD_DATA, TMP_REG1, src1, src1w, src2, src2w)); 1026 src1_r = TMP_REG1; 1027 } 1028 else if (src1_r == 0 && dst_r == 0) { 1029 FAIL_IF(getput_arg(compiler, input_flags | LOAD_DATA, TMP_REG1, src1, src1w, dst, dstw)); 1030 src1_r = TMP_REG1; 1031 } 1032 else if (src2_r == 0 && dst_r == 0) { 1033 FAIL_IF(getput_arg(compiler, input_flags | LOAD_DATA, sugg_src2_r, src2, src2w, dst, dstw)); 1034 src2_r = sugg_src2_r; 1035 } 1036 1037 if (dst_r == 0) 1038 dst_r = TMP_REG2; 1039 1040 if (src1_r == 0) { 1041 FAIL_IF(getput_arg(compiler, input_flags | LOAD_DATA, TMP_REG1, src1, src1w, 0, 0)); 1042 src1_r = TMP_REG1; 1043 } 1044 1045 if (src2_r == 0) { 1046 FAIL_IF(getput_arg(compiler, input_flags | LOAD_DATA, sugg_src2_r, src2, src2w, 0, 0)); 1047 src2_r = sugg_src2_r; 1048 } 1049 1050 FAIL_IF(emit_single_op(compiler, op, flags, dst_r, src1_r, src2_r)); 1051 1052 if (flags & (FAST_DEST | SLOW_DEST)) { 1053 if (flags & FAST_DEST) 1054 FAIL_IF(getput_arg_fast(compiler, input_flags, dst_r, dst, dstw)); 1055 else 1056 FAIL_IF(getput_arg(compiler, input_flags, dst_r, dst, dstw, 0, 0)); 1057 } 1058 return SLJIT_SUCCESS; 1059 } 1060 1061 SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_op0(struct sljit_compiler *compiler, int op) 1062 { 1063 CHECK_ERROR(); 1064 check_sljit_emit_op0(compiler, op); 1065 1066 switch (GET_OPCODE(op)) { 1067 case SLJIT_BREAKPOINT: 1068 case SLJIT_NOP: 1069 return push_inst(compiler, NOP); 1070 break; 1071 case SLJIT_UMUL: 1072 case SLJIT_SMUL: 1073 FAIL_IF(push_inst(compiler, OR | S(SLJIT_TEMPORARY_REG1) | A(TMP_REG1) | B(SLJIT_TEMPORARY_REG1))); 1074 #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64) 1075 FAIL_IF(push_inst(compiler, MULLD | D(SLJIT_TEMPORARY_REG1) | A(TMP_REG1) | B(SLJIT_TEMPORARY_REG2))); 1076 return push_inst(compiler, (GET_OPCODE(op) == SLJIT_UMUL ? MULHDU : MULHD) | D(SLJIT_TEMPORARY_REG2) | A(TMP_REG1) | B(SLJIT_TEMPORARY_REG2)); 1077 #else 1078 FAIL_IF(push_inst(compiler, MULLW | D(SLJIT_TEMPORARY_REG1) | A(TMP_REG1) | B(SLJIT_TEMPORARY_REG2))); 1079 return push_inst(compiler, (GET_OPCODE(op) == SLJIT_UMUL ? MULHWU : MULHW) | D(SLJIT_TEMPORARY_REG2) | A(TMP_REG1) | B(SLJIT_TEMPORARY_REG2)); 1080 #endif 1081 case SLJIT_UDIV: 1082 case SLJIT_SDIV: 1083 FAIL_IF(push_inst(compiler, OR | S(SLJIT_TEMPORARY_REG1) | A(TMP_REG1) | B(SLJIT_TEMPORARY_REG1))); 1084 #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64) 1085 if (op & SLJIT_INT_OP) { 1086 FAIL_IF(push_inst(compiler, (GET_OPCODE(op) == SLJIT_UDIV ? DIVWU : DIVW) | D(SLJIT_TEMPORARY_REG1) | A(TMP_REG1) | B(SLJIT_TEMPORARY_REG2))); 1087 FAIL_IF(push_inst(compiler, MULLW | D(SLJIT_TEMPORARY_REG2) | A(SLJIT_TEMPORARY_REG1) | B(SLJIT_TEMPORARY_REG2))); 1088 return push_inst(compiler, SUBF | D(SLJIT_TEMPORARY_REG2) | A(SLJIT_TEMPORARY_REG2) | B(TMP_REG1)); 1089 } 1090 FAIL_IF(push_inst(compiler, (GET_OPCODE(op) == SLJIT_UDIV ? DIVDU : DIVD) | D(SLJIT_TEMPORARY_REG1) | A(TMP_REG1) | B(SLJIT_TEMPORARY_REG2))); 1091 FAIL_IF(push_inst(compiler, MULLD | D(SLJIT_TEMPORARY_REG2) | A(SLJIT_TEMPORARY_REG1) | B(SLJIT_TEMPORARY_REG2))); 1092 return push_inst(compiler, SUBF | D(SLJIT_TEMPORARY_REG2) | A(SLJIT_TEMPORARY_REG2) | B(TMP_REG1)); 1093 #else 1094 FAIL_IF(push_inst(compiler, (GET_OPCODE(op) == SLJIT_UDIV ? DIVWU : DIVW) | D(SLJIT_TEMPORARY_REG1) | A(TMP_REG1) | B(SLJIT_TEMPORARY_REG2))); 1095 FAIL_IF(push_inst(compiler, MULLW | D(SLJIT_TEMPORARY_REG2) | A(SLJIT_TEMPORARY_REG1) | B(SLJIT_TEMPORARY_REG2))); 1096 return push_inst(compiler, SUBF | D(SLJIT_TEMPORARY_REG2) | A(SLJIT_TEMPORARY_REG2) | B(TMP_REG1)); 1097 #endif 1098 } 1099 1100 return SLJIT_SUCCESS; 1101 } 1102 1103 #define EMIT_MOV(type, type_flags, type_cast) \ 1104 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) 1105 1106 SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_op1(struct sljit_compiler *compiler, int op, 1107 int dst, sljit_w dstw, 1108 int src, sljit_w srcw) 1109 { 1110 int flags = GET_FLAGS(op) ? ALT_SET_FLAGS : 0; 1111 1112 CHECK_ERROR(); 1113 check_sljit_emit_op1(compiler, op, dst, dstw, src, srcw); 1114 ADJUST_LOCAL_OFFSET(dst, dstw); 1115 ADJUST_LOCAL_OFFSET(src, srcw); 1116 1117 if ((src & SLJIT_IMM) && srcw == 0 && GET_OPCODE(op) >= SLJIT_NOT) 1118 src = ZERO_REG; 1119 1120 #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64) 1121 if (op & SLJIT_INT_OP) { 1122 flags |= INT_DATA | SIGNED_DATA; 1123 if (src & SLJIT_IMM) 1124 srcw = (int)srcw; 1125 } 1126 #endif 1127 if (op & SLJIT_SET_O) 1128 FAIL_IF(push_inst(compiler, MTXER | S(ZERO_REG))); 1129 1130 switch (GET_OPCODE(op)) { 1131 case SLJIT_MOV: 1132 return emit_op(compiler, SLJIT_MOV, flags | WORD_DATA, dst, dstw, TMP_REG1, 0, src, srcw); 1133 1134 case SLJIT_MOV_UI: 1135 return emit_op(compiler, SLJIT_MOV_UI, flags | INT_DATA, dst, dstw, TMP_REG1, 0, src, srcw); 1136 1137 case SLJIT_MOV_SI: 1138 return emit_op(compiler, SLJIT_MOV_SI, flags | INT_DATA | SIGNED_DATA, dst, dstw, TMP_REG1, 0, src, srcw); 1139 1140 case SLJIT_MOV_UB: 1141 return EMIT_MOV(SLJIT_MOV_UB, BYTE_DATA, (unsigned char)); 1142 1143 case SLJIT_MOV_SB: 1144 return EMIT_MOV(SLJIT_MOV_SB, BYTE_DATA | SIGNED_DATA, (signed char)); 1145 1146 case SLJIT_MOV_UH: 1147 return EMIT_MOV(SLJIT_MOV_UH, HALF_DATA, (unsigned short)); 1148 1149 case SLJIT_MOV_SH: 1150 return EMIT_MOV(SLJIT_MOV_SH, HALF_DATA | SIGNED_DATA, (signed short)); 1151 1152 case SLJIT_MOVU: 1153 return emit_op(compiler, SLJIT_MOV, flags | WORD_DATA | WRITE_BACK, dst, dstw, TMP_REG1, 0, src, srcw); 1154 1155 case SLJIT_MOVU_UI: 1156 return emit_op(compiler, SLJIT_MOV_UI, flags | INT_DATA | WRITE_BACK, dst, dstw, TMP_REG1, 0, src, srcw); 1157 1158 case SLJIT_MOVU_SI: 1159 return emit_op(compiler, SLJIT_MOV_SI, flags | INT_DATA | SIGNED_DATA | WRITE_BACK, dst, dstw, TMP_REG1, 0, src, srcw); 1160 1161 case SLJIT_MOVU_UB: 1162 return EMIT_MOV(SLJIT_MOV_UB, BYTE_DATA | WRITE_BACK, (unsigned char)); 1163 1164 case SLJIT_MOVU_SB: 1165 return EMIT_MOV(SLJIT_MOV_SB, BYTE_DATA | SIGNED_DATA | WRITE_BACK, (signed char)); 1166 1167 case SLJIT_MOVU_UH: 1168 return EMIT_MOV(SLJIT_MOV_UH, HALF_DATA | WRITE_BACK, (unsigned short)); 1169 1170 case SLJIT_MOVU_SH: 1171 return EMIT_MOV(SLJIT_MOV_SH, HALF_DATA | SIGNED_DATA | WRITE_BACK, (signed short)); 1172 1173 case SLJIT_NOT: 1174 return emit_op(compiler, SLJIT_NOT, flags, dst, dstw, TMP_REG1, 0, src, srcw); 1175 1176 case SLJIT_NEG: 1177 return emit_op(compiler, SLJIT_NEG, flags, dst, dstw, TMP_REG1, 0, src, srcw); 1178 1179 case SLJIT_CLZ: 1180 #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64) 1181 return emit_op(compiler, SLJIT_CLZ, flags | (!(op & SLJIT_INT_OP) ? 0 : ALT_FORM1), dst, dstw, TMP_REG1, 0, src, srcw); 1182 #else 1183 return emit_op(compiler, SLJIT_CLZ, flags, dst, dstw, TMP_REG1, 0, src, srcw); 1184 #endif 1185 } 1186 1187 return SLJIT_SUCCESS; 1188 } 1189 1190 #undef EMIT_MOV 1191 1192 #define TEST_SL_IMM(src, srcw) \ 1193 (((src) & SLJIT_IMM) && (srcw) <= SIMM_MAX && (srcw) >= SIMM_MIN) 1194 1195 #define TEST_UL_IMM(src, srcw) \ 1196 (((src) & SLJIT_IMM) && !((srcw) & ~0xffff)) 1197 1198 #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64) 1199 #define TEST_SH_IMM(src, srcw) \ 1200 (((src) & SLJIT_IMM) && !((srcw) & 0xffff) && (srcw) <= SLJIT_W(0x7fffffff) && (srcw) >= SLJIT_W(-0x80000000)) 1201 #else 1202 #define TEST_SH_IMM(src, srcw) \ 1203 (((src) & SLJIT_IMM) && !((srcw) & 0xffff)) 1204 #endif 1205 1206 #define TEST_UH_IMM(src, srcw) \ 1207 (((src) & SLJIT_IMM) && !((srcw) & ~0xffff0000)) 1208 1209 #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64) 1210 #define TEST_ADD_IMM(src, srcw) \ 1211 (((src) & SLJIT_IMM) && (srcw) <= SLJIT_W(0x7fff7fff) && (srcw) >= SLJIT_W(-0x80000000)) 1212 #else 1213 #define TEST_ADD_IMM(src, srcw) \ 1214 ((src) & SLJIT_IMM) 1215 #endif 1216 1217 #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64) 1218 #define TEST_UI_IMM(src, srcw) \ 1219 (((src) & SLJIT_IMM) && !((srcw) & ~0xffffffff)) 1220 #else 1221 #define TEST_UI_IMM(src, srcw) \ 1222 ((src) & SLJIT_IMM) 1223 #endif 1224 1225 SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_op2(struct sljit_compiler *compiler, int op, 1226 int dst, sljit_w dstw, 1227 int src1, sljit_w src1w, 1228 int src2, sljit_w src2w) 1229 { 1230 int flags = GET_FLAGS(op) ? ALT_SET_FLAGS : 0; 1231 1232 CHECK_ERROR(); 1233 check_sljit_emit_op2(compiler, op, dst, dstw, src1, src1w, src2, src2w); 1234 ADJUST_LOCAL_OFFSET(dst, dstw); 1235 ADJUST_LOCAL_OFFSET(src1, src1w); 1236 ADJUST_LOCAL_OFFSET(src2, src2w); 1237 1238 if ((src1 & SLJIT_IMM) && src1w == 0) 1239 src1 = ZERO_REG; 1240 if ((src2 & SLJIT_IMM) && src2w == 0) 1241 src2 = ZERO_REG; 1242 1243 #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64) 1244 if (op & SLJIT_INT_OP) { 1245 flags |= INT_DATA | SIGNED_DATA; 1246 if (src1 & SLJIT_IMM) 1247 src1w = (src1w << 32) >> 32; 1248 if (src2 & SLJIT_IMM) 1249 src2w = (src2w << 32) >> 32; 1250 if (GET_FLAGS(op)) 1251 flags |= ALT_SIGN_EXT; 1252 } 1253 #endif 1254 if (op & SLJIT_SET_O) 1255 FAIL_IF(push_inst(compiler, MTXER | S(ZERO_REG))); 1256 1257 switch (GET_OPCODE(op)) { 1258 case SLJIT_ADD: 1259 if (!GET_FLAGS(op) && ((src1 | src2) & SLJIT_IMM)) { 1260 if (TEST_SL_IMM(src2, src2w)) { 1261 compiler->imm = src2w & 0xffff; 1262 return emit_op(compiler, SLJIT_ADD, flags | ALT_FORM1, dst, dstw, src1, src1w, TMP_REG2, 0); 1263 } 1264 if (TEST_SL_IMM(src1, src1w)) { 1265 compiler->imm = src1w & 0xffff; 1266 return emit_op(compiler, SLJIT_ADD, flags | ALT_FORM1, dst, dstw, src2, src2w, TMP_REG2, 0); 1267 } 1268 if (TEST_SH_IMM(src2, src2w)) { 1269 compiler->imm = (src2w >> 16) & 0xffff; 1270 return emit_op(compiler, SLJIT_ADD, flags | ALT_FORM2, dst, dstw, src1, src1w, TMP_REG2, 0); 1271 } 1272 if (TEST_SH_IMM(src1, src1w)) { 1273 compiler->imm = (src1w >> 16) & 0xffff; 1274 return emit_op(compiler, SLJIT_ADD, flags | ALT_FORM2, dst, dstw, src2, src2w, TMP_REG2, 0); 1275 } 1276 /* Range between -1 and -32768 is covered above. */ 1277 if (TEST_ADD_IMM(src2, src2w)) { 1278 compiler->imm = src2w & 0xffffffff; 1279 return emit_op(compiler, SLJIT_ADD, flags | ALT_FORM4, dst, dstw, src1, src1w, TMP_REG2, 0); 1280 } 1281 if (TEST_ADD_IMM(src1, src1w)) { 1282 compiler->imm = src1w & 0xffffffff; 1283 return emit_op(compiler, SLJIT_ADD, flags | ALT_FORM4, dst, dstw, src2, src2w, TMP_REG2, 0); 1284 } 1285 } 1286 if (!(GET_FLAGS(op) & (SLJIT_SET_E | SLJIT_SET_O))) { 1287 if (TEST_SL_IMM(src2, src2w)) { 1288 compiler->imm = src2w & 0xffff; 1289 return emit_op(compiler, SLJIT_ADD, flags | ALT_FORM3, dst, dstw, src1, src1w, TMP_REG2, 0); 1290 } 1291 if (TEST_SL_IMM(src1, src1w)) { 1292 compiler->imm = src1w & 0xffff; 1293 return emit_op(compiler, SLJIT_ADD, flags | ALT_FORM3, dst, dstw, src2, src2w, TMP_REG2, 0); 1294 } 1295 } 1296 return emit_op(compiler, SLJIT_ADD, flags, dst, dstw, src1, src1w, src2, src2w); 1297 1298 case SLJIT_ADDC: 1299 return emit_op(compiler, SLJIT_ADDC, flags | (!(op & SLJIT_KEEP_FLAGS) ? 0 : ALT_FORM1), dst, dstw, src1, src1w, src2, src2w); 1300 1301 case SLJIT_SUB: 1302 if (!GET_FLAGS(op) && ((src1 | src2) & SLJIT_IMM)) { 1303 if (TEST_SL_IMM(src2, -src2w)) { 1304 compiler->imm = (-src2w) & 0xffff; 1305 return emit_op(compiler, SLJIT_ADD, flags | ALT_FORM1, dst, dstw, src1, src1w, TMP_REG2, 0); 1306 } 1307 if (TEST_SL_IMM(src1, src1w)) { 1308 compiler->imm = src1w & 0xffff; 1309 return emit_op(compiler, SLJIT_SUB, flags | ALT_FORM1, dst, dstw, src2, src2w, TMP_REG2, 0); 1310 } 1311 if (TEST_SH_IMM(src2, -src2w)) { 1312 compiler->imm = ((-src2w) >> 16) & 0xffff; 1313 return emit_op(compiler, SLJIT_ADD, flags | ALT_FORM2, dst, dstw, src1, src1w, TMP_REG2, 0); 1314 } 1315 /* Range between -1 and -32768 is covered above. */ 1316 if (TEST_ADD_IMM(src2, -src2w)) { 1317 compiler->imm = -src2w & 0xffffffff; 1318 return emit_op(compiler, SLJIT_ADD, flags | ALT_FORM4, dst, dstw, src1, src1w, TMP_REG2, 0); 1319 } 1320 } 1321 if (dst == SLJIT_UNUSED && (op & (SLJIT_SET_E | SLJIT_SET_S | SLJIT_SET_U)) && !(op & (SLJIT_SET_O | SLJIT_SET_C))) { 1322 if (!(op & SLJIT_SET_U)) { 1323 /* We know ALT_SIGN_EXT is set if it is an SLJIT_INT_OP on 64 bit systems. */ 1324 if (TEST_SL_IMM(src2, src2w)) { 1325 compiler->imm = src2w & 0xffff; 1326 return emit_op(compiler, SLJIT_SUB, flags | ALT_FORM2, dst, dstw, src1, src1w, TMP_REG2, 0); 1327 } 1328 if (GET_FLAGS(op) == SLJIT_SET_E && TEST_SL_IMM(src1, src1w)) { 1329 compiler->imm = src1w & 0xffff; 1330 return emit_op(compiler, SLJIT_SUB, flags | ALT_FORM2, dst, dstw, src2, src2w, TMP_REG2, 0); 1331 } 1332 } 1333 if (!(op & (SLJIT_SET_E | SLJIT_SET_S))) { 1334 /* We know ALT_SIGN_EXT is set if it is an SLJIT_INT_OP on 64 bit systems. */ 1335 if (TEST_UL_IMM(src2, src2w)) { 1336 compiler->imm = src2w & 0xffff; 1337 return emit_op(compiler, SLJIT_SUB, flags | ALT_FORM3, dst, dstw, src1, src1w, TMP_REG2, 0); 1338 } 1339 return emit_op(compiler, SLJIT_SUB, flags | ALT_FORM4, dst, dstw, src1, src1w, src2, src2w); 1340 } 1341 if ((src2 & SLJIT_IMM) && src2w >= 0 && src2w <= 0x7fff) { 1342 compiler->imm = src2w; 1343 return emit_op(compiler, SLJIT_SUB, flags | ALT_FORM2 | ALT_FORM3, dst, dstw, src1, src1w, TMP_REG2, 0); 1344 } 1345 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); 1346 } 1347 if (!(op & (SLJIT_SET_E | SLJIT_SET_S | SLJIT_SET_U | SLJIT_SET_O))) { 1348 if (TEST_SL_IMM(src2, -src2w)) { 1349 compiler->imm = (-src2w) & 0xffff; 1350 return emit_op(compiler, SLJIT_ADD, flags | ALT_FORM3, dst, dstw, src1, src1w, TMP_REG2, 0); 1351 } 1352 } 1353 /* We know ALT_SIGN_EXT is set if it is an SLJIT_INT_OP on 64 bit systems. */ 1354 return emit_op(compiler, SLJIT_SUB, flags | (!(op & SLJIT_SET_U) ? 0 : ALT_FORM6), dst, dstw, src1, src1w, src2, src2w); 1355 1356 case SLJIT_SUBC: 1357 return emit_op(compiler, SLJIT_SUBC, flags | (!(op & SLJIT_KEEP_FLAGS) ? 0 : ALT_FORM1), dst, dstw, src1, src1w, src2, src2w); 1358 1359 case SLJIT_MUL: 1360 #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64) 1361 if (op & SLJIT_INT_OP) 1362 flags |= ALT_FORM2; 1363 #endif 1364 if (!GET_FLAGS(op)) { 1365 if (TEST_SL_IMM(src2, src2w)) { 1366 compiler->imm = src2w & 0xffff; 1367 return emit_op(compiler, SLJIT_MUL, flags | ALT_FORM1, dst, dstw, src1, src1w, TMP_REG2, 0); 1368 } 1369 if (TEST_SL_IMM(src1, src1w)) { 1370 compiler->imm = src1w & 0xffff; 1371 return emit_op(compiler, SLJIT_MUL, flags | ALT_FORM1, dst, dstw, src2, src2w, TMP_REG2, 0); 1372 } 1373 } 1374 return emit_op(compiler, SLJIT_MUL, flags, dst, dstw, src1, src1w, src2, src2w); 1375 1376 case SLJIT_AND: 1377 case SLJIT_OR: 1378 case SLJIT_XOR: 1379 /* Commutative unsigned operations. */ 1380 if (!GET_FLAGS(op) || GET_OPCODE(op) == SLJIT_AND) { 1381 if (TEST_UL_IMM(src2, src2w)) { 1382 compiler->imm = src2w; 1383 return emit_op(compiler, GET_OPCODE(op), flags | ALT_FORM1, dst, dstw, src1, src1w, TMP_REG2, 0); 1384 } 1385 if (TEST_UL_IMM(src1, src1w)) { 1386 compiler->imm = src1w; 1387 return emit_op(compiler, GET_OPCODE(op), flags | ALT_FORM1, dst, dstw, src2, src2w, TMP_REG2, 0); 1388 } 1389 if (TEST_UH_IMM(src2, src2w)) { 1390 compiler->imm = (src2w >> 16) & 0xffff; 1391 return emit_op(compiler, GET_OPCODE(op), flags | ALT_FORM2, dst, dstw, src1, src1w, TMP_REG2, 0); 1392 } 1393 if (TEST_UH_IMM(src1, src1w)) { 1394 compiler->imm = (src1w >> 16) & 0xffff; 1395 return emit_op(compiler, GET_OPCODE(op), flags | ALT_FORM2, dst, dstw, src2, src2w, TMP_REG2, 0); 1396 } 1397 } 1398 if (!GET_FLAGS(op) && GET_OPCODE(op) != SLJIT_AND) { 1399 if (TEST_UI_IMM(src2, src2w)) { 1400 compiler->imm = src2w; 1401 return emit_op(compiler, GET_OPCODE(op), flags | ALT_FORM3, dst, dstw, src1, src1w, TMP_REG2, 0); 1402 } 1403 if (TEST_UI_IMM(src1, src1w)) { 1404 compiler->imm = src1w; 1405 return emit_op(compiler, GET_OPCODE(op), flags | ALT_FORM3, dst, dstw, src2, src2w, TMP_REG2, 0); 1406 } 1407 } 1408 return emit_op(compiler, GET_OPCODE(op), flags, dst, dstw, src1, src1w, src2, src2w); 1409 1410 case SLJIT_SHL: 1411 case SLJIT_LSHR: 1412 case SLJIT_ASHR: 1413 #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64) 1414 if (op & SLJIT_INT_OP) 1415 flags |= ALT_FORM2; 1416 #endif 1417 if (src2 & SLJIT_IMM) { 1418 compiler->imm = src2w; 1419 return emit_op(compiler, GET_OPCODE(op), flags | ALT_FORM1, dst, dstw, src1, src1w, TMP_REG2, 0); 1420 } 1421 return emit_op(compiler, GET_OPCODE(op), flags, dst, dstw, src1, src1w, src2, src2w); 1422 } 1423 1424 return SLJIT_SUCCESS; 1425 } 1426 1427 SLJIT_API_FUNC_ATTRIBUTE int sljit_get_register_index(int reg) 1428 { 1429 check_sljit_get_register_index(reg); 1430 return reg_map[reg]; 1431 } 1432 1433 SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_op_custom(struct sljit_compiler *compiler, 1434 void *instruction, int size) 1435 { 1436 CHECK_ERROR(); 1437 check_sljit_emit_op_custom(compiler, instruction, size); 1438 SLJIT_ASSERT(size == 4); 1439 1440 return push_inst(compiler, *(sljit_ins*)instruction); 1441 } 1442 1443 /* --------------------------------------------------------------------- */ 1444 /* Floating point operators */ 1445 /* --------------------------------------------------------------------- */ 1446 1447 SLJIT_API_FUNC_ATTRIBUTE int sljit_is_fpu_available(void) 1448 { 1449 /* Always available. */ 1450 return 1; 1451 } 1452 1453 SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_fop1(struct sljit_compiler *compiler, int op, 1454 int dst, sljit_w dstw, 1455 int src, sljit_w srcw) 1456 { 1457 int dst_fr; 1458 1459 CHECK_ERROR(); 1460 check_sljit_emit_fop1(compiler, op, dst, dstw, src, srcw); 1461 1462 compiler->cache_arg = 0; 1463 compiler->cache_argw = 0; 1464 1465 if (GET_OPCODE(op) == SLJIT_FCMP) { 1466 if (dst > SLJIT_FLOAT_REG4) { 1467 FAIL_IF(emit_op_mem2(compiler, DOUBLE_DATA | LOAD_DATA, TMP_FREG1, dst, dstw, src, srcw)); 1468 dst = TMP_FREG1; 1469 } 1470 1471 if (src > SLJIT_FLOAT_REG4) { 1472 FAIL_IF(emit_op_mem2(compiler, DOUBLE_DATA | LOAD_DATA, TMP_FREG2, src, srcw, 0, 0)); 1473 src = TMP_FREG2; 1474 } 1475 1476 return push_inst(compiler, FCMPU | CRD(4) | FA(dst) | FB(src)); 1477 } 1478 1479 dst_fr = (dst > SLJIT_FLOAT_REG4) ? TMP_FREG1 : dst; 1480 1481 if (src > SLJIT_FLOAT_REG4) { 1482 FAIL_IF(emit_op_mem2(compiler, DOUBLE_DATA | LOAD_DATA, dst_fr, src, srcw, dst, dstw)); 1483 src = dst_fr; 1484 } 1485 1486 switch (op) { 1487 case SLJIT_FMOV: 1488 if (src != dst_fr && dst_fr != TMP_FREG1) 1489 FAIL_IF(push_inst(compiler, FMR | FD(dst_fr) | FB(src))); 1490 break; 1491 case SLJIT_FNEG: 1492 FAIL_IF(push_inst(compiler, FNEG | FD(dst_fr) | FB(src))); 1493 break; 1494 case SLJIT_FABS: 1495 FAIL_IF(push_inst(compiler, FABS | FD(dst_fr) | FB(src))); 1496 break; 1497 } 1498 1499 if (dst_fr == TMP_FREG1) { 1500 if (op == SLJIT_FMOV) 1501 dst_fr = src; 1502 FAIL_IF(emit_op_mem2(compiler, DOUBLE_DATA, dst_fr, dst, dstw, 0, 0)); 1503 } 1504 1505 return SLJIT_SUCCESS; 1506 } 1507 1508 SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_fop2(struct sljit_compiler *compiler, int op, 1509 int dst, sljit_w dstw, 1510 int src1, sljit_w src1w, 1511 int src2, sljit_w src2w) 1512 { 1513 int dst_fr, flags = 0; 1514 1515 CHECK_ERROR(); 1516 check_sljit_emit_fop2(compiler, op, dst, dstw, src1, src1w, src2, src2w); 1517 1518 compiler->cache_arg = 0; 1519 compiler->cache_argw = 0; 1520 1521 dst_fr = (dst > SLJIT_FLOAT_REG4) ? TMP_FREG2 : dst; 1522 1523 if (src1 > SLJIT_FLOAT_REG4) { 1524 if (getput_arg_fast(compiler, DOUBLE_DATA | LOAD_DATA, TMP_FREG1, src1, src1w)) { 1525 FAIL_IF(compiler->error); 1526 src1 = TMP_FREG1; 1527 } else 1528 flags |= ALT_FORM1; 1529 } 1530 1531 if (src2 > SLJIT_FLOAT_REG4) { 1532 if (getput_arg_fast(compiler, DOUBLE_DATA | LOAD_DATA, TMP_FREG2, src2, src2w)) { 1533 FAIL_IF(compiler->error); 1534 src2 = TMP_FREG2; 1535 } else 1536 flags |= ALT_FORM2; 1537 } 1538 1539 if ((flags & (ALT_FORM1 | ALT_FORM2)) == (ALT_FORM1 | ALT_FORM2)) { 1540 if (!can_cache(src1, src1w, src2, src2w) && can_cache(src1, src1w, dst, dstw)) { 1541 FAIL_IF(getput_arg(compiler, DOUBLE_DATA | LOAD_DATA, TMP_FREG2, src2, src2w, src1, src1w)); 1542 FAIL_IF(getput_arg(compiler, DOUBLE_DATA | LOAD_DATA, TMP_FREG1, src1, src1w, dst, dstw)); 1543 } 1544 else { 1545 FAIL_IF(getput_arg(compiler, DOUBLE_DATA | LOAD_DATA, TMP_FREG1, src1, src1w, src2, src2w)); 1546 FAIL_IF(getput_arg(compiler, DOUBLE_DATA | LOAD_DATA, TMP_FREG2, src2, src2w, dst, dstw)); 1547 } 1548 } 1549 else if (flags & ALT_FORM1) 1550 FAIL_IF(getput_arg(compiler, DOUBLE_DATA | LOAD_DATA, TMP_FREG1, src1, src1w, dst, dstw)); 1551 else if (flags & ALT_FORM2) 1552 FAIL_IF(getput_arg(compiler, DOUBLE_DATA | LOAD_DATA, TMP_FREG2, src2, src2w, dst, dstw)); 1553 1554 if (flags & ALT_FORM1) 1555 src1 = TMP_FREG1; 1556 if (flags & ALT_FORM2) 1557 src2 = TMP_FREG2; 1558 1559 switch (op) { 1560 case SLJIT_FADD: 1561 FAIL_IF(push_inst(compiler, FADD | FD(dst_fr) | FA(src1) | FB(src2))); 1562 break; 1563 1564 case SLJIT_FSUB: 1565 FAIL_IF(push_inst(compiler, FSUB | FD(dst_fr) | FA(src1) | FB(src2))); 1566 break; 1567 1568 case SLJIT_FMUL: 1569 FAIL_IF(push_inst(compiler, FMUL | FD(dst_fr) | FA(src1) | FC(src2) /* FMUL use FC as src2 */)); 1570 break; 1571 1572 case SLJIT_FDIV: 1573 FAIL_IF(push_inst(compiler, FDIV | FD(dst_fr) | FA(src1) | FB(src2))); 1574 break; 1575 } 1576 1577 if (dst_fr == TMP_FREG2) 1578 FAIL_IF(emit_op_mem2(compiler, DOUBLE_DATA, TMP_FREG2, dst, dstw, 0, 0)); 1579 1580 return SLJIT_SUCCESS; 1581 } 1582 1583 /* --------------------------------------------------------------------- */ 1584 /* Other instructions */ 1585 /* --------------------------------------------------------------------- */ 1586 1587 SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_fast_enter(struct sljit_compiler *compiler, int dst, sljit_w dstw) 1588 { 1589 CHECK_ERROR(); 1590 check_sljit_emit_fast_enter(compiler, dst, dstw); 1591 ADJUST_LOCAL_OFFSET(dst, dstw); 1592 1593 if (dst >= SLJIT_TEMPORARY_REG1 && dst <= SLJIT_NO_REGISTERS) 1594 return push_inst(compiler, MFLR | D(dst)); 1595 else if (dst & SLJIT_MEM) { 1596 FAIL_IF(push_inst(compiler, MFLR | D(TMP_REG2))); 1597 return emit_op(compiler, SLJIT_MOV, WORD_DATA, dst, dstw, TMP_REG1, 0, TMP_REG2, 0); 1598 } 1599 1600 /* SLJIT_UNUSED is also possible, although highly unlikely. */ 1601 return SLJIT_SUCCESS; 1602 } 1603 1604 SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_fast_return(struct sljit_compiler *compiler, int src, sljit_w srcw) 1605 { 1606 CHECK_ERROR(); 1607 check_sljit_emit_fast_return(compiler, src, srcw); 1608 ADJUST_LOCAL_OFFSET(src, srcw); 1609 1610 if (src >= SLJIT_TEMPORARY_REG1 && src <= SLJIT_NO_REGISTERS) 1611 FAIL_IF(push_inst(compiler, MTLR | S(src))); 1612 else { 1613 if (src & SLJIT_MEM) 1614 FAIL_IF(emit_op(compiler, SLJIT_MOV, WORD_DATA, TMP_REG2, 0, TMP_REG1, 0, src, srcw)); 1615 else if (src & SLJIT_IMM) 1616 FAIL_IF(load_immediate(compiler, TMP_REG2, srcw)); 1617 FAIL_IF(push_inst(compiler, MTLR | S(TMP_REG2))); 1618 } 1619 return push_inst(compiler, BLR); 1620 } 1621 1622 /* --------------------------------------------------------------------- */ 1623 /* Conditional instructions */ 1624 /* --------------------------------------------------------------------- */ 1625 1626 SLJIT_API_FUNC_ATTRIBUTE struct sljit_label* sljit_emit_label(struct sljit_compiler *compiler) 1627 { 1628 struct sljit_label *label; 1629 1630 CHECK_ERROR_PTR(); 1631 check_sljit_emit_label(compiler); 1632 1633 if (compiler->last_label && compiler->last_label->size == compiler->size) 1634 return compiler->last_label; 1635 1636 label = (struct sljit_label*)ensure_abuf(compiler, sizeof(struct sljit_label)); 1637 PTR_FAIL_IF(!label); 1638 set_label(label, compiler); 1639 return label; 1640 } 1641 1642 static sljit_ins get_bo_bi_flags(int type) 1643 { 1644 switch (type) { 1645 case SLJIT_C_EQUAL: 1646 return (12 << 21) | (2 << 16); 1647 1648 case SLJIT_C_NOT_EQUAL: 1649 return (4 << 21) | (2 << 16); 1650 1651 case SLJIT_C_LESS: 1652 case SLJIT_C_FLOAT_LESS: 1653 return (12 << 21) | ((4 + 0) << 16); 1654 1655 case SLJIT_C_GREATER_EQUAL: 1656 case SLJIT_C_FLOAT_GREATER_EQUAL: 1657 return (4 << 21) | ((4 + 0) << 16); 1658 1659 case SLJIT_C_GREATER: 1660 case SLJIT_C_FLOAT_GREATER: 1661 return (12 << 21) | ((4 + 1) << 16); 1662 1663 case SLJIT_C_LESS_EQUAL: 1664 case SLJIT_C_FLOAT_LESS_EQUAL: 1665 return (4 << 21) | ((4 + 1) << 16); 1666 1667 case SLJIT_C_SIG_LESS: 1668 return (12 << 21) | (0 << 16); 1669 1670 case SLJIT_C_SIG_GREATER_EQUAL: 1671 return (4 << 21) | (0 << 16); 1672 1673 case SLJIT_C_SIG_GREATER: 1674 return (12 << 21) | (1 << 16); 1675 1676 case SLJIT_C_SIG_LESS_EQUAL: 1677 return (4 << 21) | (1 << 16); 1678 1679 case SLJIT_C_OVERFLOW: 1680 case SLJIT_C_MUL_OVERFLOW: 1681 return (12 << 21) | (3 << 16); 1682 1683 case SLJIT_C_NOT_OVERFLOW: 1684 case SLJIT_C_MUL_NOT_OVERFLOW: 1685 return (4 << 21) | (3 << 16); 1686 1687 case SLJIT_C_FLOAT_EQUAL: 1688 return (12 << 21) | ((4 + 2) << 16); 1689 1690 case SLJIT_C_FLOAT_NOT_EQUAL: 1691 return (4 << 21) | ((4 + 2) << 16); 1692 1693 case SLJIT_C_FLOAT_UNORDERED: 1694 return (12 << 21) | ((4 + 3) << 16); 1695 1696 case SLJIT_C_FLOAT_ORDERED: 1697 return (4 << 21) | ((4 + 3) << 16); 1698 1699 default: 1700 SLJIT_ASSERT(type >= SLJIT_JUMP && type <= SLJIT_CALL3); 1701 return (20 << 21); 1702 } 1703 } 1704 1705 SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_jump(struct sljit_compiler *compiler, int type) 1706 { 1707 struct sljit_jump *jump; 1708 sljit_ins bo_bi_flags; 1709 1710 CHECK_ERROR_PTR(); 1711 check_sljit_emit_jump(compiler, type); 1712 1713 bo_bi_flags = get_bo_bi_flags(type & 0xff); 1714 if (!bo_bi_flags) 1715 return NULL; 1716 1717 jump = (struct sljit_jump*)ensure_abuf(compiler, sizeof(struct sljit_jump)); 1718 PTR_FAIL_IF(!jump); 1719 set_jump(jump, compiler, type & SLJIT_REWRITABLE_JUMP); 1720 type &= 0xff; 1721 1722 /* In PPC, we don't need to touch the arguments. */ 1723 if (type >= SLJIT_JUMP) 1724 jump->flags |= UNCOND_B; 1725 1726 PTR_FAIL_IF(emit_const(compiler, TMP_REG1, 0)); 1727 PTR_FAIL_IF(push_inst(compiler, MTCTR | S(TMP_REG1))); 1728 jump->addr = compiler->size; 1729 PTR_FAIL_IF(push_inst(compiler, BCCTR | bo_bi_flags | (type >= SLJIT_FAST_CALL ? 1 : 0))); 1730 return jump; 1731 } 1732 1733 SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ijump(struct sljit_compiler *compiler, int type, int src, sljit_w srcw) 1734 { 1735 struct sljit_jump *jump = NULL; 1736 int src_r; 1737 1738 CHECK_ERROR(); 1739 check_sljit_emit_ijump(compiler, type, src, srcw); 1740 ADJUST_LOCAL_OFFSET(src, srcw); 1741 1742 if (src >= SLJIT_TEMPORARY_REG1 && src <= SLJIT_NO_REGISTERS) 1743 src_r = src; 1744 else if (src & SLJIT_IMM) { 1745 jump = (struct sljit_jump*)ensure_abuf(compiler, sizeof(struct sljit_jump)); 1746 FAIL_IF(!jump); 1747 set_jump(jump, compiler, JUMP_ADDR | UNCOND_B); 1748 jump->u.target = srcw; 1749 1750 FAIL_IF(emit_const(compiler, TMP_REG2, 0)); 1751 src_r = TMP_REG2; 1752 } 1753 else { 1754 FAIL_IF(emit_op(compiler, SLJIT_MOV, WORD_DATA, TMP_REG2, 0, TMP_REG1, 0, src, srcw)); 1755 src_r = TMP_REG2; 1756 } 1757 1758 FAIL_IF(push_inst(compiler, MTCTR | S(src_r))); 1759 if (jump) 1760 jump->addr = compiler->size; 1761 return push_inst(compiler, BCCTR | (20 << 21) | (type >= SLJIT_FAST_CALL ? 1 : 0)); 1762 } 1763 1764 /* Get a bit from CR, all other bits are zeroed. */ 1765 #define GET_CR_BIT(bit, dst) \ 1766 FAIL_IF(push_inst(compiler, MFCR | D(dst))); \ 1767 FAIL_IF(push_inst(compiler, RLWINM | S(dst) | A(dst) | ((1 + (bit)) << 11) | (31 << 6) | (31 << 1))); 1768 1769 #define INVERT_BIT(dst) \ 1770 FAIL_IF(push_inst(compiler, XORI | S(dst) | A(dst) | 0x1)); 1771 1772 SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_cond_value(struct sljit_compiler *compiler, int op, int dst, sljit_w dstw, int type) 1773 { 1774 int reg; 1775 1776 CHECK_ERROR(); 1777 check_sljit_emit_cond_value(compiler, op, dst, dstw, type); 1778 ADJUST_LOCAL_OFFSET(dst, dstw); 1779 1780 if (dst == SLJIT_UNUSED) 1781 return SLJIT_SUCCESS; 1782 1783 reg = (op == SLJIT_MOV && dst >= SLJIT_TEMPORARY_REG1 && dst <= SLJIT_NO_REGISTERS) ? dst : TMP_REG2; 1784 1785 switch (type) { 1786 case SLJIT_C_EQUAL: 1787 GET_CR_BIT(2, reg); 1788 break; 1789 1790 case SLJIT_C_NOT_EQUAL: 1791 GET_CR_BIT(2, reg); 1792 INVERT_BIT(reg); 1793 break; 1794 1795 case SLJIT_C_LESS: 1796 case SLJIT_C_FLOAT_LESS: 1797 GET_CR_BIT(4 + 0, reg); 1798 break; 1799 1800 case SLJIT_C_GREATER_EQUAL: 1801 case SLJIT_C_FLOAT_GREATER_EQUAL: 1802 GET_CR_BIT(4 + 0, reg); 1803 INVERT_BIT(reg); 1804 break; 1805 1806 case SLJIT_C_GREATER: 1807 case SLJIT_C_FLOAT_GREATER: 1808 GET_CR_BIT(4 + 1, reg); 1809 break; 1810 1811 case SLJIT_C_LESS_EQUAL: 1812 case SLJIT_C_FLOAT_LESS_EQUAL: 1813 GET_CR_BIT(4 + 1, reg); 1814 INVERT_BIT(reg); 1815 break; 1816 1817 case SLJIT_C_SIG_LESS: 1818 GET_CR_BIT(0, reg); 1819 break; 1820 1821 case SLJIT_C_SIG_GREATER_EQUAL: 1822 GET_CR_BIT(0, reg); 1823 INVERT_BIT(reg); 1824 break; 1825 1826 case SLJIT_C_SIG_GREATER: 1827 GET_CR_BIT(1, reg); 1828 break; 1829 1830 case SLJIT_C_SIG_LESS_EQUAL: 1831 GET_CR_BIT(1, reg); 1832 INVERT_BIT(reg); 1833 break; 1834 1835 case SLJIT_C_OVERFLOW: 1836 case SLJIT_C_MUL_OVERFLOW: 1837 GET_CR_BIT(3, reg); 1838 break; 1839 1840 case SLJIT_C_NOT_OVERFLOW: 1841 case SLJIT_C_MUL_NOT_OVERFLOW: 1842 GET_CR_BIT(3, reg); 1843 INVERT_BIT(reg); 1844 break; 1845 1846 case SLJIT_C_FLOAT_EQUAL: 1847 GET_CR_BIT(4 + 2, reg); 1848 break; 1849 1850 case SLJIT_C_FLOAT_NOT_EQUAL: 1851 GET_CR_BIT(4 + 2, reg); 1852 INVERT_BIT(reg); 1853 break; 1854 1855 case SLJIT_C_FLOAT_UNORDERED: 1856 GET_CR_BIT(4 + 3, reg); 1857 break; 1858 1859 case SLJIT_C_FLOAT_ORDERED: 1860 GET_CR_BIT(4 + 3, reg); 1861 INVERT_BIT(reg); 1862 break; 1863 1864 default: 1865 SLJIT_ASSERT_STOP(); 1866 break; 1867 } 1868 1869 if (GET_OPCODE(op) == SLJIT_OR) 1870 return emit_op(compiler, SLJIT_OR, GET_FLAGS(op) ? ALT_SET_FLAGS : 0, dst, dstw, dst, dstw, TMP_REG2, 0); 1871 1872 return (reg == TMP_REG2) ? emit_op(compiler, SLJIT_MOV, WORD_DATA, dst, dstw, TMP_REG1, 0, TMP_REG2, 0) : SLJIT_SUCCESS; 1873 } 1874 1875 SLJIT_API_FUNC_ATTRIBUTE struct sljit_const* sljit_emit_const(struct sljit_compiler *compiler, int dst, sljit_w dstw, sljit_w init_value) 1876 { 1877 struct sljit_const *const_; 1878 int reg; 1879 1880 CHECK_ERROR_PTR(); 1881 check_sljit_emit_const(compiler, dst, dstw, init_value); 1882 ADJUST_LOCAL_OFFSET(dst, dstw); 1883 1884 const_ = (struct sljit_const*)ensure_abuf(compiler, sizeof(struct sljit_const)); 1885 PTR_FAIL_IF(!const_); 1886 set_const(const_, compiler); 1887 1888 reg = (dst >= SLJIT_TEMPORARY_REG1 && dst <= SLJIT_NO_REGISTERS) ? dst : TMP_REG2; 1889 1890 PTR_FAIL_IF(emit_const(compiler, reg, init_value)); 1891 1892 if (dst & SLJIT_MEM) 1893 PTR_FAIL_IF(emit_op(compiler, SLJIT_MOV, WORD_DATA, dst, dstw, TMP_REG1, 0, TMP_REG2, 0)); 1894 return const_; 1895 } 1896