sljitNativeMIPS_64.c revision 1.1.1.3
1 /* 2 * Stack-less Just-In-Time compiler 3 * 4 * Copyright Zoltan Herczeg (hzmester (at) freemail.hu). All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without modification, are 7 * permitted provided that the following conditions are met: 8 * 9 * 1. Redistributions of source code must retain the above copyright notice, this list of 10 * conditions and the following disclaimer. 11 * 12 * 2. Redistributions in binary form must reproduce the above copyright notice, this list 13 * of conditions and the following disclaimer in the documentation and/or other materials 14 * provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) AND CONTRIBUTORS ``AS IS'' AND ANY 17 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT 19 * SHALL THE COPYRIGHT HOLDER(S) OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED 21 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR 22 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 23 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN 24 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 25 */ 26 27 /* mips 64-bit arch dependent functions. */ 28 29 static sljit_s32 load_immediate(struct sljit_compiler *compiler, sljit_s32 dst_ar, sljit_sw imm) 30 { 31 sljit_s32 shift = 32; 32 sljit_s32 shift2; 33 sljit_s32 inv = 0; 34 sljit_ins ins; 35 sljit_uw uimm; 36 37 if (!(imm & ~0xffff)) 38 return push_inst(compiler, ORI | SA(0) | TA(dst_ar) | IMM(imm), dst_ar); 39 40 if (imm < 0 && imm >= SIMM_MIN) 41 return push_inst(compiler, ADDIU | SA(0) | TA(dst_ar) | IMM(imm), dst_ar); 42 43 if (imm <= 0x7fffffffl && imm >= -0x80000000l) { 44 FAIL_IF(push_inst(compiler, LUI | TA(dst_ar) | IMM(imm >> 16), dst_ar)); 45 return (imm & 0xffff) ? push_inst(compiler, ORI | SA(dst_ar) | TA(dst_ar) | IMM(imm), dst_ar) : SLJIT_SUCCESS; 46 } 47 48 /* Zero extended number. */ 49 uimm = imm; 50 if (imm < 0) { 51 uimm = ~imm; 52 inv = 1; 53 } 54 55 while (!(uimm & 0xff00000000000000l)) { 56 shift -= 8; 57 uimm <<= 8; 58 } 59 60 if (!(uimm & 0xf000000000000000l)) { 61 shift -= 4; 62 uimm <<= 4; 63 } 64 65 if (!(uimm & 0xc000000000000000l)) { 66 shift -= 2; 67 uimm <<= 2; 68 } 69 70 if ((sljit_sw)uimm < 0) { 71 uimm >>= 1; 72 shift += 1; 73 } 74 SLJIT_ASSERT(((uimm & 0xc000000000000000l) == 0x4000000000000000l) && (shift > 0) && (shift <= 32)); 75 76 if (inv) 77 uimm = ~uimm; 78 79 FAIL_IF(push_inst(compiler, LUI | TA(dst_ar) | IMM(uimm >> 48), dst_ar)); 80 if (uimm & 0x0000ffff00000000l) 81 FAIL_IF(push_inst(compiler, ORI | SA(dst_ar) | TA(dst_ar) | IMM(uimm >> 32), dst_ar)); 82 83 imm &= (1l << shift) - 1; 84 if (!(imm & ~0xffff)) { 85 ins = (shift == 32) ? DSLL32 : DSLL; 86 if (shift < 32) 87 ins |= SH_IMM(shift); 88 FAIL_IF(push_inst(compiler, ins | TA(dst_ar) | DA(dst_ar), dst_ar)); 89 return !(imm & 0xffff) ? SLJIT_SUCCESS : push_inst(compiler, ORI | SA(dst_ar) | TA(dst_ar) | IMM(imm), dst_ar); 90 } 91 92 /* Double shifts needs to be performed. */ 93 uimm <<= 32; 94 shift2 = shift - 16; 95 96 while (!(uimm & 0xf000000000000000l)) { 97 shift2 -= 4; 98 uimm <<= 4; 99 } 100 101 if (!(uimm & 0xc000000000000000l)) { 102 shift2 -= 2; 103 uimm <<= 2; 104 } 105 106 if (!(uimm & 0x8000000000000000l)) { 107 shift2--; 108 uimm <<= 1; 109 } 110 111 SLJIT_ASSERT((uimm & 0x8000000000000000l) && (shift2 > 0) && (shift2 <= 16)); 112 113 FAIL_IF(push_inst(compiler, DSLL | TA(dst_ar) | DA(dst_ar) | SH_IMM(shift - shift2), dst_ar)); 114 FAIL_IF(push_inst(compiler, ORI | SA(dst_ar) | TA(dst_ar) | IMM(uimm >> 48), dst_ar)); 115 FAIL_IF(push_inst(compiler, DSLL | TA(dst_ar) | DA(dst_ar) | SH_IMM(shift2), dst_ar)); 116 117 imm &= (1l << shift2) - 1; 118 return !(imm & 0xffff) ? SLJIT_SUCCESS : push_inst(compiler, ORI | SA(dst_ar) | TA(dst_ar) | IMM(imm), dst_ar); 119 } 120 121 #define SELECT_OP(a, b) \ 122 (!(op & SLJIT_I32_OP) ? a : b) 123 124 #define EMIT_LOGICAL(op_imm, op_norm) \ 125 if (flags & SRC2_IMM) { \ 126 if (op & SLJIT_SET_Z) \ 127 FAIL_IF(push_inst(compiler, op_imm | S(src1) | TA(EQUAL_FLAG) | IMM(src2), EQUAL_FLAG)); \ 128 if (!(flags & UNUSED_DEST)) \ 129 FAIL_IF(push_inst(compiler, op_imm | S(src1) | T(dst) | IMM(src2), DR(dst))); \ 130 } \ 131 else { \ 132 if (op & SLJIT_SET_Z) \ 133 FAIL_IF(push_inst(compiler, op_norm | S(src1) | T(src2) | DA(EQUAL_FLAG), EQUAL_FLAG)); \ 134 if (!(flags & UNUSED_DEST)) \ 135 FAIL_IF(push_inst(compiler, op_norm | S(src1) | T(src2) | D(dst), DR(dst))); \ 136 } 137 138 #define EMIT_SHIFT(op_dimm, op_dimm32, op_imm, op_dv, op_v) \ 139 if (flags & SRC2_IMM) { \ 140 if (src2 >= 32) { \ 141 SLJIT_ASSERT(!(op & SLJIT_I32_OP)); \ 142 ins = op_dimm32; \ 143 src2 -= 32; \ 144 } \ 145 else \ 146 ins = (op & SLJIT_I32_OP) ? op_imm : op_dimm; \ 147 if (op & SLJIT_SET_Z) \ 148 FAIL_IF(push_inst(compiler, ins | T(src1) | DA(EQUAL_FLAG) | SH_IMM(src2), EQUAL_FLAG)); \ 149 if (!(flags & UNUSED_DEST)) \ 150 FAIL_IF(push_inst(compiler, ins | T(src1) | D(dst) | SH_IMM(src2), DR(dst))); \ 151 } \ 152 else { \ 153 ins = (op & SLJIT_I32_OP) ? op_v : op_dv; \ 154 if (op & SLJIT_SET_Z) \ 155 FAIL_IF(push_inst(compiler, ins | S(src2) | T(src1) | DA(EQUAL_FLAG), EQUAL_FLAG)); \ 156 if (!(flags & UNUSED_DEST)) \ 157 FAIL_IF(push_inst(compiler, ins | S(src2) | T(src1) | D(dst), DR(dst))); \ 158 } 159 160 static SLJIT_INLINE sljit_s32 emit_single_op(struct sljit_compiler *compiler, sljit_s32 op, sljit_s32 flags, 161 sljit_s32 dst, sljit_s32 src1, sljit_sw src2) 162 { 163 sljit_ins ins; 164 sljit_s32 is_overflow, is_carry, is_handled; 165 166 switch (GET_OPCODE(op)) { 167 case SLJIT_MOV: 168 case SLJIT_MOV_P: 169 SLJIT_ASSERT(src1 == TMP_REG1 && !(flags & SRC2_IMM)); 170 if (dst != src2) 171 return push_inst(compiler, SELECT_OP(DADDU, ADDU) | S(src2) | TA(0) | D(dst), DR(dst)); 172 return SLJIT_SUCCESS; 173 174 case SLJIT_MOV_U8: 175 case SLJIT_MOV_S8: 176 SLJIT_ASSERT(src1 == TMP_REG1 && !(flags & SRC2_IMM)); 177 if ((flags & (REG_DEST | REG2_SOURCE)) == (REG_DEST | REG2_SOURCE)) { 178 if (op == SLJIT_MOV_S8) { 179 FAIL_IF(push_inst(compiler, DSLL32 | T(src2) | D(dst) | SH_IMM(24), DR(dst))); 180 return push_inst(compiler, DSRA32 | T(dst) | D(dst) | SH_IMM(24), DR(dst)); 181 } 182 return push_inst(compiler, ANDI | S(src2) | T(dst) | IMM(0xff), DR(dst)); 183 } 184 else { 185 SLJIT_ASSERT(dst == src2); 186 } 187 return SLJIT_SUCCESS; 188 189 case SLJIT_MOV_U16: 190 case SLJIT_MOV_S16: 191 SLJIT_ASSERT(src1 == TMP_REG1 && !(flags & SRC2_IMM)); 192 if ((flags & (REG_DEST | REG2_SOURCE)) == (REG_DEST | REG2_SOURCE)) { 193 if (op == SLJIT_MOV_S16) { 194 FAIL_IF(push_inst(compiler, DSLL32 | T(src2) | D(dst) | SH_IMM(16), DR(dst))); 195 return push_inst(compiler, DSRA32 | T(dst) | D(dst) | SH_IMM(16), DR(dst)); 196 } 197 return push_inst(compiler, ANDI | S(src2) | T(dst) | IMM(0xffff), DR(dst)); 198 } 199 else { 200 SLJIT_ASSERT(dst == src2); 201 } 202 return SLJIT_SUCCESS; 203 204 case SLJIT_MOV_U32: 205 SLJIT_ASSERT(!(op & SLJIT_I32_OP)); 206 FAIL_IF(push_inst(compiler, DSLL32 | T(src2) | D(dst) | SH_IMM(0), DR(dst))); 207 return push_inst(compiler, DSRL32 | T(dst) | D(dst) | SH_IMM(0), DR(dst)); 208 209 case SLJIT_MOV_S32: 210 SLJIT_ASSERT(src1 == TMP_REG1 && !(flags & SRC2_IMM)); 211 return push_inst(compiler, SLL | T(src2) | D(dst) | SH_IMM(0), DR(dst)); 212 213 case SLJIT_NOT: 214 SLJIT_ASSERT(src1 == TMP_REG1 && !(flags & SRC2_IMM)); 215 if (op & SLJIT_SET_Z) 216 FAIL_IF(push_inst(compiler, NOR | S(src2) | T(src2) | DA(EQUAL_FLAG), EQUAL_FLAG)); 217 if (!(flags & UNUSED_DEST)) 218 FAIL_IF(push_inst(compiler, NOR | S(src2) | T(src2) | D(dst), DR(dst))); 219 return SLJIT_SUCCESS; 220 221 case SLJIT_CLZ: 222 SLJIT_ASSERT(src1 == TMP_REG1 && !(flags & SRC2_IMM)); 223 #if (defined SLJIT_MIPS_R1 && SLJIT_MIPS_R1) 224 if (op & SLJIT_SET_Z) 225 FAIL_IF(push_inst(compiler, SELECT_OP(DCLZ, CLZ) | S(src2) | TA(EQUAL_FLAG) | DA(EQUAL_FLAG), EQUAL_FLAG)); 226 if (!(flags & UNUSED_DEST)) 227 FAIL_IF(push_inst(compiler, SELECT_OP(DCLZ, CLZ) | S(src2) | T(dst) | D(dst), DR(dst))); 228 #else 229 if (SLJIT_UNLIKELY(flags & UNUSED_DEST)) { 230 FAIL_IF(push_inst(compiler, SELECT_OP(DSRL32, SRL) | T(src2) | DA(EQUAL_FLAG) | SH_IMM(31), EQUAL_FLAG)); 231 return push_inst(compiler, XORI | SA(EQUAL_FLAG) | TA(EQUAL_FLAG) | IMM(1), EQUAL_FLAG); 232 } 233 /* Nearly all instructions are unmovable in the following sequence. */ 234 FAIL_IF(push_inst(compiler, SELECT_OP(DADDU, ADDU) | S(src2) | TA(0) | D(TMP_REG1), DR(TMP_REG1))); 235 /* Check zero. */ 236 FAIL_IF(push_inst(compiler, BEQ | S(TMP_REG1) | TA(0) | IMM(5), UNMOVABLE_INS)); 237 FAIL_IF(push_inst(compiler, ORI | SA(0) | T(dst) | IMM((op & SLJIT_I32_OP) ? 32 : 64), UNMOVABLE_INS)); 238 FAIL_IF(push_inst(compiler, SELECT_OP(DADDIU, ADDIU) | SA(0) | T(dst) | IMM(-1), DR(dst))); 239 /* Loop for searching the highest bit. */ 240 FAIL_IF(push_inst(compiler, SELECT_OP(DADDIU, ADDIU) | S(dst) | T(dst) | IMM(1), DR(dst))); 241 FAIL_IF(push_inst(compiler, BGEZ | S(TMP_REG1) | IMM(-2), UNMOVABLE_INS)); 242 FAIL_IF(push_inst(compiler, SELECT_OP(DSLL, SLL) | T(TMP_REG1) | D(TMP_REG1) | SH_IMM(1), UNMOVABLE_INS)); 243 if (op & SLJIT_SET_Z) 244 return push_inst(compiler, SELECT_OP(DADDU, ADDU) | S(dst) | TA(0) | DA(EQUAL_FLAG), EQUAL_FLAG); 245 #endif 246 return SLJIT_SUCCESS; 247 248 case SLJIT_ADD: 249 is_overflow = GET_FLAG_TYPE(op) == SLJIT_OVERFLOW || GET_FLAG_TYPE(op) == SLJIT_NOT_OVERFLOW; 250 is_carry = GET_FLAG_TYPE(op) == GET_FLAG_TYPE(SLJIT_SET_CARRY); 251 252 if (flags & SRC2_IMM) { 253 if (is_overflow) { 254 if (src2 >= 0) 255 FAIL_IF(push_inst(compiler, OR | S(src1) | T(src1) | DA(EQUAL_FLAG), EQUAL_FLAG)); 256 else 257 FAIL_IF(push_inst(compiler, NOR | S(src1) | T(src1) | DA(EQUAL_FLAG), EQUAL_FLAG)); 258 } 259 else if (op & SLJIT_SET_Z) 260 FAIL_IF(push_inst(compiler, SELECT_OP(DADDIU, ADDIU) | S(src1) | TA(EQUAL_FLAG) | IMM(src2), EQUAL_FLAG)); 261 262 if (is_overflow || is_carry) { 263 if (src2 >= 0) 264 FAIL_IF(push_inst(compiler, ORI | S(src1) | TA(OTHER_FLAG) | IMM(src2), OTHER_FLAG)); 265 else { 266 FAIL_IF(push_inst(compiler, SELECT_OP(DADDIU, ADDIU) | SA(0) | TA(OTHER_FLAG) | IMM(src2), OTHER_FLAG)); 267 FAIL_IF(push_inst(compiler, OR | S(src1) | TA(OTHER_FLAG) | DA(OTHER_FLAG), OTHER_FLAG)); 268 } 269 } 270 /* dst may be the same as src1 or src2. */ 271 if (!(flags & UNUSED_DEST) || (op & VARIABLE_FLAG_MASK)) 272 FAIL_IF(push_inst(compiler, SELECT_OP(DADDIU, ADDIU) | S(src1) | T(dst) | IMM(src2), DR(dst))); 273 } 274 else { 275 if (is_overflow) 276 FAIL_IF(push_inst(compiler, XOR | S(src1) | T(src2) | DA(EQUAL_FLAG), EQUAL_FLAG)); 277 else if (op & SLJIT_SET_Z) 278 FAIL_IF(push_inst(compiler, SELECT_OP(DADDU, ADDU) | S(src1) | T(src2) | DA(EQUAL_FLAG), EQUAL_FLAG)); 279 280 if (is_overflow || is_carry) 281 FAIL_IF(push_inst(compiler, OR | S(src1) | T(src2) | DA(OTHER_FLAG), OTHER_FLAG)); 282 /* dst may be the same as src1 or src2. */ 283 if (!(flags & UNUSED_DEST) || (op & VARIABLE_FLAG_MASK)) 284 FAIL_IF(push_inst(compiler, SELECT_OP(DADDU, ADDU) | S(src1) | T(src2) | D(dst), DR(dst))); 285 } 286 287 /* a + b >= a | b (otherwise, the carry should be set to 1). */ 288 if (is_overflow || is_carry) 289 FAIL_IF(push_inst(compiler, SLTU | S(dst) | TA(OTHER_FLAG) | DA(OTHER_FLAG), OTHER_FLAG)); 290 if (!is_overflow) 291 return SLJIT_SUCCESS; 292 FAIL_IF(push_inst(compiler, SELECT_OP(DSLL32, SLL) | TA(OTHER_FLAG) | D(TMP_REG1) | SH_IMM(31), DR(TMP_REG1))); 293 FAIL_IF(push_inst(compiler, XOR | S(TMP_REG1) | TA(EQUAL_FLAG) | DA(EQUAL_FLAG), EQUAL_FLAG)); 294 FAIL_IF(push_inst(compiler, XOR | S(dst) | TA(EQUAL_FLAG) | DA(OTHER_FLAG), OTHER_FLAG)); 295 if (op & SLJIT_SET_Z) 296 FAIL_IF(push_inst(compiler, SELECT_OP(DADDU, ADDU) | S(dst) | TA(0) | DA(EQUAL_FLAG), EQUAL_FLAG)); 297 return push_inst(compiler, SELECT_OP(DSRL32, SRL) | TA(OTHER_FLAG) | DA(OTHER_FLAG) | SH_IMM(31), OTHER_FLAG); 298 299 case SLJIT_ADDC: 300 is_carry = GET_FLAG_TYPE(op) == GET_FLAG_TYPE(SLJIT_SET_CARRY); 301 302 if (flags & SRC2_IMM) { 303 if (is_carry) { 304 if (src2 >= 0) 305 FAIL_IF(push_inst(compiler, ORI | S(src1) | TA(EQUAL_FLAG) | IMM(src2), EQUAL_FLAG)); 306 else { 307 FAIL_IF(push_inst(compiler, SELECT_OP(DADDIU, ADDIU) | SA(0) | TA(EQUAL_FLAG) | IMM(src2), EQUAL_FLAG)); 308 FAIL_IF(push_inst(compiler, OR | S(src1) | TA(EQUAL_FLAG) | DA(EQUAL_FLAG), EQUAL_FLAG)); 309 } 310 } 311 FAIL_IF(push_inst(compiler, SELECT_OP(DADDIU, ADDIU) | S(src1) | T(dst) | IMM(src2), DR(dst))); 312 } else { 313 if (is_carry) 314 FAIL_IF(push_inst(compiler, OR | S(src1) | T(src2) | DA(EQUAL_FLAG), EQUAL_FLAG)); 315 /* dst may be the same as src1 or src2. */ 316 FAIL_IF(push_inst(compiler, SELECT_OP(DADDU, ADDU) | S(src1) | T(src2) | D(dst), DR(dst))); 317 } 318 if (is_carry) 319 FAIL_IF(push_inst(compiler, SLTU | S(dst) | TA(EQUAL_FLAG) | DA(EQUAL_FLAG), EQUAL_FLAG)); 320 321 FAIL_IF(push_inst(compiler, SELECT_OP(DADDU, ADDU) | S(dst) | TA(OTHER_FLAG) | D(dst), DR(dst))); 322 if (!is_carry) 323 return SLJIT_SUCCESS; 324 325 /* Set ULESS_FLAG (dst == 0) && (OTHER_FLAG == 1). */ 326 FAIL_IF(push_inst(compiler, SLTU | S(dst) | TA(OTHER_FLAG) | DA(OTHER_FLAG), OTHER_FLAG)); 327 /* Set carry flag. */ 328 return push_inst(compiler, OR | SA(OTHER_FLAG) | TA(EQUAL_FLAG) | DA(OTHER_FLAG), OTHER_FLAG); 329 330 case SLJIT_SUB: 331 if ((flags & SRC2_IMM) && src2 == SIMM_MIN) { 332 FAIL_IF(push_inst(compiler, ADDIU | SA(0) | T(TMP_REG2) | IMM(src2), DR(TMP_REG2))); 333 src2 = TMP_REG2; 334 flags &= ~SRC2_IMM; 335 } 336 337 is_handled = 0; 338 339 if (flags & SRC2_IMM) { 340 if (GET_FLAG_TYPE(op) == SLJIT_LESS || GET_FLAG_TYPE(op) == SLJIT_GREATER_EQUAL) { 341 FAIL_IF(push_inst(compiler, SLTIU | S(src1) | TA(OTHER_FLAG) | IMM(src2), OTHER_FLAG)); 342 is_handled = 1; 343 } 344 else if (GET_FLAG_TYPE(op) == SLJIT_SIG_LESS || GET_FLAG_TYPE(op) == SLJIT_SIG_GREATER_EQUAL) { 345 FAIL_IF(push_inst(compiler, SLTI | S(src1) | TA(OTHER_FLAG) | IMM(src2), OTHER_FLAG)); 346 is_handled = 1; 347 } 348 } 349 350 if (!is_handled && GET_FLAG_TYPE(op) >= SLJIT_LESS && GET_FLAG_TYPE(op) <= SLJIT_SIG_LESS_EQUAL) { 351 is_handled = 1; 352 353 if (flags & SRC2_IMM) { 354 FAIL_IF(push_inst(compiler, ADDIU | SA(0) | T(TMP_REG2) | IMM(src2), DR(TMP_REG2))); 355 src2 = TMP_REG2; 356 flags &= ~SRC2_IMM; 357 } 358 359 if (GET_FLAG_TYPE(op) == SLJIT_LESS || GET_FLAG_TYPE(op) == SLJIT_GREATER_EQUAL) { 360 FAIL_IF(push_inst(compiler, SLTU | S(src1) | T(src2) | DA(OTHER_FLAG), OTHER_FLAG)); 361 } 362 else if (GET_FLAG_TYPE(op) == SLJIT_GREATER || GET_FLAG_TYPE(op) == SLJIT_LESS_EQUAL) 363 { 364 FAIL_IF(push_inst(compiler, SLTU | S(src2) | T(src1) | DA(OTHER_FLAG), OTHER_FLAG)); 365 } 366 else if (GET_FLAG_TYPE(op) == SLJIT_SIG_LESS || GET_FLAG_TYPE(op) == SLJIT_SIG_GREATER_EQUAL) { 367 FAIL_IF(push_inst(compiler, SLT | S(src1) | T(src2) | DA(OTHER_FLAG), OTHER_FLAG)); 368 } 369 else if (GET_FLAG_TYPE(op) == SLJIT_SIG_GREATER || GET_FLAG_TYPE(op) == SLJIT_SIG_LESS_EQUAL) 370 { 371 FAIL_IF(push_inst(compiler, SLT | S(src2) | T(src1) | DA(OTHER_FLAG), OTHER_FLAG)); 372 } 373 } 374 375 if (is_handled) { 376 if (flags & SRC2_IMM) { 377 if (op & SLJIT_SET_Z) 378 FAIL_IF(push_inst(compiler, SELECT_OP(DADDIU, ADDIU) | S(src1) | TA(EQUAL_FLAG) | IMM(-src2), EQUAL_FLAG)); 379 if (!(flags & UNUSED_DEST)) 380 return push_inst(compiler, SELECT_OP(DADDIU, ADDIU) | S(src1) | T(dst) | IMM(-src2), DR(dst)); 381 } 382 else { 383 if (op & SLJIT_SET_Z) 384 FAIL_IF(push_inst(compiler, SELECT_OP(DSUBU, SUBU) | S(src1) | T(src2) | DA(EQUAL_FLAG), EQUAL_FLAG)); 385 if (!(flags & UNUSED_DEST)) 386 return push_inst(compiler, SELECT_OP(DSUBU, SUBU) | S(src1) | T(src2) | D(dst), DR(dst)); 387 } 388 return SLJIT_SUCCESS; 389 } 390 391 is_overflow = GET_FLAG_TYPE(op) == SLJIT_OVERFLOW || GET_FLAG_TYPE(op) == SLJIT_NOT_OVERFLOW; 392 is_carry = GET_FLAG_TYPE(op) == GET_FLAG_TYPE(SLJIT_SET_CARRY); 393 394 if (flags & SRC2_IMM) { 395 if (is_overflow) { 396 if (src2 >= 0) 397 FAIL_IF(push_inst(compiler, OR | S(src1) | T(src1) | DA(EQUAL_FLAG), EQUAL_FLAG)); 398 else 399 FAIL_IF(push_inst(compiler, NOR | S(src1) | T(src1) | DA(EQUAL_FLAG), EQUAL_FLAG)); 400 } 401 else if (op & SLJIT_SET_Z) 402 FAIL_IF(push_inst(compiler, SELECT_OP(DADDIU, ADDIU) | S(src1) | TA(EQUAL_FLAG) | IMM(-src2), EQUAL_FLAG)); 403 404 if (is_overflow || is_carry) 405 FAIL_IF(push_inst(compiler, SLTIU | S(src1) | TA(OTHER_FLAG) | IMM(src2), OTHER_FLAG)); 406 /* dst may be the same as src1 or src2. */ 407 if (!(flags & UNUSED_DEST) || (op & VARIABLE_FLAG_MASK)) 408 FAIL_IF(push_inst(compiler, SELECT_OP(DADDIU, ADDIU) | S(src1) | T(dst) | IMM(-src2), DR(dst))); 409 } 410 else { 411 if (is_overflow) 412 FAIL_IF(push_inst(compiler, XOR | S(src1) | T(src2) | DA(EQUAL_FLAG), EQUAL_FLAG)); 413 else if (op & SLJIT_SET_Z) 414 FAIL_IF(push_inst(compiler, SELECT_OP(DSUBU, SUBU) | S(src1) | T(src2) | DA(EQUAL_FLAG), EQUAL_FLAG)); 415 416 if (is_overflow || is_carry) 417 FAIL_IF(push_inst(compiler, SLTU | S(src1) | T(src2) | DA(OTHER_FLAG), OTHER_FLAG)); 418 /* dst may be the same as src1 or src2. */ 419 if (!(flags & UNUSED_DEST) || (op & VARIABLE_FLAG_MASK)) 420 FAIL_IF(push_inst(compiler, SELECT_OP(DSUBU, SUBU) | S(src1) | T(src2) | D(dst), DR(dst))); 421 } 422 423 if (!is_overflow) 424 return SLJIT_SUCCESS; 425 FAIL_IF(push_inst(compiler, SELECT_OP(DSLL32, SLL) | TA(OTHER_FLAG) | D(TMP_REG1) | SH_IMM(31), DR(TMP_REG1))); 426 FAIL_IF(push_inst(compiler, XOR | S(TMP_REG1) | TA(EQUAL_FLAG) | DA(EQUAL_FLAG), EQUAL_FLAG)); 427 FAIL_IF(push_inst(compiler, XOR | S(dst) | TA(EQUAL_FLAG) | DA(OTHER_FLAG), OTHER_FLAG)); 428 if (op & SLJIT_SET_Z) 429 FAIL_IF(push_inst(compiler, SELECT_OP(DADDU, ADDU) | S(dst) | TA(0) | DA(EQUAL_FLAG), EQUAL_FLAG)); 430 return push_inst(compiler, SELECT_OP(DSRL32, SRL) | TA(OTHER_FLAG) | DA(OTHER_FLAG) | SH_IMM(31), OTHER_FLAG); 431 432 case SLJIT_SUBC: 433 if ((flags & SRC2_IMM) && src2 == SIMM_MIN) { 434 FAIL_IF(push_inst(compiler, ADDIU | SA(0) | T(TMP_REG2) | IMM(src2), DR(TMP_REG2))); 435 src2 = TMP_REG2; 436 flags &= ~SRC2_IMM; 437 } 438 439 is_carry = GET_FLAG_TYPE(op) == GET_FLAG_TYPE(SLJIT_SET_CARRY); 440 441 if (flags & SRC2_IMM) { 442 if (is_carry) 443 FAIL_IF(push_inst(compiler, SLTIU | S(src1) | TA(EQUAL_FLAG) | IMM(src2), EQUAL_FLAG)); 444 /* dst may be the same as src1 or src2. */ 445 FAIL_IF(push_inst(compiler, SELECT_OP(DADDIU, ADDIU) | S(src1) | T(dst) | IMM(-src2), DR(dst))); 446 } 447 else { 448 if (is_carry) 449 FAIL_IF(push_inst(compiler, SLTU | S(src1) | T(src2) | DA(EQUAL_FLAG), EQUAL_FLAG)); 450 /* dst may be the same as src1 or src2. */ 451 FAIL_IF(push_inst(compiler, SELECT_OP(DSUBU, SUBU) | S(src1) | T(src2) | D(dst), DR(dst))); 452 } 453 454 if (is_carry) 455 FAIL_IF(push_inst(compiler, SLTU | S(dst) | TA(OTHER_FLAG) | D(TMP_REG1), DR(TMP_REG1))); 456 457 FAIL_IF(push_inst(compiler, SELECT_OP(DSUBU, SUBU) | S(dst) | TA(OTHER_FLAG) | D(dst), DR(dst))); 458 return (is_carry) ? push_inst(compiler, OR | SA(EQUAL_FLAG) | T(TMP_REG1) | DA(OTHER_FLAG), OTHER_FLAG) : SLJIT_SUCCESS; 459 460 case SLJIT_MUL: 461 SLJIT_ASSERT(!(flags & SRC2_IMM)); 462 463 if (GET_FLAG_TYPE(op) != SLJIT_MUL_OVERFLOW && GET_FLAG_TYPE(op) != SLJIT_MUL_NOT_OVERFLOW) { 464 #if (defined SLJIT_MIPS_R1 && SLJIT_MIPS_R1) 465 if (op & SLJIT_I32_OP) 466 return push_inst(compiler, MUL | S(src1) | T(src2) | D(dst), DR(dst)); 467 FAIL_IF(push_inst(compiler, DMULT | S(src1) | T(src2), MOVABLE_INS)); 468 return push_inst(compiler, MFLO | D(dst), DR(dst)); 469 #else 470 FAIL_IF(push_inst(compiler, SELECT_OP(DMULT, MULT) | S(src1) | T(src2), MOVABLE_INS)); 471 return push_inst(compiler, MFLO | D(dst), DR(dst)); 472 #endif 473 } 474 FAIL_IF(push_inst(compiler, SELECT_OP(DMULT, MULT) | S(src1) | T(src2), MOVABLE_INS)); 475 FAIL_IF(push_inst(compiler, MFHI | DA(EQUAL_FLAG), EQUAL_FLAG)); 476 FAIL_IF(push_inst(compiler, MFLO | D(dst), DR(dst))); 477 FAIL_IF(push_inst(compiler, SELECT_OP(DSRA32, SRA) | T(dst) | DA(OTHER_FLAG) | SH_IMM(31), OTHER_FLAG)); 478 return push_inst(compiler, SELECT_OP(DSUBU, SUBU) | SA(EQUAL_FLAG) | TA(OTHER_FLAG) | DA(OTHER_FLAG), OTHER_FLAG); 479 480 case SLJIT_AND: 481 EMIT_LOGICAL(ANDI, AND); 482 return SLJIT_SUCCESS; 483 484 case SLJIT_OR: 485 EMIT_LOGICAL(ORI, OR); 486 return SLJIT_SUCCESS; 487 488 case SLJIT_XOR: 489 EMIT_LOGICAL(XORI, XOR); 490 return SLJIT_SUCCESS; 491 492 case SLJIT_SHL: 493 EMIT_SHIFT(DSLL, DSLL32, SLL, DSLLV, SLLV); 494 return SLJIT_SUCCESS; 495 496 case SLJIT_LSHR: 497 EMIT_SHIFT(DSRL, DSRL32, SRL, DSRLV, SRLV); 498 return SLJIT_SUCCESS; 499 500 case SLJIT_ASHR: 501 EMIT_SHIFT(DSRA, DSRA32, SRA, DSRAV, SRAV); 502 return SLJIT_SUCCESS; 503 } 504 505 SLJIT_UNREACHABLE(); 506 return SLJIT_SUCCESS; 507 } 508 509 static SLJIT_INLINE sljit_s32 emit_const(struct sljit_compiler *compiler, sljit_s32 dst, sljit_sw init_value) 510 { 511 FAIL_IF(push_inst(compiler, LUI | T(dst) | IMM(init_value >> 48), DR(dst))); 512 FAIL_IF(push_inst(compiler, ORI | S(dst) | T(dst) | IMM(init_value >> 32), DR(dst))); 513 FAIL_IF(push_inst(compiler, DSLL | T(dst) | D(dst) | SH_IMM(16), DR(dst))); 514 FAIL_IF(push_inst(compiler, ORI | S(dst) | T(dst) | IMM(init_value >> 16), DR(dst))); 515 FAIL_IF(push_inst(compiler, DSLL | T(dst) | D(dst) | SH_IMM(16), DR(dst))); 516 return push_inst(compiler, ORI | S(dst) | T(dst) | IMM(init_value), DR(dst)); 517 } 518 519 SLJIT_API_FUNC_ATTRIBUTE void sljit_set_jump_addr(sljit_uw addr, sljit_uw new_target, sljit_sw executable_offset) 520 { 521 sljit_ins *inst = (sljit_ins *)addr; 522 523 inst[0] = (inst[0] & 0xffff0000) | ((new_target >> 48) & 0xffff); 524 inst[1] = (inst[1] & 0xffff0000) | ((new_target >> 32) & 0xffff); 525 inst[3] = (inst[3] & 0xffff0000) | ((new_target >> 16) & 0xffff); 526 inst[5] = (inst[5] & 0xffff0000) | (new_target & 0xffff); 527 inst = (sljit_ins *)SLJIT_ADD_EXEC_OFFSET(inst, executable_offset); 528 SLJIT_CACHE_FLUSH(inst, inst + 6); 529 } 530 531 SLJIT_API_FUNC_ATTRIBUTE void sljit_set_const(sljit_uw addr, sljit_sw new_constant, sljit_sw executable_offset) 532 { 533 sljit_ins *inst = (sljit_ins *)addr; 534 535 inst[0] = (inst[0] & 0xffff0000) | ((new_constant >> 48) & 0xffff); 536 inst[1] = (inst[1] & 0xffff0000) | ((new_constant >> 32) & 0xffff); 537 inst[3] = (inst[3] & 0xffff0000) | ((new_constant >> 16) & 0xffff); 538 inst[5] = (inst[5] & 0xffff0000) | (new_constant & 0xffff); 539 inst = (sljit_ins *)SLJIT_ADD_EXEC_OFFSET(inst, executable_offset); 540 SLJIT_CACHE_FLUSH(inst, inst + 6); 541 } 542
Indexes created Mon Oct 27 02:09:54 GMT 2025