sljitNativeMIPS_32.c revision 1.1.1.5
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 32-bit arch dependent functions. */ 28 29 static sljit_s32 load_immediate(struct sljit_compiler *compiler, sljit_s32 dst_ar, sljit_sw imm) 30 { 31 if (!(imm & ~0xffff)) 32 return push_inst(compiler, ORI | SA(0) | TA(dst_ar) | IMM(imm), dst_ar); 33 34 if (imm < 0 && imm >= SIMM_MIN) 35 return push_inst(compiler, ADDIU | SA(0) | TA(dst_ar) | IMM(imm), dst_ar); 36 37 FAIL_IF(push_inst(compiler, LUI | TA(dst_ar) | IMM(imm >> 16), dst_ar)); 38 return (imm & 0xffff) ? push_inst(compiler, ORI | SA(dst_ar) | TA(dst_ar) | IMM(imm), dst_ar) : SLJIT_SUCCESS; 39 } 40 41 #define EMIT_LOGICAL(op_imm, op_norm) \ 42 if (flags & SRC2_IMM) { \ 43 if (op & SLJIT_SET_Z) \ 44 FAIL_IF(push_inst(compiler, op_imm | S(src1) | TA(EQUAL_FLAG) | IMM(src2), EQUAL_FLAG)); \ 45 if (!(flags & UNUSED_DEST)) \ 46 FAIL_IF(push_inst(compiler, op_imm | S(src1) | T(dst) | IMM(src2), DR(dst))); \ 47 } \ 48 else { \ 49 if (op & SLJIT_SET_Z) \ 50 FAIL_IF(push_inst(compiler, op_norm | S(src1) | T(src2) | DA(EQUAL_FLAG), EQUAL_FLAG)); \ 51 if (!(flags & UNUSED_DEST)) \ 52 FAIL_IF(push_inst(compiler, op_norm | S(src1) | T(src2) | D(dst), DR(dst))); \ 53 } 54 55 #define EMIT_SHIFT(op_imm, op_v) \ 56 if (flags & SRC2_IMM) { \ 57 if (op & SLJIT_SET_Z) \ 58 FAIL_IF(push_inst(compiler, op_imm | T(src1) | DA(EQUAL_FLAG) | SH_IMM(src2), EQUAL_FLAG)); \ 59 if (!(flags & UNUSED_DEST)) \ 60 FAIL_IF(push_inst(compiler, op_imm | T(src1) | D(dst) | SH_IMM(src2), DR(dst))); \ 61 } \ 62 else { \ 63 if (op & SLJIT_SET_Z) \ 64 FAIL_IF(push_inst(compiler, op_v | S(src2) | T(src1) | DA(EQUAL_FLAG), EQUAL_FLAG)); \ 65 if (!(flags & UNUSED_DEST)) \ 66 FAIL_IF(push_inst(compiler, op_v | S(src2) | T(src1) | D(dst), DR(dst))); \ 67 } 68 69 static SLJIT_INLINE sljit_s32 emit_single_op(struct sljit_compiler *compiler, sljit_s32 op, sljit_s32 flags, 70 sljit_s32 dst, sljit_s32 src1, sljit_sw src2) 71 { 72 sljit_s32 is_overflow, is_carry, is_handled; 73 74 switch (GET_OPCODE(op)) { 75 case SLJIT_MOV: 76 case SLJIT_MOV_U32: 77 case SLJIT_MOV_S32: 78 case SLJIT_MOV_P: 79 SLJIT_ASSERT(src1 == TMP_REG1 && !(flags & SRC2_IMM)); 80 if (dst != src2) 81 return push_inst(compiler, ADDU | S(src2) | TA(0) | D(dst), DR(dst)); 82 return SLJIT_SUCCESS; 83 84 case SLJIT_MOV_U8: 85 case SLJIT_MOV_S8: 86 SLJIT_ASSERT(src1 == TMP_REG1 && !(flags & SRC2_IMM)); 87 if ((flags & (REG_DEST | REG2_SOURCE)) == (REG_DEST | REG2_SOURCE)) { 88 if (op == SLJIT_MOV_S8) { 89 #if (defined SLJIT_MIPS_R1 && SLJIT_MIPS_R1) 90 return push_inst(compiler, SEB | T(src2) | D(dst), DR(dst)); 91 #else 92 FAIL_IF(push_inst(compiler, SLL | T(src2) | D(dst) | SH_IMM(24), DR(dst))); 93 return push_inst(compiler, SRA | T(dst) | D(dst) | SH_IMM(24), DR(dst)); 94 #endif 95 } 96 return push_inst(compiler, ANDI | S(src2) | T(dst) | IMM(0xff), DR(dst)); 97 } 98 else { 99 SLJIT_ASSERT(dst == src2); 100 } 101 return SLJIT_SUCCESS; 102 103 case SLJIT_MOV_U16: 104 case SLJIT_MOV_S16: 105 SLJIT_ASSERT(src1 == TMP_REG1 && !(flags & SRC2_IMM)); 106 if ((flags & (REG_DEST | REG2_SOURCE)) == (REG_DEST | REG2_SOURCE)) { 107 if (op == SLJIT_MOV_S16) { 108 #if (defined SLJIT_MIPS_R1 && SLJIT_MIPS_R1) 109 return push_inst(compiler, SEH | T(src2) | D(dst), DR(dst)); 110 #else 111 FAIL_IF(push_inst(compiler, SLL | T(src2) | D(dst) | SH_IMM(16), DR(dst))); 112 return push_inst(compiler, SRA | T(dst) | D(dst) | SH_IMM(16), DR(dst)); 113 #endif 114 } 115 return push_inst(compiler, ANDI | S(src2) | T(dst) | IMM(0xffff), DR(dst)); 116 } 117 else { 118 SLJIT_ASSERT(dst == src2); 119 } 120 return SLJIT_SUCCESS; 121 122 case SLJIT_NOT: 123 SLJIT_ASSERT(src1 == TMP_REG1 && !(flags & SRC2_IMM)); 124 if (op & SLJIT_SET_Z) 125 FAIL_IF(push_inst(compiler, NOR | S(src2) | T(src2) | DA(EQUAL_FLAG), EQUAL_FLAG)); 126 if (!(flags & UNUSED_DEST)) 127 FAIL_IF(push_inst(compiler, NOR | S(src2) | T(src2) | D(dst), DR(dst))); 128 return SLJIT_SUCCESS; 129 130 case SLJIT_CLZ: 131 SLJIT_ASSERT(src1 == TMP_REG1 && !(flags & SRC2_IMM)); 132 #if (defined SLJIT_MIPS_R1 && SLJIT_MIPS_R1) 133 if (op & SLJIT_SET_Z) 134 FAIL_IF(push_inst(compiler, CLZ | S(src2) | TA(EQUAL_FLAG) | DA(EQUAL_FLAG), EQUAL_FLAG)); 135 if (!(flags & UNUSED_DEST)) 136 FAIL_IF(push_inst(compiler, CLZ | S(src2) | T(dst) | D(dst), DR(dst))); 137 #else 138 if (SLJIT_UNLIKELY(flags & UNUSED_DEST)) { 139 FAIL_IF(push_inst(compiler, SRL | T(src2) | DA(EQUAL_FLAG) | SH_IMM(31), EQUAL_FLAG)); 140 return push_inst(compiler, XORI | SA(EQUAL_FLAG) | TA(EQUAL_FLAG) | IMM(1), EQUAL_FLAG); 141 } 142 /* Nearly all instructions are unmovable in the following sequence. */ 143 FAIL_IF(push_inst(compiler, ADDU | S(src2) | TA(0) | D(TMP_REG1), DR(TMP_REG1))); 144 /* Check zero. */ 145 FAIL_IF(push_inst(compiler, BEQ | S(TMP_REG1) | TA(0) | IMM(5), UNMOVABLE_INS)); 146 FAIL_IF(push_inst(compiler, ORI | SA(0) | T(dst) | IMM(32), UNMOVABLE_INS)); 147 FAIL_IF(push_inst(compiler, ADDIU | SA(0) | T(dst) | IMM(-1), DR(dst))); 148 /* Loop for searching the highest bit. */ 149 FAIL_IF(push_inst(compiler, ADDIU | S(dst) | T(dst) | IMM(1), DR(dst))); 150 FAIL_IF(push_inst(compiler, BGEZ | S(TMP_REG1) | IMM(-2), UNMOVABLE_INS)); 151 FAIL_IF(push_inst(compiler, SLL | T(TMP_REG1) | D(TMP_REG1) | SH_IMM(1), UNMOVABLE_INS)); 152 if (op & SLJIT_SET_Z) 153 return push_inst(compiler, ADDU | S(dst) | TA(0) | DA(EQUAL_FLAG), EQUAL_FLAG); 154 #endif 155 return SLJIT_SUCCESS; 156 157 case SLJIT_ADD: 158 is_overflow = GET_FLAG_TYPE(op) == SLJIT_OVERFLOW || GET_FLAG_TYPE(op) == SLJIT_NOT_OVERFLOW; 159 is_carry = GET_FLAG_TYPE(op) == GET_FLAG_TYPE(SLJIT_SET_CARRY); 160 161 if (flags & SRC2_IMM) { 162 if (is_overflow) { 163 if (src2 >= 0) 164 FAIL_IF(push_inst(compiler, OR | S(src1) | T(src1) | DA(EQUAL_FLAG), EQUAL_FLAG)); 165 else 166 FAIL_IF(push_inst(compiler, NOR | S(src1) | T(src1) | DA(EQUAL_FLAG), EQUAL_FLAG)); 167 } 168 else if (op & SLJIT_SET_Z) 169 FAIL_IF(push_inst(compiler, ADDIU | S(src1) | TA(EQUAL_FLAG) | IMM(src2), EQUAL_FLAG)); 170 171 if (is_overflow || is_carry) { 172 if (src2 >= 0) 173 FAIL_IF(push_inst(compiler, ORI | S(src1) | TA(OTHER_FLAG) | IMM(src2), OTHER_FLAG)); 174 else { 175 FAIL_IF(push_inst(compiler, ADDIU | SA(0) | TA(OTHER_FLAG) | IMM(src2), OTHER_FLAG)); 176 FAIL_IF(push_inst(compiler, OR | S(src1) | TA(OTHER_FLAG) | DA(OTHER_FLAG), OTHER_FLAG)); 177 } 178 } 179 /* dst may be the same as src1 or src2. */ 180 if (!(flags & UNUSED_DEST) || (op & VARIABLE_FLAG_MASK)) 181 FAIL_IF(push_inst(compiler, ADDIU | S(src1) | T(dst) | IMM(src2), DR(dst))); 182 } 183 else { 184 if (is_overflow) 185 FAIL_IF(push_inst(compiler, XOR | S(src1) | T(src2) | DA(EQUAL_FLAG), EQUAL_FLAG)); 186 else if (op & SLJIT_SET_Z) 187 FAIL_IF(push_inst(compiler, ADDU | S(src1) | T(src2) | DA(EQUAL_FLAG), EQUAL_FLAG)); 188 189 if (is_overflow || is_carry) 190 FAIL_IF(push_inst(compiler, OR | S(src1) | T(src2) | DA(OTHER_FLAG), OTHER_FLAG)); 191 /* dst may be the same as src1 or src2. */ 192 if (!(flags & UNUSED_DEST) || (op & VARIABLE_FLAG_MASK)) 193 FAIL_IF(push_inst(compiler, ADDU | S(src1) | T(src2) | D(dst), DR(dst))); 194 } 195 196 /* a + b >= a | b (otherwise, the carry should be set to 1). */ 197 if (is_overflow || is_carry) 198 FAIL_IF(push_inst(compiler, SLTU | S(dst) | TA(OTHER_FLAG) | DA(OTHER_FLAG), OTHER_FLAG)); 199 if (!is_overflow) 200 return SLJIT_SUCCESS; 201 FAIL_IF(push_inst(compiler, SLL | TA(OTHER_FLAG) | D(TMP_REG1) | SH_IMM(31), DR(TMP_REG1))); 202 FAIL_IF(push_inst(compiler, XOR | S(TMP_REG1) | TA(EQUAL_FLAG) | DA(EQUAL_FLAG), EQUAL_FLAG)); 203 FAIL_IF(push_inst(compiler, XOR | S(dst) | TA(EQUAL_FLAG) | DA(OTHER_FLAG), OTHER_FLAG)); 204 if (op & SLJIT_SET_Z) 205 FAIL_IF(push_inst(compiler, ADDU | S(dst) | TA(0) | DA(EQUAL_FLAG), EQUAL_FLAG)); 206 return push_inst(compiler, SRL | TA(OTHER_FLAG) | DA(OTHER_FLAG) | SH_IMM(31), OTHER_FLAG); 207 208 case SLJIT_ADDC: 209 is_carry = GET_FLAG_TYPE(op) == GET_FLAG_TYPE(SLJIT_SET_CARRY); 210 211 if (flags & SRC2_IMM) { 212 if (is_carry) { 213 if (src2 >= 0) 214 FAIL_IF(push_inst(compiler, ORI | S(src1) | TA(EQUAL_FLAG) | IMM(src2), EQUAL_FLAG)); 215 else { 216 FAIL_IF(push_inst(compiler, ADDIU | SA(0) | TA(EQUAL_FLAG) | IMM(src2), EQUAL_FLAG)); 217 FAIL_IF(push_inst(compiler, OR | S(src1) | TA(EQUAL_FLAG) | DA(EQUAL_FLAG), EQUAL_FLAG)); 218 } 219 } 220 FAIL_IF(push_inst(compiler, ADDIU | S(src1) | T(dst) | IMM(src2), DR(dst))); 221 } else { 222 if (is_carry) 223 FAIL_IF(push_inst(compiler, OR | S(src1) | T(src2) | DA(EQUAL_FLAG), EQUAL_FLAG)); 224 /* dst may be the same as src1 or src2. */ 225 FAIL_IF(push_inst(compiler, ADDU | S(src1) | T(src2) | D(dst), DR(dst))); 226 } 227 if (is_carry) 228 FAIL_IF(push_inst(compiler, SLTU | S(dst) | TA(EQUAL_FLAG) | DA(EQUAL_FLAG), EQUAL_FLAG)); 229 230 FAIL_IF(push_inst(compiler, ADDU | S(dst) | TA(OTHER_FLAG) | D(dst), DR(dst))); 231 if (!is_carry) 232 return SLJIT_SUCCESS; 233 234 /* Set ULESS_FLAG (dst == 0) && (OTHER_FLAG == 1). */ 235 FAIL_IF(push_inst(compiler, SLTU | S(dst) | TA(OTHER_FLAG) | DA(OTHER_FLAG), OTHER_FLAG)); 236 /* Set carry flag. */ 237 return push_inst(compiler, OR | SA(OTHER_FLAG) | TA(EQUAL_FLAG) | DA(OTHER_FLAG), OTHER_FLAG); 238 239 case SLJIT_SUB: 240 if ((flags & SRC2_IMM) && src2 == SIMM_MIN) { 241 FAIL_IF(push_inst(compiler, ADDIU | SA(0) | T(TMP_REG2) | IMM(src2), DR(TMP_REG2))); 242 src2 = TMP_REG2; 243 flags &= ~SRC2_IMM; 244 } 245 246 is_handled = 0; 247 248 if (flags & SRC2_IMM) { 249 if (GET_FLAG_TYPE(op) == SLJIT_LESS || GET_FLAG_TYPE(op) == SLJIT_GREATER_EQUAL) { 250 FAIL_IF(push_inst(compiler, SLTIU | S(src1) | TA(OTHER_FLAG) | IMM(src2), OTHER_FLAG)); 251 is_handled = 1; 252 } 253 else if (GET_FLAG_TYPE(op) == SLJIT_SIG_LESS || GET_FLAG_TYPE(op) == SLJIT_SIG_GREATER_EQUAL) { 254 FAIL_IF(push_inst(compiler, SLTI | S(src1) | TA(OTHER_FLAG) | IMM(src2), OTHER_FLAG)); 255 is_handled = 1; 256 } 257 } 258 259 if (!is_handled && GET_FLAG_TYPE(op) >= SLJIT_LESS && GET_FLAG_TYPE(op) <= SLJIT_SIG_LESS_EQUAL) { 260 is_handled = 1; 261 262 if (flags & SRC2_IMM) { 263 FAIL_IF(push_inst(compiler, ADDIU | SA(0) | T(TMP_REG2) | IMM(src2), DR(TMP_REG2))); 264 src2 = TMP_REG2; 265 flags &= ~SRC2_IMM; 266 } 267 268 if (GET_FLAG_TYPE(op) == SLJIT_LESS || GET_FLAG_TYPE(op) == SLJIT_GREATER_EQUAL) { 269 FAIL_IF(push_inst(compiler, SLTU | S(src1) | T(src2) | DA(OTHER_FLAG), OTHER_FLAG)); 270 } 271 else if (GET_FLAG_TYPE(op) == SLJIT_GREATER || GET_FLAG_TYPE(op) == SLJIT_LESS_EQUAL) 272 { 273 FAIL_IF(push_inst(compiler, SLTU | S(src2) | T(src1) | DA(OTHER_FLAG), OTHER_FLAG)); 274 } 275 else if (GET_FLAG_TYPE(op) == SLJIT_SIG_LESS || GET_FLAG_TYPE(op) == SLJIT_SIG_GREATER_EQUAL) { 276 FAIL_IF(push_inst(compiler, SLT | S(src1) | T(src2) | DA(OTHER_FLAG), OTHER_FLAG)); 277 } 278 else if (GET_FLAG_TYPE(op) == SLJIT_SIG_GREATER || GET_FLAG_TYPE(op) == SLJIT_SIG_LESS_EQUAL) 279 { 280 FAIL_IF(push_inst(compiler, SLT | S(src2) | T(src1) | DA(OTHER_FLAG), OTHER_FLAG)); 281 } 282 } 283 284 if (is_handled) { 285 if (flags & SRC2_IMM) { 286 if (op & SLJIT_SET_Z) 287 FAIL_IF(push_inst(compiler, ADDIU | S(src1) | TA(EQUAL_FLAG) | IMM(-src2), EQUAL_FLAG)); 288 if (!(flags & UNUSED_DEST)) 289 return push_inst(compiler, ADDIU | S(src1) | T(dst) | IMM(-src2), DR(dst)); 290 } 291 else { 292 if (op & SLJIT_SET_Z) 293 FAIL_IF(push_inst(compiler, SUBU | S(src1) | T(src2) | DA(EQUAL_FLAG), EQUAL_FLAG)); 294 if (!(flags & UNUSED_DEST)) 295 return push_inst(compiler, SUBU | S(src1) | T(src2) | D(dst), DR(dst)); 296 } 297 return SLJIT_SUCCESS; 298 } 299 300 is_overflow = GET_FLAG_TYPE(op) == SLJIT_OVERFLOW || GET_FLAG_TYPE(op) == SLJIT_NOT_OVERFLOW; 301 is_carry = GET_FLAG_TYPE(op) == GET_FLAG_TYPE(SLJIT_SET_CARRY); 302 303 if (flags & SRC2_IMM) { 304 if (is_overflow) { 305 if (src2 >= 0) 306 FAIL_IF(push_inst(compiler, OR | S(src1) | T(src1) | DA(EQUAL_FLAG), EQUAL_FLAG)); 307 else 308 FAIL_IF(push_inst(compiler, NOR | S(src1) | T(src1) | DA(EQUAL_FLAG), EQUAL_FLAG)); 309 } 310 else if (op & SLJIT_SET_Z) 311 FAIL_IF(push_inst(compiler, ADDIU | S(src1) | TA(EQUAL_FLAG) | IMM(-src2), EQUAL_FLAG)); 312 313 if (is_overflow || is_carry) 314 FAIL_IF(push_inst(compiler, SLTIU | S(src1) | TA(OTHER_FLAG) | IMM(src2), OTHER_FLAG)); 315 /* dst may be the same as src1 or src2. */ 316 if (!(flags & UNUSED_DEST) || (op & VARIABLE_FLAG_MASK)) 317 FAIL_IF(push_inst(compiler, ADDIU | S(src1) | T(dst) | IMM(-src2), DR(dst))); 318 } 319 else { 320 if (is_overflow) 321 FAIL_IF(push_inst(compiler, XOR | S(src1) | T(src2) | DA(EQUAL_FLAG), EQUAL_FLAG)); 322 else if (op & SLJIT_SET_Z) 323 FAIL_IF(push_inst(compiler, SUBU | S(src1) | T(src2) | DA(EQUAL_FLAG), EQUAL_FLAG)); 324 325 if (is_overflow || is_carry) 326 FAIL_IF(push_inst(compiler, SLTU | S(src1) | T(src2) | DA(OTHER_FLAG), OTHER_FLAG)); 327 /* dst may be the same as src1 or src2. */ 328 if (!(flags & UNUSED_DEST) || (op & VARIABLE_FLAG_MASK)) 329 FAIL_IF(push_inst(compiler, SUBU | S(src1) | T(src2) | D(dst), DR(dst))); 330 } 331 332 if (!is_overflow) 333 return SLJIT_SUCCESS; 334 FAIL_IF(push_inst(compiler, SLL | TA(OTHER_FLAG) | D(TMP_REG1) | SH_IMM(31), DR(TMP_REG1))); 335 FAIL_IF(push_inst(compiler, XOR | S(TMP_REG1) | TA(EQUAL_FLAG) | DA(EQUAL_FLAG), EQUAL_FLAG)); 336 FAIL_IF(push_inst(compiler, XOR | S(dst) | TA(EQUAL_FLAG) | DA(OTHER_FLAG), OTHER_FLAG)); 337 if (op & SLJIT_SET_Z) 338 FAIL_IF(push_inst(compiler, ADDU | S(dst) | TA(0) | DA(EQUAL_FLAG), EQUAL_FLAG)); 339 return push_inst(compiler, SRL | TA(OTHER_FLAG) | DA(OTHER_FLAG) | SH_IMM(31), OTHER_FLAG); 340 341 case SLJIT_SUBC: 342 if ((flags & SRC2_IMM) && src2 == SIMM_MIN) { 343 FAIL_IF(push_inst(compiler, ADDIU | SA(0) | T(TMP_REG2) | IMM(src2), DR(TMP_REG2))); 344 src2 = TMP_REG2; 345 flags &= ~SRC2_IMM; 346 } 347 348 is_carry = GET_FLAG_TYPE(op) == GET_FLAG_TYPE(SLJIT_SET_CARRY); 349 350 if (flags & SRC2_IMM) { 351 if (is_carry) 352 FAIL_IF(push_inst(compiler, SLTIU | S(src1) | TA(EQUAL_FLAG) | IMM(src2), EQUAL_FLAG)); 353 /* dst may be the same as src1 or src2. */ 354 FAIL_IF(push_inst(compiler, ADDIU | S(src1) | T(dst) | IMM(-src2), DR(dst))); 355 } 356 else { 357 if (is_carry) 358 FAIL_IF(push_inst(compiler, SLTU | S(src1) | T(src2) | DA(EQUAL_FLAG), EQUAL_FLAG)); 359 /* dst may be the same as src1 or src2. */ 360 FAIL_IF(push_inst(compiler, SUBU | S(src1) | T(src2) | D(dst), DR(dst))); 361 } 362 363 if (is_carry) 364 FAIL_IF(push_inst(compiler, SLTU | S(dst) | TA(OTHER_FLAG) | D(TMP_REG1), DR(TMP_REG1))); 365 366 FAIL_IF(push_inst(compiler, SUBU | S(dst) | TA(OTHER_FLAG) | D(dst), DR(dst))); 367 return (is_carry) ? push_inst(compiler, OR | SA(EQUAL_FLAG) | T(TMP_REG1) | DA(OTHER_FLAG), OTHER_FLAG) : SLJIT_SUCCESS; 368 369 case SLJIT_MUL: 370 SLJIT_ASSERT(!(flags & SRC2_IMM)); 371 372 if (GET_FLAG_TYPE(op) != SLJIT_MUL_OVERFLOW && GET_FLAG_TYPE(op) != SLJIT_MUL_NOT_OVERFLOW) { 373 #if (defined SLJIT_MIPS_R1 && SLJIT_MIPS_R1) 374 return push_inst(compiler, MUL | S(src1) | T(src2) | D(dst), DR(dst)); 375 #else 376 FAIL_IF(push_inst(compiler, MULT | S(src1) | T(src2), MOVABLE_INS)); 377 return push_inst(compiler, MFLO | D(dst), DR(dst)); 378 #endif 379 } 380 FAIL_IF(push_inst(compiler, MULT | S(src1) | T(src2), MOVABLE_INS)); 381 FAIL_IF(push_inst(compiler, MFHI | DA(EQUAL_FLAG), EQUAL_FLAG)); 382 FAIL_IF(push_inst(compiler, MFLO | D(dst), DR(dst))); 383 FAIL_IF(push_inst(compiler, SRA | T(dst) | DA(OTHER_FLAG) | SH_IMM(31), OTHER_FLAG)); 384 return push_inst(compiler, SUBU | SA(EQUAL_FLAG) | TA(OTHER_FLAG) | DA(OTHER_FLAG), OTHER_FLAG); 385 386 case SLJIT_AND: 387 EMIT_LOGICAL(ANDI, AND); 388 return SLJIT_SUCCESS; 389 390 case SLJIT_OR: 391 EMIT_LOGICAL(ORI, OR); 392 return SLJIT_SUCCESS; 393 394 case SLJIT_XOR: 395 EMIT_LOGICAL(XORI, XOR); 396 return SLJIT_SUCCESS; 397 398 case SLJIT_SHL: 399 EMIT_SHIFT(SLL, SLLV); 400 return SLJIT_SUCCESS; 401 402 case SLJIT_LSHR: 403 EMIT_SHIFT(SRL, SRLV); 404 return SLJIT_SUCCESS; 405 406 case SLJIT_ASHR: 407 EMIT_SHIFT(SRA, SRAV); 408 return SLJIT_SUCCESS; 409 } 410 411 SLJIT_UNREACHABLE(); 412 return SLJIT_SUCCESS; 413 } 414 415 static SLJIT_INLINE sljit_s32 emit_const(struct sljit_compiler *compiler, sljit_s32 dst, sljit_sw init_value) 416 { 417 FAIL_IF(push_inst(compiler, LUI | T(dst) | IMM(init_value >> 16), DR(dst))); 418 return push_inst(compiler, ORI | S(dst) | T(dst) | IMM(init_value), DR(dst)); 419 } 420 421 SLJIT_API_FUNC_ATTRIBUTE void sljit_set_jump_addr(sljit_uw addr, sljit_uw new_target, sljit_sw executable_offset) 422 { 423 sljit_ins *inst = (sljit_ins *)addr; 424 425 inst[0] = (inst[0] & 0xffff0000) | ((new_target >> 16) & 0xffff); 426 inst[1] = (inst[1] & 0xffff0000) | (new_target & 0xffff); 427 inst = (sljit_ins *)SLJIT_ADD_EXEC_OFFSET(inst, executable_offset); 428 SLJIT_CACHE_FLUSH(inst, inst + 2); 429 } 430 431 SLJIT_API_FUNC_ATTRIBUTE void sljit_set_const(sljit_uw addr, sljit_sw new_constant, sljit_sw executable_offset) 432 { 433 sljit_ins *inst = (sljit_ins *)addr; 434 435 inst[0] = (inst[0] & 0xffff0000) | ((new_constant >> 16) & 0xffff); 436 inst[1] = (inst[1] & 0xffff0000) | (new_constant & 0xffff); 437 inst = (sljit_ins *)SLJIT_ADD_EXEC_OFFSET(inst, executable_offset); 438 SLJIT_CACHE_FLUSH(inst, inst + 2); 439 } 440
Indexes created Sun Oct 19 18:09:56 GMT 2025