sljitNativeMIPS_32.c revision 1.1.1.2.4.4
1 /* $NetBSD: sljitNativeMIPS_32.c,v 1.1.1.2.4.4 2017/12/03 11:38:03 jdolecek Exp $ */ 2 3 /* 4 * Stack-less Just-In-Time compiler 5 * 6 * Copyright 2009-2012 Zoltan Herczeg (hzmester (at) freemail.hu). All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without modification, are 9 * permitted provided that the following conditions are met: 10 * 11 * 1. Redistributions of source code must retain the above copyright notice, this list of 12 * conditions and the following disclaimer. 13 * 14 * 2. Redistributions in binary form must reproduce the above copyright notice, this list 15 * of conditions and the following disclaimer in the documentation and/or other materials 16 * provided with the distribution. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) AND CONTRIBUTORS ``AS IS'' AND ANY 19 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 20 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT 21 * SHALL THE COPYRIGHT HOLDER(S) OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED 23 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR 24 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 25 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN 26 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 */ 28 29 /* mips 32-bit arch dependent functions. */ 30 31 static sljit_s32 load_immediate(struct sljit_compiler *compiler, sljit_s32 dst_ar, sljit_sw imm) 32 { 33 if (!(imm & ~0xffff)) 34 return push_inst(compiler, ORI | SA(0) | TA(dst_ar) | IMM(imm), dst_ar); 35 36 if (imm < 0 && imm >= SIMM_MIN) 37 return push_inst(compiler, ADDIU | SA(0) | TA(dst_ar) | IMM(imm), dst_ar); 38 39 FAIL_IF(push_inst(compiler, LUI | TA(dst_ar) | IMM(imm >> 16), dst_ar)); 40 return (imm & 0xffff) ? push_inst(compiler, ORI | SA(dst_ar) | TA(dst_ar) | IMM(imm), dst_ar) : SLJIT_SUCCESS; 41 } 42 43 #define EMIT_LOGICAL(op_imm, op_norm) \ 44 if (flags & SRC2_IMM) { \ 45 if (op & SLJIT_SET_E) \ 46 FAIL_IF(push_inst(compiler, op_imm | S(src1) | TA(EQUAL_FLAG) | IMM(src2), EQUAL_FLAG)); \ 47 if (CHECK_FLAGS(SLJIT_SET_E)) \ 48 FAIL_IF(push_inst(compiler, op_imm | S(src1) | T(dst) | IMM(src2), DR(dst))); \ 49 } \ 50 else { \ 51 if (op & SLJIT_SET_E) \ 52 FAIL_IF(push_inst(compiler, op_norm | S(src1) | T(src2) | DA(EQUAL_FLAG), EQUAL_FLAG)); \ 53 if (CHECK_FLAGS(SLJIT_SET_E)) \ 54 FAIL_IF(push_inst(compiler, op_norm | S(src1) | T(src2) | D(dst), DR(dst))); \ 55 } 56 57 #define EMIT_SHIFT(op_imm, op_v) \ 58 if (flags & SRC2_IMM) { \ 59 if (op & SLJIT_SET_E) \ 60 FAIL_IF(push_inst(compiler, op_imm | T(src1) | DA(EQUAL_FLAG) | SH_IMM(src2), EQUAL_FLAG)); \ 61 if (CHECK_FLAGS(SLJIT_SET_E)) \ 62 FAIL_IF(push_inst(compiler, op_imm | T(src1) | D(dst) | SH_IMM(src2), DR(dst))); \ 63 } \ 64 else { \ 65 if (op & SLJIT_SET_E) \ 66 FAIL_IF(push_inst(compiler, op_v | S(src2) | T(src1) | DA(EQUAL_FLAG), EQUAL_FLAG)); \ 67 if (CHECK_FLAGS(SLJIT_SET_E)) \ 68 FAIL_IF(push_inst(compiler, op_v | S(src2) | T(src1) | D(dst), DR(dst))); \ 69 } 70 71 static SLJIT_INLINE sljit_s32 emit_single_op(struct sljit_compiler *compiler, sljit_s32 op, sljit_s32 flags, 72 sljit_s32 dst, sljit_s32 src1, sljit_sw src2) 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 if (dst != src2) 99 SLJIT_ASSERT_STOP(); 100 return SLJIT_SUCCESS; 101 102 case SLJIT_MOV_U16: 103 case SLJIT_MOV_S16: 104 SLJIT_ASSERT(src1 == TMP_REG1 && !(flags & SRC2_IMM)); 105 if ((flags & (REG_DEST | REG2_SOURCE)) == (REG_DEST | REG2_SOURCE)) { 106 if (op == SLJIT_MOV_S16) { 107 #if (defined SLJIT_MIPS_R1 && SLJIT_MIPS_R1) 108 return push_inst(compiler, SEH | T(src2) | D(dst), DR(dst)); 109 #else 110 FAIL_IF(push_inst(compiler, SLL | T(src2) | D(dst) | SH_IMM(16), DR(dst))); 111 return push_inst(compiler, SRA | T(dst) | D(dst) | SH_IMM(16), DR(dst)); 112 #endif 113 } 114 return push_inst(compiler, ANDI | S(src2) | T(dst) | IMM(0xffff), DR(dst)); 115 } 116 else if (dst != src2) 117 SLJIT_ASSERT_STOP(); 118 return SLJIT_SUCCESS; 119 120 case SLJIT_NOT: 121 SLJIT_ASSERT(src1 == TMP_REG1 && !(flags & SRC2_IMM)); 122 if (op & SLJIT_SET_E) 123 FAIL_IF(push_inst(compiler, NOR | S(src2) | T(src2) | DA(EQUAL_FLAG), EQUAL_FLAG)); 124 if (CHECK_FLAGS(SLJIT_SET_E)) 125 FAIL_IF(push_inst(compiler, NOR | S(src2) | T(src2) | D(dst), DR(dst))); 126 return SLJIT_SUCCESS; 127 128 case SLJIT_CLZ: 129 SLJIT_ASSERT(src1 == TMP_REG1 && !(flags & SRC2_IMM)); 130 #if (defined SLJIT_MIPS_R1 && SLJIT_MIPS_R1) 131 if (op & SLJIT_SET_E) 132 FAIL_IF(push_inst(compiler, CLZ | S(src2) | TA(EQUAL_FLAG) | DA(EQUAL_FLAG), EQUAL_FLAG)); 133 if (CHECK_FLAGS(SLJIT_SET_E)) 134 FAIL_IF(push_inst(compiler, CLZ | S(src2) | T(dst) | D(dst), DR(dst))); 135 #else 136 if (SLJIT_UNLIKELY(flags & UNUSED_DEST)) { 137 FAIL_IF(push_inst(compiler, SRL | T(src2) | DA(EQUAL_FLAG) | SH_IMM(31), EQUAL_FLAG)); 138 return push_inst(compiler, XORI | SA(EQUAL_FLAG) | TA(EQUAL_FLAG) | IMM(1), EQUAL_FLAG); 139 } 140 /* Nearly all instructions are unmovable in the following sequence. */ 141 FAIL_IF(push_inst(compiler, ADDU | S(src2) | TA(0) | D(TMP_REG1), DR(TMP_REG1))); 142 /* Check zero. */ 143 FAIL_IF(push_inst(compiler, BEQ | S(TMP_REG1) | TA(0) | IMM(5), UNMOVABLE_INS)); 144 FAIL_IF(push_inst(compiler, ORI | SA(0) | T(dst) | IMM(32), UNMOVABLE_INS)); 145 FAIL_IF(push_inst(compiler, ADDIU | SA(0) | T(dst) | IMM(-1), DR(dst))); 146 /* Loop for searching the highest bit. */ 147 FAIL_IF(push_inst(compiler, ADDIU | S(dst) | T(dst) | IMM(1), DR(dst))); 148 FAIL_IF(push_inst(compiler, BGEZ | S(TMP_REG1) | IMM(-2), UNMOVABLE_INS)); 149 FAIL_IF(push_inst(compiler, SLL | T(TMP_REG1) | D(TMP_REG1) | SH_IMM(1), UNMOVABLE_INS)); 150 if (op & SLJIT_SET_E) 151 return push_inst(compiler, ADDU | S(dst) | TA(0) | DA(EQUAL_FLAG), EQUAL_FLAG); 152 #endif 153 return SLJIT_SUCCESS; 154 155 case SLJIT_ADD: 156 if (flags & SRC2_IMM) { 157 if (op & SLJIT_SET_O) { 158 if (src2 >= 0) 159 FAIL_IF(push_inst(compiler, OR | S(src1) | T(src1) | DA(OVERFLOW_FLAG), OVERFLOW_FLAG)); 160 else 161 FAIL_IF(push_inst(compiler, NOR | S(src1) | T(src1) | DA(OVERFLOW_FLAG), OVERFLOW_FLAG)); 162 } 163 if (op & SLJIT_SET_E) 164 FAIL_IF(push_inst(compiler, ADDIU | S(src1) | TA(EQUAL_FLAG) | IMM(src2), EQUAL_FLAG)); 165 if (op & (SLJIT_SET_C | SLJIT_SET_O)) { 166 if (src2 >= 0) 167 FAIL_IF(push_inst(compiler, ORI | S(src1) | TA(ULESS_FLAG) | IMM(src2), ULESS_FLAG)); 168 else { 169 FAIL_IF(push_inst(compiler, ADDIU | SA(0) | TA(ULESS_FLAG) | IMM(src2), ULESS_FLAG)); 170 FAIL_IF(push_inst(compiler, OR | S(src1) | TA(ULESS_FLAG) | DA(ULESS_FLAG), ULESS_FLAG)); 171 } 172 } 173 /* dst may be the same as src1 or src2. */ 174 if (CHECK_FLAGS(SLJIT_SET_E)) 175 FAIL_IF(push_inst(compiler, ADDIU | S(src1) | T(dst) | IMM(src2), DR(dst))); 176 } 177 else { 178 if (op & SLJIT_SET_O) 179 FAIL_IF(push_inst(compiler, XOR | S(src1) | T(src2) | DA(OVERFLOW_FLAG), OVERFLOW_FLAG)); 180 if (op & SLJIT_SET_E) 181 FAIL_IF(push_inst(compiler, ADDU | S(src1) | T(src2) | DA(EQUAL_FLAG), EQUAL_FLAG)); 182 if (op & (SLJIT_SET_C | SLJIT_SET_O)) 183 FAIL_IF(push_inst(compiler, OR | S(src1) | T(src2) | DA(ULESS_FLAG), ULESS_FLAG)); 184 /* dst may be the same as src1 or src2. */ 185 if (CHECK_FLAGS(SLJIT_SET_E)) 186 FAIL_IF(push_inst(compiler, ADDU | S(src1) | T(src2) | D(dst), DR(dst))); 187 } 188 189 /* a + b >= a | b (otherwise, the carry should be set to 1). */ 190 if (op & (SLJIT_SET_C | SLJIT_SET_O)) 191 FAIL_IF(push_inst(compiler, SLTU | S(dst) | TA(ULESS_FLAG) | DA(ULESS_FLAG), ULESS_FLAG)); 192 if (!(op & SLJIT_SET_O)) 193 return SLJIT_SUCCESS; 194 FAIL_IF(push_inst(compiler, SLL | TA(ULESS_FLAG) | D(TMP_REG1) | SH_IMM(31), DR(TMP_REG1))); 195 FAIL_IF(push_inst(compiler, XOR | S(TMP_REG1) | TA(OVERFLOW_FLAG) | DA(OVERFLOW_FLAG), OVERFLOW_FLAG)); 196 FAIL_IF(push_inst(compiler, XOR | S(dst) | TA(OVERFLOW_FLAG) | DA(OVERFLOW_FLAG), OVERFLOW_FLAG)); 197 return push_inst(compiler, SLL | TA(OVERFLOW_FLAG) | DA(OVERFLOW_FLAG) | SH_IMM(31), OVERFLOW_FLAG); 198 199 case SLJIT_ADDC: 200 if (flags & SRC2_IMM) { 201 if (op & SLJIT_SET_C) { 202 if (src2 >= 0) 203 FAIL_IF(push_inst(compiler, ORI | S(src1) | TA(OVERFLOW_FLAG) | IMM(src2), OVERFLOW_FLAG)); 204 else { 205 FAIL_IF(push_inst(compiler, ADDIU | SA(0) | TA(OVERFLOW_FLAG) | IMM(src2), OVERFLOW_FLAG)); 206 FAIL_IF(push_inst(compiler, OR | S(src1) | TA(OVERFLOW_FLAG) | DA(OVERFLOW_FLAG), OVERFLOW_FLAG)); 207 } 208 } 209 FAIL_IF(push_inst(compiler, ADDIU | S(src1) | T(dst) | IMM(src2), DR(dst))); 210 } else { 211 if (op & SLJIT_SET_C) 212 FAIL_IF(push_inst(compiler, OR | S(src1) | T(src2) | DA(OVERFLOW_FLAG), OVERFLOW_FLAG)); 213 /* dst may be the same as src1 or src2. */ 214 FAIL_IF(push_inst(compiler, ADDU | S(src1) | T(src2) | D(dst), DR(dst))); 215 } 216 if (op & SLJIT_SET_C) 217 FAIL_IF(push_inst(compiler, SLTU | S(dst) | TA(OVERFLOW_FLAG) | DA(OVERFLOW_FLAG), OVERFLOW_FLAG)); 218 219 FAIL_IF(push_inst(compiler, ADDU | S(dst) | TA(ULESS_FLAG) | D(dst), DR(dst))); 220 if (!(op & SLJIT_SET_C)) 221 return SLJIT_SUCCESS; 222 223 /* Set ULESS_FLAG (dst == 0) && (ULESS_FLAG == 1). */ 224 FAIL_IF(push_inst(compiler, SLTU | S(dst) | TA(ULESS_FLAG) | DA(ULESS_FLAG), ULESS_FLAG)); 225 /* Set carry flag. */ 226 return push_inst(compiler, OR | SA(ULESS_FLAG) | TA(OVERFLOW_FLAG) | DA(ULESS_FLAG), ULESS_FLAG); 227 228 case SLJIT_SUB: 229 if ((flags & SRC2_IMM) && ((op & (SLJIT_SET_U | SLJIT_SET_S)) || src2 == SIMM_MIN)) { 230 FAIL_IF(push_inst(compiler, ADDIU | SA(0) | T(TMP_REG2) | IMM(src2), DR(TMP_REG2))); 231 src2 = TMP_REG2; 232 flags &= ~SRC2_IMM; 233 } 234 235 if (flags & SRC2_IMM) { 236 if (op & SLJIT_SET_O) { 237 if (src2 >= 0) 238 FAIL_IF(push_inst(compiler, OR | S(src1) | T(src1) | DA(OVERFLOW_FLAG), OVERFLOW_FLAG)); 239 else 240 FAIL_IF(push_inst(compiler, NOR | S(src1) | T(src1) | DA(OVERFLOW_FLAG), OVERFLOW_FLAG)); 241 } 242 if (op & SLJIT_SET_E) 243 FAIL_IF(push_inst(compiler, ADDIU | S(src1) | TA(EQUAL_FLAG) | IMM(-src2), EQUAL_FLAG)); 244 if (op & (SLJIT_SET_C | SLJIT_SET_O)) 245 FAIL_IF(push_inst(compiler, SLTIU | S(src1) | TA(ULESS_FLAG) | IMM(src2), ULESS_FLAG)); 246 /* dst may be the same as src1 or src2. */ 247 if (CHECK_FLAGS(SLJIT_SET_E)) 248 FAIL_IF(push_inst(compiler, ADDIU | S(src1) | T(dst) | IMM(-src2), DR(dst))); 249 } 250 else { 251 if (op & SLJIT_SET_O) 252 FAIL_IF(push_inst(compiler, XOR | S(src1) | T(src2) | DA(OVERFLOW_FLAG), OVERFLOW_FLAG)); 253 if (op & SLJIT_SET_E) 254 FAIL_IF(push_inst(compiler, SUBU | S(src1) | T(src2) | DA(EQUAL_FLAG), EQUAL_FLAG)); 255 if (op & (SLJIT_SET_U | SLJIT_SET_C | SLJIT_SET_O)) 256 FAIL_IF(push_inst(compiler, SLTU | S(src1) | T(src2) | DA(ULESS_FLAG), ULESS_FLAG)); 257 if (op & SLJIT_SET_U) 258 FAIL_IF(push_inst(compiler, SLTU | S(src2) | T(src1) | DA(UGREATER_FLAG), UGREATER_FLAG)); 259 if (op & SLJIT_SET_S) { 260 FAIL_IF(push_inst(compiler, SLT | S(src1) | T(src2) | DA(LESS_FLAG), LESS_FLAG)); 261 FAIL_IF(push_inst(compiler, SLT | S(src2) | T(src1) | DA(GREATER_FLAG), GREATER_FLAG)); 262 } 263 /* dst may be the same as src1 or src2. */ 264 if (CHECK_FLAGS(SLJIT_SET_E | SLJIT_SET_U | SLJIT_SET_S | SLJIT_SET_C)) 265 FAIL_IF(push_inst(compiler, SUBU | S(src1) | T(src2) | D(dst), DR(dst))); 266 } 267 268 if (!(op & SLJIT_SET_O)) 269 return SLJIT_SUCCESS; 270 FAIL_IF(push_inst(compiler, SLL | TA(ULESS_FLAG) | D(TMP_REG1) | SH_IMM(31), DR(TMP_REG1))); 271 FAIL_IF(push_inst(compiler, XOR | S(TMP_REG1) | TA(OVERFLOW_FLAG) | DA(OVERFLOW_FLAG), OVERFLOW_FLAG)); 272 FAIL_IF(push_inst(compiler, XOR | S(dst) | TA(OVERFLOW_FLAG) | DA(OVERFLOW_FLAG), OVERFLOW_FLAG)); 273 return push_inst(compiler, SRL | TA(OVERFLOW_FLAG) | DA(OVERFLOW_FLAG) | SH_IMM(31), OVERFLOW_FLAG); 274 275 case SLJIT_SUBC: 276 if ((flags & SRC2_IMM) && src2 == SIMM_MIN) { 277 FAIL_IF(push_inst(compiler, ADDIU | SA(0) | T(TMP_REG2) | IMM(src2), DR(TMP_REG2))); 278 src2 = TMP_REG2; 279 flags &= ~SRC2_IMM; 280 } 281 282 if (flags & SRC2_IMM) { 283 if (op & SLJIT_SET_C) 284 FAIL_IF(push_inst(compiler, SLTIU | S(src1) | TA(OVERFLOW_FLAG) | IMM(src2), OVERFLOW_FLAG)); 285 /* dst may be the same as src1 or src2. */ 286 FAIL_IF(push_inst(compiler, ADDIU | S(src1) | T(dst) | IMM(-src2), DR(dst))); 287 } 288 else { 289 if (op & SLJIT_SET_C) 290 FAIL_IF(push_inst(compiler, SLTU | S(src1) | T(src2) | DA(OVERFLOW_FLAG), OVERFLOW_FLAG)); 291 /* dst may be the same as src1 or src2. */ 292 FAIL_IF(push_inst(compiler, SUBU | S(src1) | T(src2) | D(dst), DR(dst))); 293 } 294 295 if (op & SLJIT_SET_C) 296 FAIL_IF(push_inst(compiler, SLTU | S(dst) | TA(ULESS_FLAG) | DA(LESS_FLAG), LESS_FLAG)); 297 298 FAIL_IF(push_inst(compiler, SUBU | S(dst) | TA(ULESS_FLAG) | D(dst), DR(dst))); 299 return (op & SLJIT_SET_C) ? push_inst(compiler, OR | SA(OVERFLOW_FLAG) | TA(LESS_FLAG) | DA(ULESS_FLAG), ULESS_FLAG) : SLJIT_SUCCESS; 300 301 case SLJIT_MUL: 302 SLJIT_ASSERT(!(flags & SRC2_IMM)); 303 if (!(op & SLJIT_SET_O)) { 304 #if (defined SLJIT_MIPS_R1 && SLJIT_MIPS_R1) 305 return push_inst(compiler, MUL | S(src1) | T(src2) | D(dst), DR(dst)); 306 #else 307 FAIL_IF(push_inst(compiler, MULT | S(src1) | T(src2), MOVABLE_INS)); 308 return push_inst(compiler, MFLO | D(dst), DR(dst)); 309 #endif 310 } 311 FAIL_IF(push_inst(compiler, MULT | S(src1) | T(src2), MOVABLE_INS)); 312 FAIL_IF(push_inst(compiler, MFHI | DA(ULESS_FLAG), ULESS_FLAG)); 313 FAIL_IF(push_inst(compiler, MFLO | D(dst), DR(dst))); 314 FAIL_IF(push_inst(compiler, SRA | T(dst) | DA(UGREATER_FLAG) | SH_IMM(31), UGREATER_FLAG)); 315 return push_inst(compiler, SUBU | SA(ULESS_FLAG) | TA(UGREATER_FLAG) | DA(OVERFLOW_FLAG), OVERFLOW_FLAG); 316 317 case SLJIT_AND: 318 EMIT_LOGICAL(ANDI, AND); 319 return SLJIT_SUCCESS; 320 321 case SLJIT_OR: 322 EMIT_LOGICAL(ORI, OR); 323 return SLJIT_SUCCESS; 324 325 case SLJIT_XOR: 326 EMIT_LOGICAL(XORI, XOR); 327 return SLJIT_SUCCESS; 328 329 case SLJIT_SHL: 330 EMIT_SHIFT(SLL, SLLV); 331 return SLJIT_SUCCESS; 332 333 case SLJIT_LSHR: 334 EMIT_SHIFT(SRL, SRLV); 335 return SLJIT_SUCCESS; 336 337 case SLJIT_ASHR: 338 EMIT_SHIFT(SRA, SRAV); 339 return SLJIT_SUCCESS; 340 } 341 342 SLJIT_ASSERT_STOP(); 343 return SLJIT_SUCCESS; 344 } 345 346 static SLJIT_INLINE sljit_s32 emit_const(struct sljit_compiler *compiler, sljit_s32 dst, sljit_sw init_value) 347 { 348 FAIL_IF(push_inst(compiler, LUI | T(dst) | IMM(init_value >> 16), DR(dst))); 349 return push_inst(compiler, ORI | S(dst) | T(dst) | IMM(init_value), DR(dst)); 350 } 351 352 SLJIT_API_FUNC_ATTRIBUTE void sljit_set_jump_addr(sljit_uw addr, sljit_uw new_addr) 353 { 354 sljit_ins *inst = (sljit_ins*)addr; 355 356 inst[0] = (inst[0] & 0xffff0000) | ((new_addr >> 16) & 0xffff); 357 inst[1] = (inst[1] & 0xffff0000) | (new_addr & 0xffff); 358 SLJIT_CACHE_FLUSH(inst, inst + 2); 359 } 360 361 SLJIT_API_FUNC_ATTRIBUTE void sljit_set_const(sljit_uw addr, sljit_sw new_constant) 362 { 363 sljit_ins *inst = (sljit_ins*)addr; 364 365 inst[0] = (inst[0] & 0xffff0000) | ((new_constant >> 16) & 0xffff); 366 inst[1] = (inst[1] & 0xffff0000) | (new_constant & 0xffff); 367 SLJIT_CACHE_FLUSH(inst, inst + 2); 368 } 369
Indexes created Sun Oct 19 01:09:53 GMT 2025