Annotation of win32/pcre/sljit/sljitNativeARM_v5.c, revision 1.1
1.1 ! misha 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()
! 28: {
! 29: #if (defined SLJIT_CONFIG_ARM_V7 && SLJIT_CONFIG_ARM_V7)
! 30: return "ARMv7" SLJIT_CPUINFO;
! 31: #elif (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5)
! 32: return "ARMv5" SLJIT_CPUINFO;
! 33: #else
! 34: #error "Internal error: Unknown ARM architecture"
! 35: #endif
! 36: }
! 37:
! 38: /* Last register + 1. */
! 39: #define TMP_REG1 (SLJIT_NO_REGISTERS + 1)
! 40: #define TMP_REG2 (SLJIT_NO_REGISTERS + 2)
! 41: #define TMP_REG3 (SLJIT_NO_REGISTERS + 3)
! 42: #define TMP_PC (SLJIT_NO_REGISTERS + 4)
! 43:
! 44: #define TMP_FREG1 (SLJIT_FLOAT_REG4 + 1)
! 45: #define TMP_FREG2 (SLJIT_FLOAT_REG4 + 2)
! 46:
! 47: /* In ARM instruction words.
! 48: Cache lines are usually 32 byte aligned. */
! 49: #define CONST_POOL_ALIGNMENT 8
! 50: #define CONST_POOL_EMPTY 0xffffffff
! 51:
! 52: #define ALIGN_INSTRUCTION(ptr) \
! 53: (sljit_uw*)(((sljit_uw)(ptr) + (CONST_POOL_ALIGNMENT * sizeof(sljit_uw)) - 1) & ~((CONST_POOL_ALIGNMENT * sizeof(sljit_uw)) - 1))
! 54: #define MAX_DIFFERENCE(max_diff) \
! 55: (((max_diff) / (int)sizeof(sljit_uw)) - (CONST_POOL_ALIGNMENT - 1))
! 56:
! 57: /* See sljit_emit_enter and sljit_emit_op0 if you want to change them. */
! 58: static SLJIT_CONST sljit_ub reg_map[SLJIT_NO_REGISTERS + 5] = {
! 59: 0, 0, 1, 2, 10, 11, 4, 5, 6, 7, 8, 13, 3, 12, 14, 15
! 60: };
! 61:
! 62: #define RM(rm) (reg_map[rm])
! 63: #define RD(rd) (reg_map[rd] << 12)
! 64: #define RN(rn) (reg_map[rn] << 16)
! 65:
! 66: /* --------------------------------------------------------------------- */
! 67: /* Instrucion forms */
! 68: /* --------------------------------------------------------------------- */
! 69:
! 70: /* The instruction includes the AL condition.
! 71: INST_NAME - CONDITIONAL remove this flag. */
! 72: #define COND_MASK 0xf0000000
! 73: #define CONDITIONAL 0xe0000000
! 74: #define PUSH_POOL 0xff000000
! 75:
! 76: /* DP - Data Processing instruction (use with EMIT_DATA_PROCESS_INS). */
! 77: #define ADC_DP 0x5
! 78: #define ADD_DP 0x4
! 79: #define AND_DP 0x0
! 80: #define B 0xea000000
! 81: #define BIC_DP 0xe
! 82: #define BL 0xeb000000
! 83: #define BLX 0xe12fff30
! 84: #define BX 0xe12fff10
! 85: #define CLZ 0xe16f0f10
! 86: #define CMP_DP 0xa
! 87: #define BKPT 0xe1200070
! 88: #define EOR_DP 0x1
! 89: #define MOV_DP 0xd
! 90: #define MUL 0xe0000090
! 91: #define MVN_DP 0xf
! 92: #define NOP 0xe1a00000
! 93: #define ORR_DP 0xc
! 94: #define PUSH 0xe92d0000
! 95: #define POP 0xe8bd0000
! 96: #define RSB_DP 0x3
! 97: #define RSC_DP 0x7
! 98: #define SBC_DP 0x6
! 99: #define SMULL 0xe0c00090
! 100: #define SUB_DP 0x2
! 101: #define UMULL 0xe0800090
! 102: #define VABS_F64 0xeeb00bc0
! 103: #define VADD_F64 0xee300b00
! 104: #define VCMP_F64 0xeeb40b40
! 105: #define VDIV_F64 0xee800b00
! 106: #define VMOV_F64 0xeeb00b40
! 107: #define VMRS 0xeef1fa10
! 108: #define VMUL_F64 0xee200b00
! 109: #define VNEG_F64 0xeeb10b40
! 110: #define VSTR 0xed000b00
! 111: #define VSUB_F64 0xee300b40
! 112:
! 113: #if (defined SLJIT_CONFIG_ARM_V7 && SLJIT_CONFIG_ARM_V7)
! 114: /* Arm v7 specific instructions. */
! 115: #define MOVW 0xe3000000
! 116: #define MOVT 0xe3400000
! 117: #define SXTB 0xe6af0070
! 118: #define SXTH 0xe6bf0070
! 119: #define UXTB 0xe6ef0070
! 120: #define UXTH 0xe6ff0070
! 121: #endif
! 122:
! 123: #if (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5)
! 124:
! 125: static int push_cpool(struct sljit_compiler *compiler)
! 126: {
! 127: /* Pushing the constant pool into the instruction stream. */
! 128: sljit_uw* inst;
! 129: sljit_uw* cpool_ptr;
! 130: sljit_uw* cpool_end;
! 131: int i;
! 132:
! 133: /* The label could point the address after the constant pool. */
! 134: if (compiler->last_label && compiler->last_label->size == compiler->size)
! 135: compiler->last_label->size += compiler->cpool_fill + (CONST_POOL_ALIGNMENT - 1) + 1;
! 136:
! 137: SLJIT_ASSERT(compiler->cpool_fill > 0 && compiler->cpool_fill <= CPOOL_SIZE);
! 138: inst = (sljit_uw*)ensure_buf(compiler, sizeof(sljit_uw));
! 139: FAIL_IF(!inst);
! 140: compiler->size++;
! 141: *inst = 0xff000000 | compiler->cpool_fill;
! 142:
! 143: for (i = 0; i < CONST_POOL_ALIGNMENT - 1; i++) {
! 144: inst = (sljit_uw*)ensure_buf(compiler, sizeof(sljit_uw));
! 145: FAIL_IF(!inst);
! 146: compiler->size++;
! 147: *inst = 0;
! 148: }
! 149:
! 150: cpool_ptr = compiler->cpool;
! 151: cpool_end = cpool_ptr + compiler->cpool_fill;
! 152: while (cpool_ptr < cpool_end) {
! 153: inst = (sljit_uw*)ensure_buf(compiler, sizeof(sljit_uw));
! 154: FAIL_IF(!inst);
! 155: compiler->size++;
! 156: *inst = *cpool_ptr++;
! 157: }
! 158: compiler->cpool_diff = CONST_POOL_EMPTY;
! 159: compiler->cpool_fill = 0;
! 160: return SLJIT_SUCCESS;
! 161: }
! 162:
! 163: static int push_inst(struct sljit_compiler *compiler, sljit_uw inst)
! 164: {
! 165: sljit_uw* ptr;
! 166:
! 167: if (SLJIT_UNLIKELY(compiler->cpool_diff != CONST_POOL_EMPTY && compiler->size - compiler->cpool_diff >= MAX_DIFFERENCE(4092)))
! 168: FAIL_IF(push_cpool(compiler));
! 169:
! 170: ptr = (sljit_uw*)ensure_buf(compiler, sizeof(sljit_uw));
! 171: FAIL_IF(!ptr);
! 172: compiler->size++;
! 173: *ptr = inst;
! 174: return SLJIT_SUCCESS;
! 175: }
! 176:
! 177: static int push_inst_with_literal(struct sljit_compiler *compiler, sljit_uw inst, sljit_uw literal)
! 178: {
! 179: sljit_uw* ptr;
! 180: sljit_uw cpool_index = CPOOL_SIZE;
! 181: sljit_uw* cpool_ptr;
! 182: sljit_uw* cpool_end;
! 183: sljit_ub* cpool_unique_ptr;
! 184:
! 185: if (SLJIT_UNLIKELY(compiler->cpool_diff != CONST_POOL_EMPTY && compiler->size - compiler->cpool_diff >= MAX_DIFFERENCE(4092)))
! 186: FAIL_IF(push_cpool(compiler));
! 187: else if (compiler->cpool_fill > 0) {
! 188: cpool_ptr = compiler->cpool;
! 189: cpool_end = cpool_ptr + compiler->cpool_fill;
! 190: cpool_unique_ptr = compiler->cpool_unique;
! 191: do {
! 192: if ((*cpool_ptr == literal) && !(*cpool_unique_ptr)) {
! 193: cpool_index = cpool_ptr - compiler->cpool;
! 194: break;
! 195: }
! 196: cpool_ptr++;
! 197: cpool_unique_ptr++;
! 198: } while (cpool_ptr < cpool_end);
! 199: }
! 200:
! 201: if (cpool_index == CPOOL_SIZE) {
! 202: /* Must allocate a new entry in the literal pool. */
! 203: if (compiler->cpool_fill < CPOOL_SIZE) {
! 204: cpool_index = compiler->cpool_fill;
! 205: compiler->cpool_fill++;
! 206: }
! 207: else {
! 208: FAIL_IF(push_cpool(compiler));
! 209: cpool_index = 0;
! 210: compiler->cpool_fill = 1;
! 211: }
! 212: }
! 213:
! 214: SLJIT_ASSERT((inst & 0xfff) == 0);
! 215: ptr = (sljit_uw*)ensure_buf(compiler, sizeof(sljit_uw));
! 216: FAIL_IF(!ptr);
! 217: compiler->size++;
! 218: *ptr = inst | cpool_index;
! 219:
! 220: compiler->cpool[cpool_index] = literal;
! 221: compiler->cpool_unique[cpool_index] = 0;
! 222: if (compiler->cpool_diff == CONST_POOL_EMPTY)
! 223: compiler->cpool_diff = compiler->size;
! 224: return SLJIT_SUCCESS;
! 225: }
! 226:
! 227: static int push_inst_with_unique_literal(struct sljit_compiler *compiler, sljit_uw inst, sljit_uw literal)
! 228: {
! 229: sljit_uw* ptr;
! 230: if (SLJIT_UNLIKELY((compiler->cpool_diff != CONST_POOL_EMPTY && compiler->size - compiler->cpool_diff >= MAX_DIFFERENCE(4092)) || compiler->cpool_fill >= CPOOL_SIZE))
! 231: FAIL_IF(push_cpool(compiler));
! 232:
! 233: SLJIT_ASSERT(compiler->cpool_fill < CPOOL_SIZE && (inst & 0xfff) == 0);
! 234: ptr = (sljit_uw*)ensure_buf(compiler, sizeof(sljit_uw));
! 235: FAIL_IF(!ptr);
! 236: compiler->size++;
! 237: *ptr = inst | compiler->cpool_fill;
! 238:
! 239: compiler->cpool[compiler->cpool_fill] = literal;
! 240: compiler->cpool_unique[compiler->cpool_fill] = 1;
! 241: compiler->cpool_fill++;
! 242: if (compiler->cpool_diff == CONST_POOL_EMPTY)
! 243: compiler->cpool_diff = compiler->size;
! 244: return SLJIT_SUCCESS;
! 245: }
! 246:
! 247: static SLJIT_INLINE int prepare_blx(struct sljit_compiler *compiler)
! 248: {
! 249: /* Place for at least two instruction (doesn't matter whether the first has a literal). */
! 250: if (SLJIT_UNLIKELY(compiler->cpool_diff != CONST_POOL_EMPTY && compiler->size - compiler->cpool_diff >= MAX_DIFFERENCE(4088)))
! 251: return push_cpool(compiler);
! 252: return SLJIT_SUCCESS;
! 253: }
! 254:
! 255: static SLJIT_INLINE int emit_blx(struct sljit_compiler *compiler)
! 256: {
! 257: /* Must follow tightly the previous instruction (to be able to convert it to bl instruction). */
! 258: SLJIT_ASSERT(compiler->cpool_diff == CONST_POOL_EMPTY || compiler->size - compiler->cpool_diff < MAX_DIFFERENCE(4092));
! 259: return push_inst(compiler, BLX | RM(TMP_REG1));
! 260: }
! 261:
! 262: static sljit_uw patch_pc_relative_loads(sljit_uw *last_pc_patch, sljit_uw *code_ptr, sljit_uw* const_pool, sljit_uw cpool_size)
! 263: {
! 264: sljit_uw diff;
! 265: sljit_uw ind;
! 266: sljit_uw counter = 0;
! 267: sljit_uw* clear_const_pool = const_pool;
! 268: sljit_uw* clear_const_pool_end = const_pool + cpool_size;
! 269:
! 270: SLJIT_ASSERT(const_pool - code_ptr <= CONST_POOL_ALIGNMENT);
! 271: /* Set unused flag for all literals in the constant pool.
! 272: I.e.: unused literals can belong to branches, which can be encoded as B or BL.
! 273: We can "compress" the constant pool by discarding these literals. */
! 274: while (clear_const_pool < clear_const_pool_end)
! 275: *clear_const_pool++ = (sljit_uw)(-1);
! 276:
! 277: while (last_pc_patch < code_ptr) {
! 278: /* Data transfer instruction with Rn == r15. */
! 279: if ((*last_pc_patch & 0x0c0f0000) == 0x040f0000) {
! 280: diff = const_pool - last_pc_patch;
! 281: ind = (*last_pc_patch) & 0xfff;
! 282:
! 283: /* Must be a load instruction with immediate offset. */
! 284: SLJIT_ASSERT(ind < cpool_size && !(*last_pc_patch & (1 << 25)) && (*last_pc_patch & (1 << 20)));
! 285: if ((int)const_pool[ind] < 0) {
! 286: const_pool[ind] = counter;
! 287: ind = counter;
! 288: counter++;
! 289: }
! 290: else
! 291: ind = const_pool[ind];
! 292:
! 293: SLJIT_ASSERT(diff >= 1);
! 294: if (diff >= 2 || ind > 0) {
! 295: diff = (diff + ind - 2) << 2;
! 296: SLJIT_ASSERT(diff <= 0xfff);
! 297: *last_pc_patch = (*last_pc_patch & ~0xfff) | diff;
! 298: }
! 299: else
! 300: *last_pc_patch = (*last_pc_patch & ~(0xfff | (1 << 23))) | 0x004;
! 301: }
! 302: last_pc_patch++;
! 303: }
! 304: return counter;
! 305: }
! 306:
! 307: /* In some rare ocasions we may need future patches. The probability is close to 0 in practice. */
! 308: struct future_patch {
! 309: struct future_patch* next;
! 310: int index;
! 311: int value;
! 312: };
! 313:
! 314: static SLJIT_INLINE int resolve_const_pool_index(struct future_patch **first_patch, sljit_uw cpool_current_index, sljit_uw *cpool_start_address, sljit_uw *buf_ptr)
! 315: {
! 316: int value;
! 317: struct future_patch *curr_patch, *prev_patch;
! 318:
! 319: /* Using the values generated by patch_pc_relative_loads. */
! 320: if (!*first_patch)
! 321: value = (int)cpool_start_address[cpool_current_index];
! 322: else {
! 323: curr_patch = *first_patch;
! 324: prev_patch = 0;
! 325: while (1) {
! 326: if (!curr_patch) {
! 327: value = (int)cpool_start_address[cpool_current_index];
! 328: break;
! 329: }
! 330: if ((sljit_uw)curr_patch->index == cpool_current_index) {
! 331: value = curr_patch->value;
! 332: if (prev_patch)
! 333: prev_patch->next = curr_patch->next;
! 334: else
! 335: *first_patch = curr_patch->next;
! 336: SLJIT_FREE(curr_patch);
! 337: break;
! 338: }
! 339: prev_patch = curr_patch;
! 340: curr_patch = curr_patch->next;
! 341: }
! 342: }
! 343:
! 344: if (value >= 0) {
! 345: if ((sljit_uw)value > cpool_current_index) {
! 346: curr_patch = (struct future_patch*)SLJIT_MALLOC(sizeof(struct future_patch));
! 347: if (!curr_patch) {
! 348: while (*first_patch) {
! 349: curr_patch = *first_patch;
! 350: *first_patch = (*first_patch)->next;
! 351: SLJIT_FREE(curr_patch);
! 352: }
! 353: return SLJIT_ERR_ALLOC_FAILED;
! 354: }
! 355: curr_patch->next = *first_patch;
! 356: curr_patch->index = value;
! 357: curr_patch->value = cpool_start_address[value];
! 358: *first_patch = curr_patch;
! 359: }
! 360: cpool_start_address[value] = *buf_ptr;
! 361: }
! 362: return SLJIT_SUCCESS;
! 363: }
! 364:
! 365: #else
! 366:
! 367: static int push_inst(struct sljit_compiler *compiler, sljit_uw inst)
! 368: {
! 369: sljit_uw* ptr;
! 370:
! 371: ptr = (sljit_uw*)ensure_buf(compiler, sizeof(sljit_uw));
! 372: FAIL_IF(!ptr);
! 373: compiler->size++;
! 374: *ptr = inst;
! 375: return SLJIT_SUCCESS;
! 376: }
! 377:
! 378: static SLJIT_INLINE int emit_imm(struct sljit_compiler *compiler, int reg, sljit_w imm)
! 379: {
! 380: FAIL_IF(push_inst(compiler, MOVW | RD(reg) | ((imm << 4) & 0xf0000) | (imm & 0xfff)));
! 381: return push_inst(compiler, MOVT | RD(reg) | ((imm >> 12) & 0xf0000) | ((imm >> 16) & 0xfff));
! 382: }
! 383:
! 384: #endif
! 385:
! 386: static SLJIT_INLINE int detect_jump_type(struct sljit_jump *jump, sljit_uw *code_ptr, sljit_uw *code)
! 387: {
! 388: sljit_w diff;
! 389:
! 390: if (jump->flags & SLJIT_REWRITABLE_JUMP)
! 391: return 0;
! 392:
! 393: #if (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5)
! 394: if (jump->flags & IS_BL)
! 395: code_ptr--;
! 396:
! 397: if (jump->flags & JUMP_ADDR)
! 398: diff = ((sljit_w)jump->u.target - (sljit_w)(code_ptr + 2));
! 399: else {
! 400: SLJIT_ASSERT(jump->flags & JUMP_LABEL);
! 401: diff = ((sljit_w)(code + jump->u.label->size) - (sljit_w)(code_ptr + 2));
! 402: }
! 403:
! 404: /* Branch to Thumb code has not been optimized yet. */
! 405: if (diff & 0x3)
! 406: return 0;
! 407:
! 408: diff >>= 2;
! 409: if (jump->flags & IS_BL) {
! 410: if (diff <= 0x01ffffff && diff >= -0x02000000) {
! 411: *code_ptr = (BL - CONDITIONAL) | (*(code_ptr + 1) & COND_MASK);
! 412: jump->flags |= PATCH_B;
! 413: return 1;
! 414: }
! 415: }
! 416: else {
! 417: if (diff <= 0x01ffffff && diff >= -0x02000000) {
! 418: *code_ptr = (B - CONDITIONAL) | (*code_ptr & COND_MASK);
! 419: jump->flags |= PATCH_B;
! 420: }
! 421: }
! 422: #else
! 423: if (jump->flags & JUMP_ADDR)
! 424: diff = ((sljit_w)jump->u.target - (sljit_w)code_ptr);
! 425: else {
! 426: SLJIT_ASSERT(jump->flags & JUMP_LABEL);
! 427: diff = ((sljit_w)(code + jump->u.label->size) - (sljit_w)code_ptr);
! 428: }
! 429:
! 430: /* Branch to Thumb code has not been optimized yet. */
! 431: if (diff & 0x3)
! 432: return 0;
! 433:
! 434: diff >>= 2;
! 435: if (diff <= 0x01ffffff && diff >= -0x02000000) {
! 436: code_ptr -= 2;
! 437: *code_ptr = ((jump->flags & IS_BL) ? (BL - CONDITIONAL) : (B - CONDITIONAL)) | (code_ptr[2] & COND_MASK);
! 438: jump->flags |= PATCH_B;
! 439: return 1;
! 440: }
! 441: #endif
! 442: return 0;
! 443: }
! 444:
! 445: static SLJIT_INLINE void inline_set_jump_addr(sljit_uw addr, sljit_uw new_addr, int flush)
! 446: {
! 447: #if (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5)
! 448: sljit_uw *ptr = (sljit_uw*)addr;
! 449: sljit_uw *inst = (sljit_uw*)ptr[0];
! 450: sljit_uw mov_pc = ptr[1];
! 451: int bl = (mov_pc & 0x0000f000) != RD(TMP_PC);
! 452: sljit_w diff = (sljit_w)(((sljit_w)new_addr - (sljit_w)(inst + 2)) >> 2);
! 453:
! 454: if (diff <= 0x7fffff && diff >= -0x800000) {
! 455: /* Turn to branch. */
! 456: if (!bl) {
! 457: inst[0] = (mov_pc & COND_MASK) | (B - CONDITIONAL) | (diff & 0xffffff);
! 458: if (flush) {
! 459: SLJIT_CACHE_FLUSH(inst, inst + 1);
! 460: }
! 461: } else {
! 462: inst[0] = (mov_pc & COND_MASK) | (BL - CONDITIONAL) | (diff & 0xffffff);
! 463: inst[1] = NOP;
! 464: if (flush) {
! 465: SLJIT_CACHE_FLUSH(inst, inst + 2);
! 466: }
! 467: }
! 468: } else {
! 469: /* Get the position of the constant. */
! 470: if (mov_pc & (1 << 23))
! 471: ptr = inst + ((mov_pc & 0xfff) >> 2) + 2;
! 472: else
! 473: ptr = inst + 1;
! 474:
! 475: if (*inst != mov_pc) {
! 476: inst[0] = mov_pc;
! 477: if (!bl) {
! 478: if (flush) {
! 479: SLJIT_CACHE_FLUSH(inst, inst + 1);
! 480: }
! 481: } else {
! 482: inst[1] = BLX | RM(TMP_REG1);
! 483: if (flush) {
! 484: SLJIT_CACHE_FLUSH(inst, inst + 2);
! 485: }
! 486: }
! 487: }
! 488: *ptr = new_addr;
! 489: }
! 490: #else
! 491: sljit_uw *inst = (sljit_uw*)addr;
! 492: SLJIT_ASSERT((inst[0] & 0xfff00000) == MOVW && (inst[1] & 0xfff00000) == MOVT);
! 493: inst[0] = MOVW | (inst[0] & 0xf000) | ((new_addr << 4) & 0xf0000) | (new_addr & 0xfff);
! 494: inst[1] = MOVT | (inst[1] & 0xf000) | ((new_addr >> 12) & 0xf0000) | ((new_addr >> 16) & 0xfff);
! 495: if (flush) {
! 496: SLJIT_CACHE_FLUSH(inst, inst + 2);
! 497: }
! 498: #endif
! 499: }
! 500:
! 501: static sljit_uw get_immediate(sljit_uw imm);
! 502:
! 503: static SLJIT_INLINE void inline_set_const(sljit_uw addr, sljit_w new_constant, int flush)
! 504: {
! 505: #if (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5)
! 506: sljit_uw *ptr = (sljit_uw*)addr;
! 507: sljit_uw *inst = (sljit_uw*)ptr[0];
! 508: sljit_uw ldr_literal = ptr[1];
! 509: sljit_uw src2;
! 510:
! 511: src2 = get_immediate(new_constant);
! 512: if (src2) {
! 513: *inst = 0xe3a00000 | (ldr_literal & 0xf000) | src2;
! 514: if (flush) {
! 515: SLJIT_CACHE_FLUSH(inst, inst + 1);
! 516: }
! 517: return;
! 518: }
! 519:
! 520: src2 = get_immediate(~new_constant);
! 521: if (src2) {
! 522: *inst = 0xe3e00000 | (ldr_literal & 0xf000) | src2;
! 523: if (flush) {
! 524: SLJIT_CACHE_FLUSH(inst, inst + 1);
! 525: }
! 526: return;
! 527: }
! 528:
! 529: if (ldr_literal & (1 << 23))
! 530: ptr = inst + ((ldr_literal & 0xfff) >> 2) + 2;
! 531: else
! 532: ptr = inst + 1;
! 533:
! 534: if (*inst != ldr_literal) {
! 535: *inst = ldr_literal;
! 536: if (flush) {
! 537: SLJIT_CACHE_FLUSH(inst, inst + 1);
! 538: }
! 539: }
! 540: *ptr = new_constant;
! 541: #else
! 542: sljit_uw *inst = (sljit_uw*)addr;
! 543: SLJIT_ASSERT((inst[0] & 0xfff00000) == MOVW && (inst[1] & 0xfff00000) == MOVT);
! 544: inst[0] = MOVW | (inst[0] & 0xf000) | ((new_constant << 4) & 0xf0000) | (new_constant & 0xfff);
! 545: inst[1] = MOVT | (inst[1] & 0xf000) | ((new_constant >> 12) & 0xf0000) | ((new_constant >> 16) & 0xfff);
! 546: if (flush) {
! 547: SLJIT_CACHE_FLUSH(inst, inst + 2);
! 548: }
! 549: #endif
! 550: }
! 551:
! 552: SLJIT_API_FUNC_ATTRIBUTE void* sljit_generate_code(struct sljit_compiler *compiler)
! 553: {
! 554: struct sljit_memory_fragment *buf;
! 555: sljit_uw *code;
! 556: sljit_uw *code_ptr;
! 557: sljit_uw *buf_ptr;
! 558: sljit_uw *buf_end;
! 559: sljit_uw size;
! 560: sljit_uw word_count;
! 561: #if (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5)
! 562: sljit_uw cpool_size;
! 563: sljit_uw cpool_skip_alignment;
! 564: sljit_uw cpool_current_index;
! 565: sljit_uw *cpool_start_address;
! 566: sljit_uw *last_pc_patch;
! 567: struct future_patch *first_patch;
! 568: #endif
! 569:
! 570: struct sljit_label *label;
! 571: struct sljit_jump *jump;
! 572: struct sljit_const *const_;
! 573:
! 574: CHECK_ERROR_PTR();
! 575: check_sljit_generate_code(compiler);
! 576: reverse_buf(compiler);
! 577:
! 578: /* Second code generation pass. */
! 579: #if (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5)
! 580: size = compiler->size + (compiler->patches << 1);
! 581: if (compiler->cpool_fill > 0)
! 582: size += compiler->cpool_fill + CONST_POOL_ALIGNMENT - 1;
! 583: #else
! 584: size = compiler->size;
! 585: #endif
! 586: code = (sljit_uw*)SLJIT_MALLOC_EXEC(size * sizeof(sljit_uw));
! 587: PTR_FAIL_WITH_EXEC_IF(code);
! 588: buf = compiler->buf;
! 589:
! 590: #if (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5)
! 591: cpool_size = 0;
! 592: cpool_skip_alignment = 0;
! 593: cpool_current_index = 0;
! 594: cpool_start_address = NULL;
! 595: first_patch = NULL;
! 596: last_pc_patch = code;
! 597: #endif
! 598:
! 599: code_ptr = code;
! 600: word_count = 0;
! 601:
! 602: label = compiler->labels;
! 603: jump = compiler->jumps;
! 604: const_ = compiler->consts;
! 605:
! 606: if (label && label->size == 0) {
! 607: label->addr = (sljit_uw)code;
! 608: label->size = 0;
! 609: label = label->next;
! 610: }
! 611:
! 612: do {
! 613: buf_ptr = (sljit_uw*)buf->memory;
! 614: buf_end = buf_ptr + (buf->used_size >> 2);
! 615: do {
! 616: word_count++;
! 617: #if (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5)
! 618: if (cpool_size > 0) {
! 619: if (cpool_skip_alignment > 0) {
! 620: buf_ptr++;
! 621: cpool_skip_alignment--;
! 622: }
! 623: else {
! 624: if (SLJIT_UNLIKELY(resolve_const_pool_index(&first_patch, cpool_current_index, cpool_start_address, buf_ptr))) {
! 625: SLJIT_FREE_EXEC(code);
! 626: compiler->error = SLJIT_ERR_ALLOC_FAILED;
! 627: return NULL;
! 628: }
! 629: buf_ptr++;
! 630: if (++cpool_current_index >= cpool_size) {
! 631: SLJIT_ASSERT(!first_patch);
! 632: cpool_size = 0;
! 633: if (label && label->size == word_count) {
! 634: /* Points after the current instruction. */
! 635: label->addr = (sljit_uw)code_ptr;
! 636: label->size = code_ptr - code;
! 637: label = label->next;
! 638: }
! 639: }
! 640: }
! 641: }
! 642: else if ((*buf_ptr & 0xff000000) != PUSH_POOL) {
! 643: #endif
! 644: *code_ptr = *buf_ptr++;
! 645: /* These structures are ordered by their address. */
! 646: SLJIT_ASSERT(!label || label->size >= word_count);
! 647: SLJIT_ASSERT(!jump || jump->addr >= word_count);
! 648: SLJIT_ASSERT(!const_ || const_->addr >= word_count);
! 649: if (jump && jump->addr == word_count) {
! 650: #if (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5)
! 651: if (detect_jump_type(jump, code_ptr, code))
! 652: code_ptr--;
! 653: jump->addr = (sljit_uw)code_ptr;
! 654: #else
! 655: jump->addr = (sljit_uw)(code_ptr - 2);
! 656: if (detect_jump_type(jump, code_ptr, code))
! 657: code_ptr -= 2;
! 658: #endif
! 659: jump = jump->next;
! 660: }
! 661: if (label && label->size == word_count) {
! 662: /* code_ptr can be affected above. */
! 663: label->addr = (sljit_uw)(code_ptr + 1);
! 664: label->size = (code_ptr + 1) - code;
! 665: label = label->next;
! 666: }
! 667: if (const_ && const_->addr == word_count) {
! 668: #if (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5)
! 669: const_->addr = (sljit_uw)code_ptr;
! 670: #else
! 671: const_->addr = (sljit_uw)(code_ptr - 1);
! 672: #endif
! 673: const_ = const_->next;
! 674: }
! 675: code_ptr++;
! 676: #if (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5)
! 677: }
! 678: else {
! 679: /* Fortunately, no need to shift. */
! 680: cpool_size = *buf_ptr++ & ~PUSH_POOL;
! 681: SLJIT_ASSERT(cpool_size > 0);
! 682: cpool_start_address = ALIGN_INSTRUCTION(code_ptr + 1);
! 683: cpool_current_index = patch_pc_relative_loads(last_pc_patch, code_ptr, cpool_start_address, cpool_size);
! 684: if (cpool_current_index > 0) {
! 685: /* Unconditional branch. */
! 686: *code_ptr = B | (((cpool_start_address - code_ptr) + cpool_current_index - 2) & ~PUSH_POOL);
! 687: code_ptr = cpool_start_address + cpool_current_index;
! 688: }
! 689: cpool_skip_alignment = CONST_POOL_ALIGNMENT - 1;
! 690: cpool_current_index = 0;
! 691: last_pc_patch = code_ptr;
! 692: }
! 693: #endif
! 694: } while (buf_ptr < buf_end);
! 695: buf = buf->next;
! 696: } while (buf);
! 697:
! 698: SLJIT_ASSERT(!label);
! 699: SLJIT_ASSERT(!jump);
! 700: SLJIT_ASSERT(!const_);
! 701:
! 702: #if (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5)
! 703: SLJIT_ASSERT(cpool_size == 0);
! 704: if (compiler->cpool_fill > 0) {
! 705: cpool_start_address = ALIGN_INSTRUCTION(code_ptr);
! 706: cpool_current_index = patch_pc_relative_loads(last_pc_patch, code_ptr, cpool_start_address, compiler->cpool_fill);
! 707: if (cpool_current_index > 0)
! 708: code_ptr = cpool_start_address + cpool_current_index;
! 709:
! 710: buf_ptr = compiler->cpool;
! 711: buf_end = buf_ptr + compiler->cpool_fill;
! 712: cpool_current_index = 0;
! 713: while (buf_ptr < buf_end) {
! 714: if (SLJIT_UNLIKELY(resolve_const_pool_index(&first_patch, cpool_current_index, cpool_start_address, buf_ptr))) {
! 715: SLJIT_FREE_EXEC(code);
! 716: compiler->error = SLJIT_ERR_ALLOC_FAILED;
! 717: return NULL;
! 718: }
! 719: buf_ptr++;
! 720: cpool_current_index++;
! 721: }
! 722: SLJIT_ASSERT(!first_patch);
! 723: }
! 724: #endif
! 725:
! 726: jump = compiler->jumps;
! 727: while (jump) {
! 728: buf_ptr = (sljit_uw*)jump->addr;
! 729:
! 730: if (jump->flags & PATCH_B) {
! 731: if (!(jump->flags & JUMP_ADDR)) {
! 732: SLJIT_ASSERT(jump->flags & JUMP_LABEL);
! 733: SLJIT_ASSERT(((sljit_w)jump->u.label->addr - (sljit_w)(buf_ptr + 2)) <= 0x01ffffff && ((sljit_w)jump->u.label->addr - (sljit_w)(buf_ptr + 2)) >= -0x02000000);
! 734: *buf_ptr |= (((sljit_w)jump->u.label->addr - (sljit_w)(buf_ptr + 2)) >> 2) & 0x00ffffff;
! 735: }
! 736: else {
! 737: SLJIT_ASSERT(((sljit_w)jump->u.target - (sljit_w)(buf_ptr + 2)) <= 0x01ffffff && ((sljit_w)jump->u.target - (sljit_w)(buf_ptr + 2)) >= -0x02000000);
! 738: *buf_ptr |= (((sljit_w)jump->u.target - (sljit_w)(buf_ptr + 2)) >> 2) & 0x00ffffff;
! 739: }
! 740: }
! 741: else if (jump->flags & SLJIT_REWRITABLE_JUMP) {
! 742: #if (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5)
! 743: jump->addr = (sljit_uw)code_ptr;
! 744: code_ptr[0] = (sljit_uw)buf_ptr;
! 745: code_ptr[1] = *buf_ptr;
! 746: inline_set_jump_addr((sljit_uw)code_ptr, (jump->flags & JUMP_LABEL) ? jump->u.label->addr : jump->u.target, 0);
! 747: code_ptr += 2;
! 748: #else
! 749: inline_set_jump_addr((sljit_uw)buf_ptr, (jump->flags & JUMP_LABEL) ? jump->u.label->addr : jump->u.target, 0);
! 750: #endif
! 751: }
! 752: else {
! 753: #if (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5)
! 754: if (jump->flags & IS_BL)
! 755: buf_ptr--;
! 756: if (*buf_ptr & (1 << 23))
! 757: buf_ptr += ((*buf_ptr & 0xfff) >> 2) + 2;
! 758: else
! 759: buf_ptr += 1;
! 760: *buf_ptr = (jump->flags & JUMP_LABEL) ? jump->u.label->addr : jump->u.target;
! 761: #else
! 762: inline_set_jump_addr((sljit_uw)buf_ptr, (jump->flags & JUMP_LABEL) ? jump->u.label->addr : jump->u.target, 0);
! 763: #endif
! 764: }
! 765: jump = jump->next;
! 766: }
! 767:
! 768: #if (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5)
! 769: const_ = compiler->consts;
! 770: while (const_) {
! 771: buf_ptr = (sljit_uw*)const_->addr;
! 772: const_->addr = (sljit_uw)code_ptr;
! 773:
! 774: code_ptr[0] = (sljit_uw)buf_ptr;
! 775: code_ptr[1] = *buf_ptr;
! 776: if (*buf_ptr & (1 << 23))
! 777: buf_ptr += ((*buf_ptr & 0xfff) >> 2) + 2;
! 778: else
! 779: buf_ptr += 1;
! 780: /* Set the value again (can be a simple constant). */
! 781: inline_set_const((sljit_uw)code_ptr, *buf_ptr, 0);
! 782: code_ptr += 2;
! 783:
! 784: const_ = const_->next;
! 785: }
! 786: #endif
! 787:
! 788: SLJIT_ASSERT(code_ptr - code <= (int)size);
! 789:
! 790: SLJIT_CACHE_FLUSH(code, code_ptr);
! 791: compiler->error = SLJIT_ERR_COMPILED;
! 792: compiler->executable_size = size * sizeof(sljit_uw);
! 793: return code;
! 794: }
! 795:
! 796: /* emit_op inp_flags.
! 797: WRITE_BACK must be the first, since it is a flag. */
! 798: #define WRITE_BACK 0x01
! 799: #define ALLOW_IMM 0x02
! 800: #define ALLOW_INV_IMM 0x04
! 801: #define ALLOW_ANY_IMM (ALLOW_IMM | ALLOW_INV_IMM)
! 802: #define ARG_TEST 0x08
! 803:
! 804: /* Creates an index in data_transfer_insts array. */
! 805: #define WORD_DATA 0x00
! 806: #define BYTE_DATA 0x10
! 807: #define HALF_DATA 0x20
! 808: #define SIGNED_DATA 0x40
! 809: #define LOAD_DATA 0x80
! 810:
! 811: #define EMIT_INSTRUCTION(inst) \
! 812: FAIL_IF(push_inst(compiler, (inst)))
! 813:
! 814: /* Condition: AL. */
! 815: #define EMIT_DATA_PROCESS_INS(opcode, set_flags, dst, src1, src2) \
! 816: (0xe0000000 | ((opcode) << 21) | (set_flags) | RD(dst) | RN(src1) | (src2))
! 817:
! 818: static int emit_op(struct sljit_compiler *compiler, int op, int inp_flags,
! 819: int dst, sljit_w dstw,
! 820: int src1, sljit_w src1w,
! 821: int src2, sljit_w src2w);
! 822:
! 823: SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_enter(struct sljit_compiler *compiler, int args, int temporaries, int saveds, int local_size)
! 824: {
! 825: int size;
! 826: sljit_uw push;
! 827:
! 828: CHECK_ERROR();
! 829: check_sljit_emit_enter(compiler, args, temporaries, saveds, local_size);
! 830:
! 831: compiler->temporaries = temporaries;
! 832: compiler->saveds = saveds;
! 833:
! 834: /* Push saved registers, temporary registers
! 835: stmdb sp!, {..., lr} */
! 836: push = PUSH | (1 << 14);
! 837: if (temporaries >= 5)
! 838: push |= 1 << 11;
! 839: if (temporaries >= 4)
! 840: push |= 1 << 10;
! 841: if (saveds >= 5)
! 842: push |= 1 << 8;
! 843: if (saveds >= 4)
! 844: push |= 1 << 7;
! 845: if (saveds >= 3)
! 846: push |= 1 << 6;
! 847: if (saveds >= 2)
! 848: push |= 1 << 5;
! 849: if (saveds >= 1)
! 850: push |= 1 << 4;
! 851: EMIT_INSTRUCTION(push);
! 852:
! 853: /* Stack must be aligned to 8 bytes: */
! 854: size = (1 + saveds) * sizeof(sljit_uw);
! 855: if (temporaries >= 4)
! 856: size += (temporaries - 3) * sizeof(sljit_uw);
! 857: local_size += size;
! 858: local_size = (local_size + 7) & ~7;
! 859: local_size -= size;
! 860: compiler->local_size = local_size;
! 861: if (local_size > 0)
! 862: FAIL_IF(emit_op(compiler, SLJIT_SUB, ALLOW_IMM, SLJIT_LOCALS_REG, 0, SLJIT_LOCALS_REG, 0, SLJIT_IMM, local_size));
! 863:
! 864: if (args >= 1)
! 865: EMIT_INSTRUCTION(EMIT_DATA_PROCESS_INS(MOV_DP, 0, SLJIT_SAVED_REG1, SLJIT_UNUSED, RM(SLJIT_TEMPORARY_REG1)));
! 866: if (args >= 2)
! 867: EMIT_INSTRUCTION(EMIT_DATA_PROCESS_INS(MOV_DP, 0, SLJIT_SAVED_REG2, SLJIT_UNUSED, RM(SLJIT_TEMPORARY_REG2)));
! 868: if (args >= 3)
! 869: EMIT_INSTRUCTION(EMIT_DATA_PROCESS_INS(MOV_DP, 0, SLJIT_SAVED_REG3, SLJIT_UNUSED, RM(SLJIT_TEMPORARY_REG3)));
! 870:
! 871: return SLJIT_SUCCESS;
! 872: }
! 873:
! 874: SLJIT_API_FUNC_ATTRIBUTE void sljit_set_context(struct sljit_compiler *compiler, int args, int temporaries, int saveds, int local_size)
! 875: {
! 876: int size;
! 877:
! 878: CHECK_ERROR_VOID();
! 879: check_sljit_set_context(compiler, args, temporaries, saveds, local_size);
! 880:
! 881: compiler->temporaries = temporaries;
! 882: compiler->saveds = saveds;
! 883:
! 884: size = (1 + saveds) * sizeof(sljit_uw);
! 885: if (temporaries >= 4)
! 886: size += (temporaries - 3) * sizeof(sljit_uw);
! 887: local_size += size;
! 888: local_size = (local_size + 7) & ~7;
! 889: local_size -= size;
! 890: compiler->local_size = local_size;
! 891: }
! 892:
! 893: SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_return(struct sljit_compiler *compiler, int op, int src, sljit_w srcw)
! 894: {
! 895: sljit_uw pop;
! 896:
! 897: CHECK_ERROR();
! 898: check_sljit_emit_return(compiler, op, src, srcw);
! 899:
! 900: FAIL_IF(emit_mov_before_return(compiler, op, src, srcw));
! 901:
! 902: if (compiler->local_size > 0)
! 903: FAIL_IF(emit_op(compiler, SLJIT_ADD, ALLOW_IMM, SLJIT_LOCALS_REG, 0, SLJIT_LOCALS_REG, 0, SLJIT_IMM, compiler->local_size));
! 904:
! 905: pop = POP | (1 << 15);
! 906: /* Push saved registers, temporary registers
! 907: ldmia sp!, {..., pc} */
! 908: if (compiler->temporaries >= 5)
! 909: pop |= 1 << 11;
! 910: if (compiler->temporaries >= 4)
! 911: pop |= 1 << 10;
! 912: if (compiler->saveds >= 5)
! 913: pop |= 1 << 8;
! 914: if (compiler->saveds >= 4)
! 915: pop |= 1 << 7;
! 916: if (compiler->saveds >= 3)
! 917: pop |= 1 << 6;
! 918: if (compiler->saveds >= 2)
! 919: pop |= 1 << 5;
! 920: if (compiler->saveds >= 1)
! 921: pop |= 1 << 4;
! 922:
! 923: return push_inst(compiler, pop);
! 924: }
! 925:
! 926: /* --------------------------------------------------------------------- */
! 927: /* Operators */
! 928: /* --------------------------------------------------------------------- */
! 929:
! 930: /* s/l - store/load (1 bit)
! 931: u/s - signed/unsigned (1 bit)
! 932: w/b/h/N - word/byte/half/NOT allowed (2 bit)
! 933: It contans 16 items, but not all are different. */
! 934:
! 935: static sljit_w data_transfer_insts[16] = {
! 936: /* s u w */ 0xe5000000 /* str */,
! 937: /* s u b */ 0xe5400000 /* strb */,
! 938: /* s u h */ 0xe10000b0 /* strh */,
! 939: /* s u N */ 0x00000000 /* not allowed */,
! 940: /* s s w */ 0xe5000000 /* str */,
! 941: /* s s b */ 0xe5400000 /* strb */,
! 942: /* s s h */ 0xe10000b0 /* strh */,
! 943: /* s s N */ 0x00000000 /* not allowed */,
! 944:
! 945: /* l u w */ 0xe5100000 /* ldr */,
! 946: /* l u b */ 0xe5500000 /* ldrb */,
! 947: /* l u h */ 0xe11000b0 /* ldrh */,
! 948: /* l u N */ 0x00000000 /* not allowed */,
! 949: /* l s w */ 0xe5100000 /* ldr */,
! 950: /* l s b */ 0xe11000d0 /* ldrsb */,
! 951: /* l s h */ 0xe11000f0 /* ldrsh */,
! 952: /* l s N */ 0x00000000 /* not allowed */,
! 953: };
! 954:
! 955: #define EMIT_DATA_TRANSFER(type, add, wb, target, base1, base2) \
! 956: (data_transfer_insts[(type) >> 4] | ((add) << 23) | ((wb) << 21) | (reg_map[target] << 12) | (reg_map[base1] << 16) | (base2))
! 957: /* Normal ldr/str instruction.
! 958: Type2: ldrsb, ldrh, ldrsh */
! 959: #define IS_TYPE1_TRANSFER(type) \
! 960: (data_transfer_insts[(type) >> 4] & 0x04000000)
! 961: #define TYPE2_TRANSFER_IMM(imm) \
! 962: (((imm) & 0xf) | (((imm) & 0xf0) << 4) | (1 << 22))
! 963:
! 964: /* flags: */
! 965: /* Arguments are swapped. */
! 966: #define ARGS_SWAPPED 0x01
! 967: /* Inverted immediate. */
! 968: #define INV_IMM 0x02
! 969: /* Source and destination is register. */
! 970: #define REG_DEST 0x04
! 971: #define REG_SOURCE 0x08
! 972: /* One instruction is enough. */
! 973: #define FAST_DEST 0x10
! 974: /* Multiple instructions are required. */
! 975: #define SLOW_DEST 0x20
! 976: /* SET_FLAGS must be (1 << 20) as it is also the value of S bit (can be used for optimization). */
! 977: #define SET_FLAGS (1 << 20)
! 978: /* dst: reg
! 979: src1: reg
! 980: src2: reg or imm (if allowed)
! 981: SRC2_IMM must be (1 << 25) as it is also the value of I bit (can be used for optimization). */
! 982: #define SRC2_IMM (1 << 25)
! 983:
! 984: #define EMIT_DATA_PROCESS_INS_AND_RETURN(opcode) \
! 985: return push_inst(compiler, EMIT_DATA_PROCESS_INS(opcode, flags & SET_FLAGS, dst, src1, (src2 & SRC2_IMM) ? src2 : RM(src2)))
! 986:
! 987: #define EMIT_FULL_DATA_PROCESS_INS_AND_RETURN(opcode, dst, src1, src2) \
! 988: return push_inst(compiler, EMIT_DATA_PROCESS_INS(opcode, flags & SET_FLAGS, dst, src1, src2))
! 989:
! 990: #define EMIT_SHIFT_INS_AND_RETURN(opcode) \
! 991: SLJIT_ASSERT(!(flags & INV_IMM) && !(src2 & SRC2_IMM)); \
! 992: if (compiler->shift_imm != 0x20) { \
! 993: SLJIT_ASSERT(src1 == TMP_REG1); \
! 994: SLJIT_ASSERT(!(flags & ARGS_SWAPPED)); \
! 995: if (compiler->shift_imm != 0) \
! 996: return push_inst(compiler, EMIT_DATA_PROCESS_INS(MOV_DP, flags & SET_FLAGS, dst, SLJIT_UNUSED, (compiler->shift_imm << 7) | (opcode << 5) | reg_map[src2])); \
! 997: return push_inst(compiler, EMIT_DATA_PROCESS_INS(MOV_DP, flags & SET_FLAGS, dst, SLJIT_UNUSED, reg_map[src2])); \
! 998: } \
! 999: return push_inst(compiler, EMIT_DATA_PROCESS_INS(MOV_DP, flags & SET_FLAGS, dst, SLJIT_UNUSED, (reg_map[(flags & ARGS_SWAPPED) ? src1 : src2] << 8) | (opcode << 5) | 0x10 | ((flags & ARGS_SWAPPED) ? reg_map[src2] : reg_map[src1])));
! 1000:
! 1001: static SLJIT_INLINE int emit_single_op(struct sljit_compiler *compiler, int op, int flags,
! 1002: int dst, int src1, int src2)
! 1003: {
! 1004: sljit_w mul_inst;
! 1005:
! 1006: switch (GET_OPCODE(op)) {
! 1007: case SLJIT_ADD:
! 1008: SLJIT_ASSERT(!(flags & INV_IMM));
! 1009: EMIT_DATA_PROCESS_INS_AND_RETURN(ADD_DP);
! 1010:
! 1011: case SLJIT_ADDC:
! 1012: SLJIT_ASSERT(!(flags & INV_IMM));
! 1013: EMIT_DATA_PROCESS_INS_AND_RETURN(ADC_DP);
! 1014:
! 1015: case SLJIT_SUB:
! 1016: SLJIT_ASSERT(!(flags & INV_IMM));
! 1017: if (!(flags & ARGS_SWAPPED))
! 1018: EMIT_DATA_PROCESS_INS_AND_RETURN(SUB_DP);
! 1019: EMIT_DATA_PROCESS_INS_AND_RETURN(RSB_DP);
! 1020:
! 1021: case SLJIT_SUBC:
! 1022: SLJIT_ASSERT(!(flags & INV_IMM));
! 1023: if (!(flags & ARGS_SWAPPED))
! 1024: EMIT_DATA_PROCESS_INS_AND_RETURN(SBC_DP);
! 1025: EMIT_DATA_PROCESS_INS_AND_RETURN(RSC_DP);
! 1026:
! 1027: case SLJIT_MUL:
! 1028: SLJIT_ASSERT(!(flags & INV_IMM));
! 1029: SLJIT_ASSERT(!(src2 & SRC2_IMM));
! 1030: if (SLJIT_UNLIKELY(op & SLJIT_SET_O))
! 1031: mul_inst = SMULL | (reg_map[TMP_REG3] << 16) | (reg_map[dst] << 12);
! 1032: else
! 1033: mul_inst = MUL | (reg_map[dst] << 16);
! 1034:
! 1035: if (dst != src2)
! 1036: FAIL_IF(push_inst(compiler, mul_inst | (reg_map[src1] << 8) | reg_map[src2]));
! 1037: else if (dst != src1)
! 1038: FAIL_IF(push_inst(compiler, mul_inst | (reg_map[src2] << 8) | reg_map[src1]));
! 1039: else {
! 1040: /* Rm and Rd must not be the same register. */
! 1041: SLJIT_ASSERT(dst != TMP_REG1);
! 1042: FAIL_IF(push_inst(compiler, EMIT_DATA_PROCESS_INS(MOV_DP, 0, TMP_REG1, SLJIT_UNUSED, reg_map[src2])));
! 1043: FAIL_IF(push_inst(compiler, mul_inst | (reg_map[src2] << 8) | reg_map[TMP_REG1]));
! 1044: }
! 1045:
! 1046: if (!(op & SLJIT_SET_O))
! 1047: return SLJIT_SUCCESS;
! 1048:
! 1049: /* We need to use TMP_REG3. */
! 1050: compiler->cache_arg = 0;
! 1051: compiler->cache_argw = 0;
! 1052: /* cmp TMP_REG2, dst asr #31. */
! 1053: return push_inst(compiler, EMIT_DATA_PROCESS_INS(CMP_DP, SET_FLAGS, SLJIT_UNUSED, TMP_REG3, RM(dst) | 0xfc0));
! 1054:
! 1055: case SLJIT_AND:
! 1056: if (!(flags & INV_IMM))
! 1057: EMIT_DATA_PROCESS_INS_AND_RETURN(AND_DP);
! 1058: EMIT_DATA_PROCESS_INS_AND_RETURN(BIC_DP);
! 1059:
! 1060: case SLJIT_OR:
! 1061: SLJIT_ASSERT(!(flags & INV_IMM));
! 1062: EMIT_DATA_PROCESS_INS_AND_RETURN(ORR_DP);
! 1063:
! 1064: case SLJIT_XOR:
! 1065: SLJIT_ASSERT(!(flags & INV_IMM));
! 1066: EMIT_DATA_PROCESS_INS_AND_RETURN(EOR_DP);
! 1067:
! 1068: case SLJIT_SHL:
! 1069: EMIT_SHIFT_INS_AND_RETURN(0);
! 1070:
! 1071: case SLJIT_LSHR:
! 1072: EMIT_SHIFT_INS_AND_RETURN(1);
! 1073:
! 1074: case SLJIT_ASHR:
! 1075: EMIT_SHIFT_INS_AND_RETURN(2);
! 1076:
! 1077: case SLJIT_MOV:
! 1078: SLJIT_ASSERT(src1 == TMP_REG1 && !(flags & ARGS_SWAPPED));
! 1079: if (dst != src2) {
! 1080: if (src2 & SRC2_IMM) {
! 1081: if (flags & INV_IMM)
! 1082: EMIT_FULL_DATA_PROCESS_INS_AND_RETURN(MVN_DP, dst, SLJIT_UNUSED, src2);
! 1083: EMIT_FULL_DATA_PROCESS_INS_AND_RETURN(MOV_DP, dst, SLJIT_UNUSED, src2);
! 1084: }
! 1085: EMIT_FULL_DATA_PROCESS_INS_AND_RETURN(MOV_DP, dst, SLJIT_UNUSED, reg_map[src2]);
! 1086: }
! 1087: return SLJIT_SUCCESS;
! 1088:
! 1089: case SLJIT_MOV_UB:
! 1090: case SLJIT_MOV_SB:
! 1091: SLJIT_ASSERT(src1 == TMP_REG1 && !(flags & ARGS_SWAPPED));
! 1092: if ((flags & (REG_DEST | REG_SOURCE)) == (REG_DEST | REG_SOURCE)) {
! 1093: #if (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5)
! 1094: if (op == SLJIT_MOV_UB)
! 1095: return push_inst(compiler, EMIT_DATA_PROCESS_INS(AND_DP, 0, dst, src2, SRC2_IMM | 0xff));
! 1096: EMIT_INSTRUCTION(EMIT_DATA_PROCESS_INS(MOV_DP, 0, dst, SLJIT_UNUSED, (24 << 7) | reg_map[src2]));
! 1097: return push_inst(compiler, EMIT_DATA_PROCESS_INS(MOV_DP, 0, dst, SLJIT_UNUSED, (24 << 7) | (op == SLJIT_MOV_UB ? 0x20 : 0x40) | reg_map[dst]));
! 1098: #else
! 1099: return push_inst(compiler, (op == SLJIT_MOV_UB ? UXTB : SXTB) | RD(dst) | RM(src2));
! 1100: #endif
! 1101: }
! 1102: else if (dst != src2) {
! 1103: SLJIT_ASSERT(src2 & SRC2_IMM);
! 1104: if (flags & INV_IMM)
! 1105: EMIT_FULL_DATA_PROCESS_INS_AND_RETURN(MVN_DP, dst, SLJIT_UNUSED, src2);
! 1106: EMIT_FULL_DATA_PROCESS_INS_AND_RETURN(MOV_DP, dst, SLJIT_UNUSED, src2);
! 1107: }
! 1108: return SLJIT_SUCCESS;
! 1109:
! 1110: case SLJIT_MOV_UH:
! 1111: case SLJIT_MOV_SH:
! 1112: SLJIT_ASSERT(src1 == TMP_REG1 && !(flags & ARGS_SWAPPED));
! 1113: if ((flags & (REG_DEST | REG_SOURCE)) == (REG_DEST | REG_SOURCE)) {
! 1114: #if (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5)
! 1115: EMIT_INSTRUCTION(EMIT_DATA_PROCESS_INS(MOV_DP, 0, dst, SLJIT_UNUSED, (16 << 7) | reg_map[src2]));
! 1116: return push_inst(compiler, EMIT_DATA_PROCESS_INS(MOV_DP, 0, dst, SLJIT_UNUSED, (16 << 7) | (op == SLJIT_MOV_UH ? 0x20 : 0x40) | reg_map[dst]));
! 1117: #else
! 1118: return push_inst(compiler, (op == SLJIT_MOV_UH ? UXTH : SXTH) | RD(dst) | RM(src2));
! 1119: #endif
! 1120: }
! 1121: else if (dst != src2) {
! 1122: SLJIT_ASSERT(src2 & SRC2_IMM);
! 1123: if (flags & INV_IMM)
! 1124: EMIT_FULL_DATA_PROCESS_INS_AND_RETURN(MVN_DP, dst, SLJIT_UNUSED, src2);
! 1125: EMIT_FULL_DATA_PROCESS_INS_AND_RETURN(MOV_DP, dst, SLJIT_UNUSED, src2);
! 1126: }
! 1127: return SLJIT_SUCCESS;
! 1128:
! 1129: case SLJIT_NOT:
! 1130: if (src2 & SRC2_IMM) {
! 1131: if (flags & INV_IMM)
! 1132: EMIT_FULL_DATA_PROCESS_INS_AND_RETURN(MOV_DP, dst, SLJIT_UNUSED, src2);
! 1133: EMIT_FULL_DATA_PROCESS_INS_AND_RETURN(MVN_DP, dst, SLJIT_UNUSED, src2);
! 1134: }
! 1135: EMIT_FULL_DATA_PROCESS_INS_AND_RETURN(MVN_DP, dst, SLJIT_UNUSED, RM(src2));
! 1136:
! 1137: case SLJIT_CLZ:
! 1138: SLJIT_ASSERT(!(flags & INV_IMM));
! 1139: SLJIT_ASSERT(!(src2 & SRC2_IMM));
! 1140: FAIL_IF(push_inst(compiler, CLZ | RD(dst) | RM(src2)));
! 1141: if (flags & SET_FLAGS)
! 1142: EMIT_FULL_DATA_PROCESS_INS_AND_RETURN(CMP_DP, SLJIT_UNUSED, dst, SRC2_IMM);
! 1143: return SLJIT_SUCCESS;
! 1144: }
! 1145: SLJIT_ASSERT_STOP();
! 1146: return SLJIT_SUCCESS;
! 1147: }
! 1148:
! 1149: #undef EMIT_DATA_PROCESS_INS_AND_RETURN
! 1150: #undef EMIT_FULL_DATA_PROCESS_INS_AND_RETURN
! 1151: #undef EMIT_SHIFT_INS_AND_RETURN
! 1152:
! 1153: /* Tests whether the immediate can be stored in the 12 bit imm field.
! 1154: Returns with 0 if not possible. */
! 1155: static sljit_uw get_immediate(sljit_uw imm)
! 1156: {
! 1157: int rol;
! 1158:
! 1159: if (imm <= 0xff)
! 1160: return SRC2_IMM | imm;
! 1161:
! 1162: if (!(imm & 0xff000000)) {
! 1163: imm <<= 8;
! 1164: rol = 8;
! 1165: }
! 1166: else {
! 1167: imm = (imm << 24) | (imm >> 8);
! 1168: rol = 0;
! 1169: }
! 1170:
! 1171: if (!(imm & 0xff000000)) {
! 1172: imm <<= 8;
! 1173: rol += 4;
! 1174: }
! 1175:
! 1176: if (!(imm & 0xf0000000)) {
! 1177: imm <<= 4;
! 1178: rol += 2;
! 1179: }
! 1180:
! 1181: if (!(imm & 0xc0000000)) {
! 1182: imm <<= 2;
! 1183: rol += 1;
! 1184: }
! 1185:
! 1186: if (!(imm & 0x00ffffff))
! 1187: return SRC2_IMM | (imm >> 24) | (rol << 8);
! 1188: else
! 1189: return 0;
! 1190: }
! 1191:
! 1192: #if (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5)
! 1193: static int generate_int(struct sljit_compiler *compiler, int reg, sljit_uw imm, int positive)
! 1194: {
! 1195: sljit_uw mask;
! 1196: sljit_uw imm1;
! 1197: sljit_uw imm2;
! 1198: int rol;
! 1199:
! 1200: /* Step1: Search a zero byte (8 continous zero bit). */
! 1201: mask = 0xff000000;
! 1202: rol = 8;
! 1203: while(1) {
! 1204: if (!(imm & mask)) {
! 1205: /* Rol imm by rol. */
! 1206: imm = (imm << rol) | (imm >> (32 - rol));
! 1207: /* Calculate arm rol. */
! 1208: rol = 4 + (rol >> 1);
! 1209: break;
! 1210: }
! 1211: rol += 2;
! 1212: mask >>= 2;
! 1213: if (mask & 0x3) {
! 1214: /* rol by 8. */
! 1215: imm = (imm << 8) | (imm >> 24);
! 1216: mask = 0xff00;
! 1217: rol = 24;
! 1218: while (1) {
! 1219: if (!(imm & mask)) {
! 1220: /* Rol imm by rol. */
! 1221: imm = (imm << rol) | (imm >> (32 - rol));
! 1222: /* Calculate arm rol. */
! 1223: rol = (rol >> 1) - 8;
! 1224: break;
! 1225: }
! 1226: rol += 2;
! 1227: mask >>= 2;
! 1228: if (mask & 0x3)
! 1229: return 0;
! 1230: }
! 1231: break;
! 1232: }
! 1233: }
! 1234:
! 1235: /* The low 8 bit must be zero. */
! 1236: SLJIT_ASSERT(!(imm & 0xff));
! 1237:
! 1238: if (!(imm & 0xff000000)) {
! 1239: imm1 = SRC2_IMM | ((imm >> 16) & 0xff) | (((rol + 4) & 0xf) << 8);
! 1240: imm2 = SRC2_IMM | ((imm >> 8) & 0xff) | (((rol + 8) & 0xf) << 8);
! 1241: }
! 1242: else if (imm & 0xc0000000) {
! 1243: imm1 = SRC2_IMM | ((imm >> 24) & 0xff) | ((rol & 0xf) << 8);
! 1244: imm <<= 8;
! 1245: rol += 4;
! 1246:
! 1247: if (!(imm & 0xff000000)) {
! 1248: imm <<= 8;
! 1249: rol += 4;
! 1250: }
! 1251:
! 1252: if (!(imm & 0xf0000000)) {
! 1253: imm <<= 4;
! 1254: rol += 2;
! 1255: }
! 1256:
! 1257: if (!(imm & 0xc0000000)) {
! 1258: imm <<= 2;
! 1259: rol += 1;
! 1260: }
! 1261:
! 1262: if (!(imm & 0x00ffffff))
! 1263: imm2 = SRC2_IMM | (imm >> 24) | ((rol & 0xf) << 8);
! 1264: else
! 1265: return 0;
! 1266: }
! 1267: else {
! 1268: if (!(imm & 0xf0000000)) {
! 1269: imm <<= 4;
! 1270: rol += 2;
! 1271: }
! 1272:
! 1273: if (!(imm & 0xc0000000)) {
! 1274: imm <<= 2;
! 1275: rol += 1;
! 1276: }
! 1277:
! 1278: imm1 = SRC2_IMM | ((imm >> 24) & 0xff) | ((rol & 0xf) << 8);
! 1279: imm <<= 8;
! 1280: rol += 4;
! 1281:
! 1282: if (!(imm & 0xf0000000)) {
! 1283: imm <<= 4;
! 1284: rol += 2;
! 1285: }
! 1286:
! 1287: if (!(imm & 0xc0000000)) {
! 1288: imm <<= 2;
! 1289: rol += 1;
! 1290: }
! 1291:
! 1292: if (!(imm & 0x00ffffff))
! 1293: imm2 = SRC2_IMM | (imm >> 24) | ((rol & 0xf) << 8);
! 1294: else
! 1295: return 0;
! 1296: }
! 1297:
! 1298: EMIT_INSTRUCTION(EMIT_DATA_PROCESS_INS(positive ? MOV_DP : MVN_DP, 0, reg, SLJIT_UNUSED, imm1));
! 1299: EMIT_INSTRUCTION(EMIT_DATA_PROCESS_INS(positive ? ORR_DP : BIC_DP, 0, reg, reg, imm2));
! 1300: return 1;
! 1301: }
! 1302: #endif
! 1303:
! 1304: static int load_immediate(struct sljit_compiler *compiler, int reg, sljit_uw imm)
! 1305: {
! 1306: sljit_uw tmp;
! 1307:
! 1308: #if (defined SLJIT_CONFIG_ARM_V7 && SLJIT_CONFIG_ARM_V7)
! 1309: if (!(imm & ~0xffff))
! 1310: return push_inst(compiler, MOVW | RD(reg) | ((imm << 4) & 0xf0000) | (imm & 0xfff));
! 1311: #endif
! 1312:
! 1313: /* Create imm by 1 inst. */
! 1314: tmp = get_immediate(imm);
! 1315: if (tmp) {
! 1316: EMIT_INSTRUCTION(EMIT_DATA_PROCESS_INS(MOV_DP, 0, reg, SLJIT_UNUSED, tmp));
! 1317: return SLJIT_SUCCESS;
! 1318: }
! 1319:
! 1320: tmp = get_immediate(~imm);
! 1321: if (tmp) {
! 1322: EMIT_INSTRUCTION(EMIT_DATA_PROCESS_INS(MVN_DP, 0, reg, SLJIT_UNUSED, tmp));
! 1323: return SLJIT_SUCCESS;
! 1324: }
! 1325:
! 1326: #if (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5)
! 1327: /* Create imm by 2 inst. */
! 1328: FAIL_IF(generate_int(compiler, reg, imm, 1));
! 1329: FAIL_IF(generate_int(compiler, reg, ~imm, 0));
! 1330:
! 1331: /* Load integer. */
! 1332: return push_inst_with_literal(compiler, EMIT_DATA_TRANSFER(WORD_DATA | LOAD_DATA, 1, 0, reg, TMP_PC, 0), imm);
! 1333: #else
! 1334: return emit_imm(compiler, reg, imm);
! 1335: #endif
! 1336: }
! 1337:
! 1338: /* Can perform an operation using at most 1 instruction. */
! 1339: static int getput_arg_fast(struct sljit_compiler *compiler, int inp_flags, int reg, int arg, sljit_w argw)
! 1340: {
! 1341: sljit_uw imm;
! 1342:
! 1343: if (arg & SLJIT_IMM) {
! 1344: imm = get_immediate(argw);
! 1345: if (imm) {
! 1346: if (inp_flags & ARG_TEST)
! 1347: return 1;
! 1348: EMIT_INSTRUCTION(EMIT_DATA_PROCESS_INS(MOV_DP, 0, reg, SLJIT_UNUSED, imm));
! 1349: return -1;
! 1350: }
! 1351: imm = get_immediate(~argw);
! 1352: if (imm) {
! 1353: if (inp_flags & ARG_TEST)
! 1354: return 1;
! 1355: EMIT_INSTRUCTION(EMIT_DATA_PROCESS_INS(MVN_DP, 0, reg, SLJIT_UNUSED, imm));
! 1356: return -1;
! 1357: }
! 1358: return (inp_flags & ARG_TEST) ? SLJIT_SUCCESS : 0;
! 1359: }
! 1360:
! 1361: SLJIT_ASSERT(arg & SLJIT_MEM);
! 1362:
! 1363: /* Fast loads/stores. */
! 1364: if (arg & 0xf) {
! 1365: if (!(arg & 0xf0)) {
! 1366: if (IS_TYPE1_TRANSFER(inp_flags)) {
! 1367: if (argw >= 0 && argw <= 0xfff) {
! 1368: if (inp_flags & ARG_TEST)
! 1369: return 1;
! 1370: EMIT_INSTRUCTION(EMIT_DATA_TRANSFER(inp_flags, 1, inp_flags & WRITE_BACK, reg, arg & 0xf, argw));
! 1371: return -1;
! 1372: }
! 1373: if (argw < 0 && argw >= -0xfff) {
! 1374: if (inp_flags & ARG_TEST)
! 1375: return 1;
! 1376: EMIT_INSTRUCTION(EMIT_DATA_TRANSFER(inp_flags, 0, inp_flags & WRITE_BACK, reg, arg & 0xf, -argw));
! 1377: return -1;
! 1378: }
! 1379: }
! 1380: else {
! 1381: if (argw >= 0 && argw <= 0xff) {
! 1382: if (inp_flags & ARG_TEST)
! 1383: return 1;
! 1384: EMIT_INSTRUCTION(EMIT_DATA_TRANSFER(inp_flags, 1, inp_flags & WRITE_BACK, reg, arg & 0xf, TYPE2_TRANSFER_IMM(argw)));
! 1385: return -1;
! 1386: }
! 1387: if (argw < 0 && argw >= -0xff) {
! 1388: if (inp_flags & ARG_TEST)
! 1389: return 1;
! 1390: argw = -argw;
! 1391: EMIT_INSTRUCTION(EMIT_DATA_TRANSFER(inp_flags, 0, inp_flags & WRITE_BACK, reg, arg & 0xf, TYPE2_TRANSFER_IMM(argw)));
! 1392: return -1;
! 1393: }
! 1394: }
! 1395: }
! 1396: else if ((argw & 0x3) == 0 || IS_TYPE1_TRANSFER(inp_flags)) {
! 1397: if (inp_flags & ARG_TEST)
! 1398: return 1;
! 1399: EMIT_INSTRUCTION(EMIT_DATA_TRANSFER(inp_flags, 1, inp_flags & WRITE_BACK, reg, arg & 0xf,
! 1400: RM((arg >> 4) & 0xf) | (IS_TYPE1_TRANSFER(inp_flags) ? SRC2_IMM : 0) | ((argw & 0x3) << 7)));
! 1401: return -1;
! 1402: }
! 1403: }
! 1404:
! 1405: return (inp_flags & ARG_TEST) ? SLJIT_SUCCESS : 0;
! 1406: }
! 1407:
! 1408: /* See getput_arg below.
! 1409: Note: can_cache is called only for binary operators. Those
! 1410: operators always uses word arguments without write back. */
! 1411: static int can_cache(int arg, sljit_w argw, int next_arg, sljit_w next_argw)
! 1412: {
! 1413: /* Immediate caching is not supported as it would be an operation on constant arguments. */
! 1414: if (arg & SLJIT_IMM)
! 1415: return 0;
! 1416:
! 1417: /* Always a simple operation. */
! 1418: if (arg & 0xf0)
! 1419: return 0;
! 1420:
! 1421: if (!(arg & 0xf)) {
! 1422: /* Immediate access. */
! 1423: if ((next_arg & SLJIT_MEM) && ((sljit_uw)argw - (sljit_uw)next_argw <= 0xfff || (sljit_uw)next_argw - (sljit_uw)argw <= 0xfff))
! 1424: return 1;
! 1425: return 0;
! 1426: }
! 1427:
! 1428: if (argw <= 0xfffff && argw >= -0xfffff)
! 1429: return 0;
! 1430:
! 1431: if (argw == next_argw && (next_arg & SLJIT_MEM))
! 1432: return 1;
! 1433:
! 1434: if (arg == next_arg && ((sljit_uw)argw - (sljit_uw)next_argw <= 0xfff || (sljit_uw)next_argw - (sljit_uw)argw <= 0xfff))
! 1435: return 1;
! 1436:
! 1437: return 0;
! 1438: }
! 1439:
! 1440: #define GETPUT_ARG_DATA_TRANSFER(add, wb, target, base, imm) \
! 1441: if (max_delta & 0xf00) \
! 1442: FAIL_IF(push_inst(compiler, EMIT_DATA_TRANSFER(inp_flags, add, wb, target, base, imm))); \
! 1443: else \
! 1444: FAIL_IF(push_inst(compiler, EMIT_DATA_TRANSFER(inp_flags, add, wb, target, base, TYPE2_TRANSFER_IMM(imm))));
! 1445:
! 1446: #define TEST_WRITE_BACK() \
! 1447: if (inp_flags & WRITE_BACK) { \
! 1448: tmp_r = arg & 0xf; \
! 1449: if (reg == tmp_r) { \
! 1450: /* This can only happen for stores */ \
! 1451: /* since ldr reg, [reg, ...]! has no meaning */ \
! 1452: SLJIT_ASSERT(!(inp_flags & LOAD_DATA)); \
! 1453: EMIT_INSTRUCTION(EMIT_DATA_PROCESS_INS(MOV_DP, 0, TMP_REG3, SLJIT_UNUSED, RM(reg))); \
! 1454: reg = TMP_REG3; \
! 1455: } \
! 1456: }
! 1457:
! 1458: /* Emit the necessary instructions. See can_cache above. */
! 1459: 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)
! 1460: {
! 1461: int tmp_r;
! 1462: sljit_w max_delta;
! 1463: sljit_w sign;
! 1464:
! 1465: if (arg & SLJIT_IMM) {
! 1466: SLJIT_ASSERT(inp_flags & LOAD_DATA);
! 1467: return load_immediate(compiler, reg, argw);
! 1468: }
! 1469:
! 1470: SLJIT_ASSERT(arg & SLJIT_MEM);
! 1471:
! 1472: tmp_r = (inp_flags & LOAD_DATA) ? reg : TMP_REG3;
! 1473: max_delta = IS_TYPE1_TRANSFER(inp_flags) ? 0xfff : 0xff;
! 1474:
! 1475: if ((arg & 0xf) == SLJIT_UNUSED) {
! 1476: /* Write back is not used. */
! 1477: if ((compiler->cache_arg & SLJIT_IMM) && (((sljit_uw)argw - (sljit_uw)compiler->cache_argw) <= (sljit_uw)max_delta || ((sljit_uw)compiler->cache_argw - (sljit_uw)argw) <= (sljit_uw)max_delta)) {
! 1478: if (((sljit_uw)argw - (sljit_uw)compiler->cache_argw) <= (sljit_uw)max_delta) {
! 1479: sign = 1;
! 1480: argw = argw - compiler->cache_argw;
! 1481: }
! 1482: else {
! 1483: sign = 0;
! 1484: argw = compiler->cache_argw - argw;
! 1485: }
! 1486:
! 1487: if (max_delta & 0xf00) {
! 1488: EMIT_INSTRUCTION(EMIT_DATA_TRANSFER(inp_flags, sign, 0, reg, TMP_REG3, argw));
! 1489: }
! 1490: else {
! 1491: EMIT_INSTRUCTION(EMIT_DATA_TRANSFER(inp_flags, sign, 0, reg, TMP_REG3, TYPE2_TRANSFER_IMM(argw)));
! 1492: }
! 1493: return SLJIT_SUCCESS;
! 1494: }
! 1495:
! 1496: /* With write back, we can create some sophisticated loads, but
! 1497: it is hard to decide whether we should convert downward (0s) or upward (1s). */
! 1498: if ((next_arg & SLJIT_MEM) && ((sljit_uw)argw - (sljit_uw)next_argw <= (sljit_uw)max_delta || (sljit_uw)next_argw - (sljit_uw)argw <= (sljit_uw)max_delta)) {
! 1499: SLJIT_ASSERT(inp_flags & LOAD_DATA);
! 1500:
! 1501: compiler->cache_arg = SLJIT_IMM;
! 1502: compiler->cache_argw = argw;
! 1503: tmp_r = TMP_REG3;
! 1504: }
! 1505:
! 1506: FAIL_IF(load_immediate(compiler, tmp_r, argw));
! 1507: GETPUT_ARG_DATA_TRANSFER(1, 0, reg, tmp_r, 0);
! 1508: return SLJIT_SUCCESS;
! 1509: }
! 1510:
! 1511: /* Extended imm addressing for [reg+imm] format. */
! 1512: sign = (max_delta << 8) | 0xff;
! 1513: if (!(arg & 0xf0) && argw <= sign && argw >= -sign) {
! 1514: TEST_WRITE_BACK();
! 1515: if (argw >= 0) {
! 1516: sign = 1;
! 1517: }
! 1518: else {
! 1519: sign = 0;
! 1520: argw = -argw;
! 1521: }
! 1522:
! 1523: /* Optimization: add is 0x4, sub is 0x2. Sign is 1 for add and 0 for sub. */
! 1524: if (max_delta & 0xf00)
! 1525: EMIT_INSTRUCTION(EMIT_DATA_PROCESS_INS(SUB_DP << sign, 0, tmp_r, arg & 0xf, SRC2_IMM | (argw >> 12) | 0xa00));
! 1526: else
! 1527: EMIT_INSTRUCTION(EMIT_DATA_PROCESS_INS(SUB_DP << sign, 0, tmp_r, arg & 0xf, SRC2_IMM | (argw >> 8) | 0xc00));
! 1528:
! 1529: argw &= max_delta;
! 1530: GETPUT_ARG_DATA_TRANSFER(sign, inp_flags & WRITE_BACK, reg, tmp_r, argw);
! 1531: return SLJIT_SUCCESS;
! 1532: }
! 1533:
! 1534: if (arg & 0xf0) {
! 1535: SLJIT_ASSERT((argw & 0x3) && !(max_delta & 0xf00));
! 1536: if (inp_flags & WRITE_BACK)
! 1537: tmp_r = arg & 0xf;
! 1538: EMIT_INSTRUCTION(EMIT_DATA_PROCESS_INS(ADD_DP, 0, tmp_r, arg & 0xf, RM((arg >> 4) & 0xf) | ((argw & 0x3) << 7)));
! 1539: EMIT_INSTRUCTION(EMIT_DATA_TRANSFER(inp_flags, 1, 0, reg, tmp_r, TYPE2_TRANSFER_IMM(0)));
! 1540: return SLJIT_SUCCESS;
! 1541: }
! 1542:
! 1543: if (compiler->cache_arg == arg && ((sljit_uw)argw - (sljit_uw)compiler->cache_argw) <= (sljit_uw)max_delta) {
! 1544: SLJIT_ASSERT(!(inp_flags & WRITE_BACK));
! 1545: argw = argw - compiler->cache_argw;
! 1546: GETPUT_ARG_DATA_TRANSFER(1, 0, reg, TMP_REG3, argw);
! 1547: return SLJIT_SUCCESS;
! 1548: }
! 1549:
! 1550: if (compiler->cache_arg == arg && ((sljit_uw)compiler->cache_argw - (sljit_uw)argw) <= (sljit_uw)max_delta) {
! 1551: SLJIT_ASSERT(!(inp_flags & WRITE_BACK));
! 1552: argw = compiler->cache_argw - argw;
! 1553: GETPUT_ARG_DATA_TRANSFER(0, 0, reg, TMP_REG3, argw);
! 1554: return SLJIT_SUCCESS;
! 1555: }
! 1556:
! 1557: if ((compiler->cache_arg & SLJIT_IMM) && compiler->cache_argw == argw) {
! 1558: TEST_WRITE_BACK();
! 1559: EMIT_INSTRUCTION(EMIT_DATA_TRANSFER(inp_flags, 1, inp_flags & WRITE_BACK, reg, arg & 0xf, RM(TMP_REG3) | (max_delta & 0xf00 ? SRC2_IMM : 0)));
! 1560: return SLJIT_SUCCESS;
! 1561: }
! 1562:
! 1563: if (argw == next_argw && (next_arg & SLJIT_MEM)) {
! 1564: SLJIT_ASSERT(inp_flags & LOAD_DATA);
! 1565: FAIL_IF(load_immediate(compiler, TMP_REG3, argw));
! 1566:
! 1567: compiler->cache_arg = SLJIT_IMM;
! 1568: compiler->cache_argw = argw;
! 1569:
! 1570: TEST_WRITE_BACK();
! 1571: EMIT_INSTRUCTION(EMIT_DATA_TRANSFER(inp_flags, 1, inp_flags & WRITE_BACK, reg, arg & 0xf, RM(TMP_REG3) | (max_delta & 0xf00 ? SRC2_IMM : 0)));
! 1572: return SLJIT_SUCCESS;
! 1573: }
! 1574:
! 1575: if (arg == next_arg && !(inp_flags & WRITE_BACK) && ((sljit_uw)argw - (sljit_uw)next_argw <= (sljit_uw)max_delta || (sljit_uw)next_argw - (sljit_uw)argw <= (sljit_uw)max_delta)) {
! 1576: SLJIT_ASSERT(inp_flags & LOAD_DATA);
! 1577: FAIL_IF(load_immediate(compiler, TMP_REG3, argw));
! 1578: EMIT_INSTRUCTION(EMIT_DATA_PROCESS_INS(ADD_DP, 0, TMP_REG3, TMP_REG3, reg_map[arg & 0xf]));
! 1579:
! 1580: compiler->cache_arg = arg;
! 1581: compiler->cache_argw = argw;
! 1582:
! 1583: GETPUT_ARG_DATA_TRANSFER(1, 0, reg, TMP_REG3, 0);
! 1584: return SLJIT_SUCCESS;
! 1585: }
! 1586:
! 1587: if ((arg & 0xf) == tmp_r) {
! 1588: compiler->cache_arg = SLJIT_IMM;
! 1589: compiler->cache_argw = argw;
! 1590: tmp_r = TMP_REG3;
! 1591: }
! 1592:
! 1593: FAIL_IF(load_immediate(compiler, tmp_r, argw));
! 1594: EMIT_INSTRUCTION(EMIT_DATA_TRANSFER(inp_flags, 1, inp_flags & WRITE_BACK, reg, arg & 0xf, reg_map[tmp_r] | (max_delta & 0xf00 ? SRC2_IMM : 0)));
! 1595: return SLJIT_SUCCESS;
! 1596: }
! 1597:
! 1598: static int emit_op(struct sljit_compiler *compiler, int op, int inp_flags,
! 1599: int dst, sljit_w dstw,
! 1600: int src1, sljit_w src1w,
! 1601: int src2, sljit_w src2w)
! 1602: {
! 1603: /* arg1 goes to TMP_REG1 or src reg
! 1604: arg2 goes to TMP_REG2, imm or src reg
! 1605: TMP_REG3 can be used for caching
! 1606: result goes to TMP_REG2, so put result can use TMP_REG1 and TMP_REG3. */
! 1607:
! 1608: /* We prefers register and simple consts. */
! 1609: int dst_r;
! 1610: int src1_r;
! 1611: int src2_r = 0;
! 1612: int sugg_src2_r = TMP_REG2;
! 1613: int flags = GET_FLAGS(op) ? SET_FLAGS : 0;
! 1614:
! 1615: compiler->cache_arg = 0;
! 1616: compiler->cache_argw = 0;
! 1617:
! 1618: /* Destination check. */
! 1619: if (dst >= SLJIT_TEMPORARY_REG1 && dst <= TMP_REG3) {
! 1620: dst_r = dst;
! 1621: flags |= REG_DEST;
! 1622: if (op >= SLJIT_MOV && op <= SLJIT_MOVU_SI)
! 1623: sugg_src2_r = dst_r;
! 1624: }
! 1625: else if (dst == SLJIT_UNUSED) {
! 1626: if (op >= SLJIT_MOV && op <= SLJIT_MOVU_SI && !(src2 & SLJIT_MEM))
! 1627: return SLJIT_SUCCESS;
! 1628: dst_r = TMP_REG2;
! 1629: }
! 1630: else {
! 1631: SLJIT_ASSERT(dst & SLJIT_MEM);
! 1632: if (getput_arg_fast(compiler, inp_flags | ARG_TEST, TMP_REG2, dst, dstw)) {
! 1633: flags |= FAST_DEST;
! 1634: dst_r = TMP_REG2;
! 1635: }
! 1636: else {
! 1637: flags |= SLOW_DEST;
! 1638: dst_r = 0;
! 1639: }
! 1640: }
! 1641:
! 1642: /* Source 1. */
! 1643: if (src1 >= SLJIT_TEMPORARY_REG1 && src1 <= TMP_REG3)
! 1644: src1_r = src1;
! 1645: else if (src2 >= SLJIT_TEMPORARY_REG1 && src2 <= TMP_REG3) {
! 1646: flags |= ARGS_SWAPPED;
! 1647: src1_r = src2;
! 1648: src2 = src1;
! 1649: src2w = src1w;
! 1650: }
! 1651: else {
! 1652: if ((inp_flags & ALLOW_ANY_IMM) && (src1 & SLJIT_IMM)) {
! 1653: /* The second check will generate a hit. */
! 1654: src2_r = get_immediate(src1w);
! 1655: if (src2_r) {
! 1656: flags |= ARGS_SWAPPED;
! 1657: src1 = src2;
! 1658: src1w = src2w;
! 1659: }
! 1660: if (inp_flags & ALLOW_INV_IMM) {
! 1661: src2_r = get_immediate(~src1w);
! 1662: if (src2_r) {
! 1663: flags |= ARGS_SWAPPED | INV_IMM;
! 1664: src1 = src2;
! 1665: src1w = src2w;
! 1666: }
! 1667: }
! 1668: }
! 1669:
! 1670: src1_r = 0;
! 1671: if (getput_arg_fast(compiler, inp_flags | LOAD_DATA, TMP_REG1, src1, src1w)) {
! 1672: FAIL_IF(compiler->error);
! 1673: src1_r = TMP_REG1;
! 1674: }
! 1675: }
! 1676:
! 1677: /* Source 2. */
! 1678: if (src2_r == 0) {
! 1679: if (src2 >= SLJIT_TEMPORARY_REG1 && src2 <= TMP_REG3) {
! 1680: src2_r = src2;
! 1681: flags |= REG_SOURCE;
! 1682: if (!(flags & REG_DEST) && op >= SLJIT_MOV && op <= SLJIT_MOVU_SI)
! 1683: dst_r = src2_r;
! 1684: }
! 1685: else do { /* do { } while(0) is used because of breaks. */
! 1686: if ((inp_flags & ALLOW_ANY_IMM) && (src2 & SLJIT_IMM)) {
! 1687: src2_r = get_immediate(src2w);
! 1688: if (src2_r)
! 1689: break;
! 1690: if (inp_flags & ALLOW_INV_IMM) {
! 1691: src2_r = get_immediate(~src2w);
! 1692: if (src2_r) {
! 1693: flags |= INV_IMM;
! 1694: break;
! 1695: }
! 1696: }
! 1697: }
! 1698:
! 1699: /* src2_r is 0. */
! 1700: if (getput_arg_fast(compiler, inp_flags | LOAD_DATA, sugg_src2_r, src2, src2w)) {
! 1701: FAIL_IF(compiler->error);
! 1702: src2_r = sugg_src2_r;
! 1703: }
! 1704: } while (0);
! 1705: }
! 1706:
! 1707: /* src1_r, src2_r and dst_r can be zero (=unprocessed) or non-zero.
! 1708: If they are zero, they must not be registers. */
! 1709: if (src1_r == 0 && src2_r == 0 && dst_r == 0) {
! 1710: if (!can_cache(src1, src1w, src2, src2w) && can_cache(src1, src1w, dst, dstw)) {
! 1711: SLJIT_ASSERT(!(flags & ARGS_SWAPPED));
! 1712: flags |= ARGS_SWAPPED;
! 1713: FAIL_IF(getput_arg(compiler, inp_flags | LOAD_DATA, TMP_REG1, src2, src2w, src1, src1w));
! 1714: FAIL_IF(getput_arg(compiler, inp_flags | LOAD_DATA, TMP_REG2, src1, src1w, dst, dstw));
! 1715: }
! 1716: else {
! 1717: FAIL_IF(getput_arg(compiler, inp_flags | LOAD_DATA, TMP_REG1, src1, src1w, src2, src2w));
! 1718: FAIL_IF(getput_arg(compiler, inp_flags | LOAD_DATA, TMP_REG2, src2, src2w, dst, dstw));
! 1719: }
! 1720: src1_r = TMP_REG1;
! 1721: src2_r = TMP_REG2;
! 1722: }
! 1723: else if (src1_r == 0 && src2_r == 0) {
! 1724: FAIL_IF(getput_arg(compiler, inp_flags | LOAD_DATA, TMP_REG1, src1, src1w, src2, src2w));
! 1725: src1_r = TMP_REG1;
! 1726: }
! 1727: else if (src1_r == 0 && dst_r == 0) {
! 1728: FAIL_IF(getput_arg(compiler, inp_flags | LOAD_DATA, TMP_REG1, src1, src1w, dst, dstw));
! 1729: src1_r = TMP_REG1;
! 1730: }
! 1731: else if (src2_r == 0 && dst_r == 0) {
! 1732: FAIL_IF(getput_arg(compiler, inp_flags | LOAD_DATA, sugg_src2_r, src2, src2w, dst, dstw));
! 1733: src2_r = sugg_src2_r;
! 1734: }
! 1735:
! 1736: if (dst_r == 0)
! 1737: dst_r = TMP_REG2;
! 1738:
! 1739: if (src1_r == 0) {
! 1740: FAIL_IF(getput_arg(compiler, inp_flags | LOAD_DATA, TMP_REG1, src1, src1w, 0, 0));
! 1741: src1_r = TMP_REG1;
! 1742: }
! 1743:
! 1744: if (src2_r == 0) {
! 1745: FAIL_IF(getput_arg(compiler, inp_flags | LOAD_DATA, sugg_src2_r, src2, src2w, 0, 0));
! 1746: src2_r = sugg_src2_r;
! 1747: }
! 1748:
! 1749: FAIL_IF(emit_single_op(compiler, op, flags, dst_r, src1_r, src2_r));
! 1750:
! 1751: if (flags & (FAST_DEST | SLOW_DEST)) {
! 1752: if (flags & FAST_DEST)
! 1753: FAIL_IF(getput_arg_fast(compiler, inp_flags, dst_r, dst, dstw));
! 1754: else
! 1755: FAIL_IF(getput_arg(compiler, inp_flags, dst_r, dst, dstw, 0, 0));
! 1756: }
! 1757: return SLJIT_SUCCESS;
! 1758: }
! 1759:
! 1760: #ifdef __cplusplus
! 1761: extern "C" {
! 1762: #endif
! 1763:
! 1764: #if defined(__GNUC__)
! 1765: extern unsigned int __aeabi_uidivmod(unsigned numerator, unsigned denominator);
! 1766: extern unsigned int __aeabi_idivmod(unsigned numerator, unsigned denominator);
! 1767: #else
! 1768: #error "Software divmod functions are needed"
! 1769: #endif
! 1770:
! 1771: #ifdef __cplusplus
! 1772: }
! 1773: #endif
! 1774:
! 1775: SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_op0(struct sljit_compiler *compiler, int op)
! 1776: {
! 1777: CHECK_ERROR();
! 1778: check_sljit_emit_op0(compiler, op);
! 1779:
! 1780: op = GET_OPCODE(op);
! 1781: switch (op) {
! 1782: case SLJIT_BREAKPOINT:
! 1783: EMIT_INSTRUCTION(BKPT);
! 1784: break;
! 1785: case SLJIT_NOP:
! 1786: EMIT_INSTRUCTION(NOP);
! 1787: break;
! 1788: case SLJIT_UMUL:
! 1789: case SLJIT_SMUL:
! 1790: #if (defined SLJIT_CONFIG_ARM_V7 && SLJIT_CONFIG_ARM_V7)
! 1791: return push_inst(compiler, (op == SLJIT_UMUL ? UMULL : SMULL)
! 1792: | (reg_map[SLJIT_TEMPORARY_REG2] << 16)
! 1793: | (reg_map[SLJIT_TEMPORARY_REG1] << 12)
! 1794: | (reg_map[SLJIT_TEMPORARY_REG1] << 8)
! 1795: | reg_map[SLJIT_TEMPORARY_REG2]);
! 1796: #else
! 1797: EMIT_INSTRUCTION(EMIT_DATA_PROCESS_INS(MOV_DP, 0, TMP_REG1, SLJIT_UNUSED, RM(SLJIT_TEMPORARY_REG2)));
! 1798: return push_inst(compiler, (op == SLJIT_UMUL ? UMULL : SMULL)
! 1799: | (reg_map[SLJIT_TEMPORARY_REG2] << 16)
! 1800: | (reg_map[SLJIT_TEMPORARY_REG1] << 12)
! 1801: | (reg_map[SLJIT_TEMPORARY_REG1] << 8)
! 1802: | reg_map[TMP_REG1]);
! 1803: #endif
! 1804: case SLJIT_UDIV:
! 1805: case SLJIT_SDIV:
! 1806: if (compiler->temporaries >= 3)
! 1807: EMIT_INSTRUCTION(0xe52d2008 /* str r2, [sp, #-8]! */);
! 1808: #if defined(__GNUC__)
! 1809: FAIL_IF(sljit_emit_ijump(compiler, SLJIT_FAST_CALL, SLJIT_IMM,
! 1810: (op == SLJIT_UDIV ? SLJIT_FUNC_OFFSET(__aeabi_uidivmod) : SLJIT_FUNC_OFFSET(__aeabi_idivmod))));
! 1811: #else
! 1812: #error "Software divmod functions are needed"
! 1813: #endif
! 1814: if (compiler->temporaries >= 3)
! 1815: return push_inst(compiler, 0xe49d2008 /* ldr r2, [sp], #8 */);
! 1816: return SLJIT_SUCCESS;
! 1817: }
! 1818:
! 1819: return SLJIT_SUCCESS;
! 1820: }
! 1821:
! 1822: SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_op1(struct sljit_compiler *compiler, int op,
! 1823: int dst, sljit_w dstw,
! 1824: int src, sljit_w srcw)
! 1825: {
! 1826: CHECK_ERROR();
! 1827: check_sljit_emit_op1(compiler, op, dst, dstw, src, srcw);
! 1828:
! 1829: switch (GET_OPCODE(op)) {
! 1830: case SLJIT_MOV:
! 1831: case SLJIT_MOV_UI:
! 1832: case SLJIT_MOV_SI:
! 1833: return emit_op(compiler, SLJIT_MOV, ALLOW_ANY_IMM, dst, dstw, TMP_REG1, 0, src, srcw);
! 1834:
! 1835: case SLJIT_MOV_UB:
! 1836: return emit_op(compiler, SLJIT_MOV_UB, ALLOW_ANY_IMM | BYTE_DATA, dst, dstw, TMP_REG1, 0, src, (src & SLJIT_IMM) ? (unsigned char)srcw : srcw);
! 1837:
! 1838: case SLJIT_MOV_SB:
! 1839: return emit_op(compiler, SLJIT_MOV_SB, ALLOW_ANY_IMM | SIGNED_DATA | BYTE_DATA, dst, dstw, TMP_REG1, 0, src, (src & SLJIT_IMM) ? (signed char)srcw : srcw);
! 1840:
! 1841: case SLJIT_MOV_UH:
! 1842: return emit_op(compiler, SLJIT_MOV_UH, ALLOW_ANY_IMM | HALF_DATA, dst, dstw, TMP_REG1, 0, src, (src & SLJIT_IMM) ? (unsigned short)srcw : srcw);
! 1843:
! 1844: case SLJIT_MOV_SH:
! 1845: return emit_op(compiler, SLJIT_MOV_SH, ALLOW_ANY_IMM | SIGNED_DATA | HALF_DATA, dst, dstw, TMP_REG1, 0, src, (src & SLJIT_IMM) ? (signed short)srcw : srcw);
! 1846:
! 1847: case SLJIT_MOVU:
! 1848: case SLJIT_MOVU_UI:
! 1849: case SLJIT_MOVU_SI:
! 1850: return emit_op(compiler, SLJIT_MOV, ALLOW_ANY_IMM | WRITE_BACK, dst, dstw, TMP_REG1, 0, src, srcw);
! 1851:
! 1852: case SLJIT_MOVU_UB:
! 1853: return emit_op(compiler, SLJIT_MOV_UB, ALLOW_ANY_IMM | BYTE_DATA | WRITE_BACK, dst, dstw, TMP_REG1, 0, src, (src & SLJIT_IMM) ? (unsigned char)srcw : srcw);
! 1854:
! 1855: case SLJIT_MOVU_SB:
! 1856: return emit_op(compiler, SLJIT_MOV_SB, ALLOW_ANY_IMM | SIGNED_DATA | BYTE_DATA | WRITE_BACK, dst, dstw, TMP_REG1, 0, src, (src & SLJIT_IMM) ? (signed char)srcw : srcw);
! 1857:
! 1858: case SLJIT_MOVU_UH:
! 1859: return emit_op(compiler, SLJIT_MOV_UH, ALLOW_ANY_IMM | HALF_DATA | WRITE_BACK, dst, dstw, TMP_REG1, 0, src, (src & SLJIT_IMM) ? (unsigned short)srcw : srcw);
! 1860:
! 1861: case SLJIT_MOVU_SH:
! 1862: return emit_op(compiler, SLJIT_MOV_SH, ALLOW_ANY_IMM | SIGNED_DATA | HALF_DATA | WRITE_BACK, dst, dstw, TMP_REG1, 0, src, (src & SLJIT_IMM) ? (signed short)srcw : srcw);
! 1863:
! 1864: case SLJIT_NOT:
! 1865: return emit_op(compiler, op, ALLOW_ANY_IMM, dst, dstw, TMP_REG1, 0, src, srcw);
! 1866:
! 1867: case SLJIT_NEG:
! 1868: #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) || (defined SLJIT_DEBUG && SLJIT_DEBUG)
! 1869: compiler->skip_checks = 1;
! 1870: #endif
! 1871: return sljit_emit_op2(compiler, SLJIT_SUB | GET_FLAGS(op), dst, dstw, SLJIT_IMM, 0, src, srcw);
! 1872:
! 1873: case SLJIT_CLZ:
! 1874: return emit_op(compiler, op, 0, dst, dstw, TMP_REG1, 0, src, srcw);
! 1875: }
! 1876:
! 1877: return SLJIT_SUCCESS;
! 1878: }
! 1879:
! 1880: SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_op2(struct sljit_compiler *compiler, int op,
! 1881: int dst, sljit_w dstw,
! 1882: int src1, sljit_w src1w,
! 1883: int src2, sljit_w src2w)
! 1884: {
! 1885: CHECK_ERROR();
! 1886: check_sljit_emit_op2(compiler, op, dst, dstw, src1, src1w, src2, src2w);
! 1887:
! 1888: switch (GET_OPCODE(op)) {
! 1889: case SLJIT_ADD:
! 1890: case SLJIT_ADDC:
! 1891: case SLJIT_SUB:
! 1892: case SLJIT_SUBC:
! 1893: case SLJIT_OR:
! 1894: case SLJIT_XOR:
! 1895: return emit_op(compiler, op, ALLOW_IMM, dst, dstw, src1, src1w, src2, src2w);
! 1896:
! 1897: case SLJIT_MUL:
! 1898: return emit_op(compiler, op, 0, dst, dstw, src1, src1w, src2, src2w);
! 1899:
! 1900: case SLJIT_AND:
! 1901: return emit_op(compiler, op, ALLOW_ANY_IMM, dst, dstw, src1, src1w, src2, src2w);
! 1902:
! 1903: case SLJIT_SHL:
! 1904: case SLJIT_LSHR:
! 1905: case SLJIT_ASHR:
! 1906: if (src2 & SLJIT_IMM) {
! 1907: compiler->shift_imm = src2w & 0x1f;
! 1908: return emit_op(compiler, op, 0, dst, dstw, TMP_REG1, 0, src1, src1w);
! 1909: }
! 1910: else {
! 1911: compiler->shift_imm = 0x20;
! 1912: return emit_op(compiler, op, 0, dst, dstw, src1, src1w, src2, src2w);
! 1913: }
! 1914: }
! 1915:
! 1916: return SLJIT_SUCCESS;
! 1917: }
! 1918:
! 1919: SLJIT_API_FUNC_ATTRIBUTE int sljit_get_register_index(int reg)
! 1920: {
! 1921: check_sljit_get_register_index(reg);
! 1922: return reg_map[reg];
! 1923: }
! 1924:
! 1925: SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_op_custom(struct sljit_compiler *compiler,
! 1926: void *instruction, int size)
! 1927: {
! 1928: CHECK_ERROR();
! 1929: check_sljit_emit_op_custom(compiler, instruction, size);
! 1930: SLJIT_ASSERT(size == 4);
! 1931:
! 1932: return push_inst(compiler, *(sljit_uw*)instruction);
! 1933: }
! 1934:
! 1935: /* --------------------------------------------------------------------- */
! 1936: /* Floating point operators */
! 1937: /* --------------------------------------------------------------------- */
! 1938:
! 1939: #if (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5)
! 1940:
! 1941: /* 0 - no fpu
! 1942: 1 - vfp */
! 1943: static int arm_fpu_type = -1;
! 1944:
! 1945: static void init_compiler()
! 1946: {
! 1947: if (arm_fpu_type != -1)
! 1948: return;
! 1949:
! 1950: /* TODO: Only the OS can help to determine the correct fpu type. */
! 1951: arm_fpu_type = 1;
! 1952: }
! 1953:
! 1954: SLJIT_API_FUNC_ATTRIBUTE int sljit_is_fpu_available(void)
! 1955: {
! 1956: if (arm_fpu_type == -1)
! 1957: init_compiler();
! 1958: return arm_fpu_type;
! 1959: }
! 1960:
! 1961: #else
! 1962:
! 1963: #define arm_fpu_type 1
! 1964:
! 1965: SLJIT_API_FUNC_ATTRIBUTE int sljit_is_fpu_available(void)
! 1966: {
! 1967: /* Always available. */
! 1968: return 1;
! 1969: }
! 1970:
! 1971: #endif
! 1972:
! 1973: #define EMIT_FPU_DATA_TRANSFER(add, load, base, freg, offs) \
! 1974: (VSTR | ((add) << 23) | ((load) << 20) | (reg_map[base] << 16) | (freg << 12) | (offs))
! 1975: #define EMIT_FPU_OPERATION(opcode, dst, src1, src2) \
! 1976: ((opcode) | ((dst) << 12) | (src1) | ((src2) << 16))
! 1977:
! 1978: static int emit_fpu_data_transfer(struct sljit_compiler *compiler, int fpu_reg, int load, int arg, sljit_w argw)
! 1979: {
! 1980: SLJIT_ASSERT(arg & SLJIT_MEM);
! 1981:
! 1982: /* Fast loads and stores. */
! 1983: if ((arg & 0xf) && !(arg & 0xf0) && (argw & 0x3) == 0) {
! 1984: if (argw >= 0 && argw <= 0x3ff) {
! 1985: EMIT_INSTRUCTION(EMIT_FPU_DATA_TRANSFER(1, load, arg & 0xf, fpu_reg, argw >> 2));
! 1986: return SLJIT_SUCCESS;
! 1987: }
! 1988: if (argw < 0 && argw >= -0x3ff) {
! 1989: EMIT_INSTRUCTION(EMIT_FPU_DATA_TRANSFER(0, load, arg & 0xf, fpu_reg, (-argw) >> 2));
! 1990: return SLJIT_SUCCESS;
! 1991: }
! 1992: if (argw >= 0 && argw <= 0x3ffff) {
! 1993: SLJIT_ASSERT(get_immediate(argw & 0x3fc00));
! 1994: EMIT_INSTRUCTION(EMIT_DATA_PROCESS_INS(ADD_DP, 0, TMP_REG1, arg & 0xf, get_immediate(argw & 0x3fc00)));
! 1995: argw &= 0x3ff;
! 1996: EMIT_INSTRUCTION(EMIT_FPU_DATA_TRANSFER(1, load, TMP_REG1, fpu_reg, argw >> 2));
! 1997: return SLJIT_SUCCESS;
! 1998: }
! 1999: if (argw < 0 && argw >= -0x3ffff) {
! 2000: argw = -argw;
! 2001: SLJIT_ASSERT(get_immediate(argw & 0x3fc00));
! 2002: EMIT_INSTRUCTION(EMIT_DATA_PROCESS_INS(SUB_DP, 0, TMP_REG1, arg & 0xf, get_immediate(argw & 0x3fc00)));
! 2003: argw &= 0x3ff;
! 2004: EMIT_INSTRUCTION(EMIT_FPU_DATA_TRANSFER(0, load, TMP_REG1, fpu_reg, argw >> 2));
! 2005: return SLJIT_SUCCESS;
! 2006: }
! 2007: }
! 2008:
! 2009: if (arg & 0xf0) {
! 2010: EMIT_INSTRUCTION(EMIT_DATA_PROCESS_INS(ADD_DP, 0, TMP_REG1, arg & 0xf, RM((arg >> 4) & 0xf) | ((argw & 0x3) << 7)));
! 2011: EMIT_INSTRUCTION(EMIT_FPU_DATA_TRANSFER(1, load, TMP_REG1, fpu_reg, 0));
! 2012: return SLJIT_SUCCESS;
! 2013: }
! 2014:
! 2015: if (compiler->cache_arg == arg && ((argw - compiler->cache_argw) & 0x3) == 0) {
! 2016: if (((sljit_uw)argw - (sljit_uw)compiler->cache_argw) <= 0x3ff) {
! 2017: EMIT_INSTRUCTION(EMIT_FPU_DATA_TRANSFER(1, load, TMP_REG3, fpu_reg, (argw - compiler->cache_argw) >> 2));
! 2018: return SLJIT_SUCCESS;
! 2019: }
! 2020: if (((sljit_uw)compiler->cache_argw - (sljit_uw)argw) <= 0x3ff) {
! 2021: EMIT_INSTRUCTION(EMIT_FPU_DATA_TRANSFER(0, load, TMP_REG3, fpu_reg, (compiler->cache_argw - argw) >> 2));
! 2022: return SLJIT_SUCCESS;
! 2023: }
! 2024: }
! 2025:
! 2026: compiler->cache_arg = arg;
! 2027: compiler->cache_argw = argw;
! 2028: if (arg & 0xf) {
! 2029: FAIL_IF(load_immediate(compiler, TMP_REG1, argw));
! 2030: EMIT_INSTRUCTION(EMIT_DATA_PROCESS_INS(ADD_DP, 0, TMP_REG3, arg & 0xf, reg_map[TMP_REG1]));
! 2031: }
! 2032: else
! 2033: FAIL_IF(load_immediate(compiler, TMP_REG3, argw));
! 2034:
! 2035: EMIT_INSTRUCTION(EMIT_FPU_DATA_TRANSFER(1, load, TMP_REG3, fpu_reg, 0));
! 2036: return SLJIT_SUCCESS;
! 2037: }
! 2038:
! 2039: SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_fop1(struct sljit_compiler *compiler, int op,
! 2040: int dst, sljit_w dstw,
! 2041: int src, sljit_w srcw)
! 2042: {
! 2043: int dst_freg;
! 2044:
! 2045: CHECK_ERROR();
! 2046: check_sljit_emit_fop1(compiler, op, dst, dstw, src, srcw);
! 2047:
! 2048: compiler->cache_arg = 0;
! 2049: compiler->cache_argw = 0;
! 2050:
! 2051: if (GET_OPCODE(op) == SLJIT_FCMP) {
! 2052: if (dst > SLJIT_FLOAT_REG4) {
! 2053: FAIL_IF(emit_fpu_data_transfer(compiler, TMP_FREG1, 1, dst, dstw));
! 2054: dst = TMP_FREG1;
! 2055: }
! 2056: if (src > SLJIT_FLOAT_REG4) {
! 2057: FAIL_IF(emit_fpu_data_transfer(compiler, TMP_FREG2, 1, src, srcw));
! 2058: src = TMP_FREG2;
! 2059: }
! 2060: EMIT_INSTRUCTION(VCMP_F64 | (dst << 12) | src);
! 2061: EMIT_INSTRUCTION(VMRS);
! 2062: return SLJIT_SUCCESS;
! 2063: }
! 2064:
! 2065: dst_freg = (dst > SLJIT_FLOAT_REG4) ? TMP_FREG1 : dst;
! 2066:
! 2067: if (src > SLJIT_FLOAT_REG4) {
! 2068: FAIL_IF(emit_fpu_data_transfer(compiler, dst_freg, 1, src, srcw));
! 2069: src = dst_freg;
! 2070: }
! 2071:
! 2072: switch (op) {
! 2073: case SLJIT_FMOV:
! 2074: if (src != dst_freg && dst_freg != TMP_FREG1)
! 2075: EMIT_INSTRUCTION(EMIT_FPU_OPERATION(VMOV_F64, dst_freg, src, 0));
! 2076: break;
! 2077: case SLJIT_FNEG:
! 2078: EMIT_INSTRUCTION(EMIT_FPU_OPERATION(VNEG_F64, dst_freg, src, 0));
! 2079: break;
! 2080: case SLJIT_FABS:
! 2081: EMIT_INSTRUCTION(EMIT_FPU_OPERATION(VABS_F64, dst_freg, src, 0));
! 2082: break;
! 2083: }
! 2084:
! 2085: if (dst_freg == TMP_FREG1)
! 2086: FAIL_IF(emit_fpu_data_transfer(compiler, src, 0, dst, dstw));
! 2087:
! 2088: return SLJIT_SUCCESS;
! 2089: }
! 2090:
! 2091: SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_fop2(struct sljit_compiler *compiler, int op,
! 2092: int dst, sljit_w dstw,
! 2093: int src1, sljit_w src1w,
! 2094: int src2, sljit_w src2w)
! 2095: {
! 2096: int dst_freg;
! 2097:
! 2098: CHECK_ERROR();
! 2099: check_sljit_emit_fop2(compiler, op, dst, dstw, src1, src1w, src2, src2w);
! 2100:
! 2101: compiler->cache_arg = 0;
! 2102: compiler->cache_argw = 0;
! 2103:
! 2104: dst_freg = (dst > SLJIT_FLOAT_REG4) ? TMP_FREG1 : dst;
! 2105:
! 2106: if (src2 > SLJIT_FLOAT_REG4) {
! 2107: FAIL_IF(emit_fpu_data_transfer(compiler, TMP_FREG2, 1, src2, src2w));
! 2108: src2 = TMP_FREG2;
! 2109: }
! 2110:
! 2111: if (src1 > SLJIT_FLOAT_REG4) {
! 2112: FAIL_IF(emit_fpu_data_transfer(compiler, TMP_FREG1, 1, src1, src1w));
! 2113: src1 = TMP_FREG1;
! 2114: }
! 2115:
! 2116: switch (op) {
! 2117: case SLJIT_FADD:
! 2118: EMIT_INSTRUCTION(EMIT_FPU_OPERATION(VADD_F64, dst_freg, src2, src1));
! 2119: break;
! 2120:
! 2121: case SLJIT_FSUB:
! 2122: EMIT_INSTRUCTION(EMIT_FPU_OPERATION(VSUB_F64, dst_freg, src2, src1));
! 2123: break;
! 2124:
! 2125: case SLJIT_FMUL:
! 2126: EMIT_INSTRUCTION(EMIT_FPU_OPERATION(VMUL_F64, dst_freg, src2, src1));
! 2127: break;
! 2128:
! 2129: case SLJIT_FDIV:
! 2130: EMIT_INSTRUCTION(EMIT_FPU_OPERATION(VDIV_F64, dst_freg, src2, src1));
! 2131: break;
! 2132: }
! 2133:
! 2134: if (dst_freg == TMP_FREG1)
! 2135: FAIL_IF(emit_fpu_data_transfer(compiler, TMP_FREG1, 0, dst, dstw));
! 2136:
! 2137: return SLJIT_SUCCESS;
! 2138: }
! 2139:
! 2140: /* --------------------------------------------------------------------- */
! 2141: /* Other instructions */
! 2142: /* --------------------------------------------------------------------- */
! 2143:
! 2144: SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_fast_enter(struct sljit_compiler *compiler, int dst, sljit_w dstw, int args, int temporaries, int saveds, int local_size)
! 2145: {
! 2146: int size;
! 2147:
! 2148: CHECK_ERROR();
! 2149: check_sljit_emit_fast_enter(compiler, dst, dstw, args, temporaries, saveds, local_size);
! 2150:
! 2151: compiler->temporaries = temporaries;
! 2152: compiler->saveds = saveds;
! 2153:
! 2154: size = (1 + saveds) * sizeof(sljit_uw);
! 2155: if (temporaries >= 4)
! 2156: size += (temporaries - 3) * sizeof(sljit_uw);
! 2157: local_size += size;
! 2158: local_size = (local_size + 7) & ~7;
! 2159: local_size -= size;
! 2160: compiler->local_size = local_size;
! 2161:
! 2162: if (dst >= SLJIT_TEMPORARY_REG1 && dst <= SLJIT_NO_REGISTERS)
! 2163: return push_inst(compiler, EMIT_DATA_PROCESS_INS(MOV_DP, 0, dst, SLJIT_UNUSED, RM(TMP_REG3)));
! 2164: else if (dst & SLJIT_MEM) {
! 2165: if (getput_arg_fast(compiler, WORD_DATA, TMP_REG3, dst, dstw))
! 2166: return compiler->error;
! 2167: EMIT_INSTRUCTION(EMIT_DATA_PROCESS_INS(MOV_DP, 0, TMP_REG2, SLJIT_UNUSED, RM(TMP_REG3)));
! 2168: compiler->cache_arg = 0;
! 2169: compiler->cache_argw = 0;
! 2170: return getput_arg(compiler, WORD_DATA, TMP_REG2, dst, dstw, 0, 0);
! 2171: }
! 2172:
! 2173: return SLJIT_SUCCESS;
! 2174: }
! 2175:
! 2176: SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_fast_return(struct sljit_compiler *compiler, int src, sljit_w srcw)
! 2177: {
! 2178: CHECK_ERROR();
! 2179: check_sljit_emit_fast_return(compiler, src, srcw);
! 2180:
! 2181: if (src >= SLJIT_TEMPORARY_REG1 && src <= SLJIT_NO_REGISTERS)
! 2182: EMIT_INSTRUCTION(EMIT_DATA_PROCESS_INS(MOV_DP, 0, TMP_REG3, SLJIT_UNUSED, RM(src)));
! 2183: else if (src & SLJIT_MEM) {
! 2184: if (getput_arg_fast(compiler, WORD_DATA | LOAD_DATA, TMP_REG3, src, srcw))
! 2185: FAIL_IF(compiler->error);
! 2186: else {
! 2187: compiler->cache_arg = 0;
! 2188: compiler->cache_argw = 0;
! 2189: FAIL_IF(getput_arg(compiler, WORD_DATA | LOAD_DATA, TMP_REG2, src, srcw, 0, 0));
! 2190: EMIT_INSTRUCTION(EMIT_DATA_PROCESS_INS(MOV_DP, 0, TMP_REG3, SLJIT_UNUSED, RM(TMP_REG2)));
! 2191: }
! 2192: }
! 2193: else if (src & SLJIT_IMM)
! 2194: FAIL_IF(load_immediate(compiler, TMP_REG3, srcw));
! 2195: return push_inst(compiler, BLX | RM(TMP_REG3));
! 2196: }
! 2197:
! 2198: /* --------------------------------------------------------------------- */
! 2199: /* Conditional instructions */
! 2200: /* --------------------------------------------------------------------- */
! 2201:
! 2202: static sljit_uw get_cc(int type)
! 2203: {
! 2204: switch (type) {
! 2205: case SLJIT_C_EQUAL:
! 2206: case SLJIT_C_MUL_NOT_OVERFLOW:
! 2207: case SLJIT_C_FLOAT_EQUAL:
! 2208: return 0x00000000;
! 2209:
! 2210: case SLJIT_C_NOT_EQUAL:
! 2211: case SLJIT_C_MUL_OVERFLOW:
! 2212: case SLJIT_C_FLOAT_NOT_EQUAL:
! 2213: return 0x10000000;
! 2214:
! 2215: case SLJIT_C_LESS:
! 2216: case SLJIT_C_FLOAT_LESS:
! 2217: return 0x30000000;
! 2218:
! 2219: case SLJIT_C_GREATER_EQUAL:
! 2220: case SLJIT_C_FLOAT_GREATER_EQUAL:
! 2221: return 0x20000000;
! 2222:
! 2223: case SLJIT_C_GREATER:
! 2224: case SLJIT_C_FLOAT_GREATER:
! 2225: return 0x80000000;
! 2226:
! 2227: case SLJIT_C_LESS_EQUAL:
! 2228: case SLJIT_C_FLOAT_LESS_EQUAL:
! 2229: return 0x90000000;
! 2230:
! 2231: case SLJIT_C_SIG_LESS:
! 2232: return 0xb0000000;
! 2233:
! 2234: case SLJIT_C_SIG_GREATER_EQUAL:
! 2235: return 0xa0000000;
! 2236:
! 2237: case SLJIT_C_SIG_GREATER:
! 2238: return 0xc0000000;
! 2239:
! 2240: case SLJIT_C_SIG_LESS_EQUAL:
! 2241: return 0xd0000000;
! 2242:
! 2243: case SLJIT_C_OVERFLOW:
! 2244: case SLJIT_C_FLOAT_NAN:
! 2245: return 0x60000000;
! 2246:
! 2247: case SLJIT_C_NOT_OVERFLOW:
! 2248: case SLJIT_C_FLOAT_NOT_NAN:
! 2249: return 0x70000000;
! 2250:
! 2251: default: /* SLJIT_JUMP */
! 2252: return 0xe0000000;
! 2253: }
! 2254: }
! 2255:
! 2256: SLJIT_API_FUNC_ATTRIBUTE struct sljit_label* sljit_emit_label(struct sljit_compiler *compiler)
! 2257: {
! 2258: struct sljit_label *label;
! 2259:
! 2260: CHECK_ERROR_PTR();
! 2261: check_sljit_emit_label(compiler);
! 2262:
! 2263: if (compiler->last_label && compiler->last_label->size == compiler->size)
! 2264: return compiler->last_label;
! 2265:
! 2266: label = (struct sljit_label*)ensure_abuf(compiler, sizeof(struct sljit_label));
! 2267: PTR_FAIL_IF(!label);
! 2268: set_label(label, compiler);
! 2269: return label;
! 2270: }
! 2271:
! 2272: SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_jump(struct sljit_compiler *compiler, int type)
! 2273: {
! 2274: struct sljit_jump *jump;
! 2275:
! 2276: CHECK_ERROR_PTR();
! 2277: check_sljit_emit_jump(compiler, type);
! 2278:
! 2279: jump = (struct sljit_jump*)ensure_abuf(compiler, sizeof(struct sljit_jump));
! 2280: PTR_FAIL_IF(!jump);
! 2281: set_jump(jump, compiler, type & SLJIT_REWRITABLE_JUMP);
! 2282: type &= 0xff;
! 2283:
! 2284: /* In ARM, we don't need to touch the arguments. */
! 2285: #if (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5)
! 2286: if (type >= SLJIT_FAST_CALL)
! 2287: PTR_FAIL_IF(prepare_blx(compiler));
! 2288: PTR_FAIL_IF(push_inst_with_unique_literal(compiler, ((EMIT_DATA_TRANSFER(WORD_DATA | LOAD_DATA, 1, 0,
! 2289: type <= SLJIT_JUMP ? TMP_PC : TMP_REG1, TMP_PC, 0)) & ~COND_MASK) | get_cc(type), 0));
! 2290:
! 2291: if (jump->flags & SLJIT_REWRITABLE_JUMP) {
! 2292: jump->addr = compiler->size;
! 2293: compiler->patches++;
! 2294: }
! 2295:
! 2296: if (type >= SLJIT_FAST_CALL) {
! 2297: jump->flags |= IS_BL;
! 2298: PTR_FAIL_IF(emit_blx(compiler));
! 2299: }
! 2300:
! 2301: if (!(jump->flags & SLJIT_REWRITABLE_JUMP))
! 2302: jump->addr = compiler->size;
! 2303: #else
! 2304: if (type >= SLJIT_FAST_CALL)
! 2305: jump->flags |= IS_BL;
! 2306: PTR_FAIL_IF(emit_imm(compiler, TMP_REG1, 0));
! 2307: PTR_FAIL_IF(push_inst(compiler, (((type <= SLJIT_JUMP ? BX : BLX) | RM(TMP_REG1)) & ~COND_MASK) | get_cc(type)));
! 2308: jump->addr = compiler->size;
! 2309: #endif
! 2310: return jump;
! 2311: }
! 2312:
! 2313: SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ijump(struct sljit_compiler *compiler, int type, int src, sljit_w srcw)
! 2314: {
! 2315: struct sljit_jump *jump;
! 2316:
! 2317: CHECK_ERROR();
! 2318: check_sljit_emit_ijump(compiler, type, src, srcw);
! 2319:
! 2320: /* In ARM, we don't need to touch the arguments. */
! 2321: if (src & SLJIT_IMM) {
! 2322: jump = (struct sljit_jump*)ensure_abuf(compiler, sizeof(struct sljit_jump));
! 2323: FAIL_IF(!jump);
! 2324: set_jump(jump, compiler, JUMP_ADDR | ((type >= SLJIT_FAST_CALL) ? IS_BL : 0));
! 2325: jump->u.target = srcw;
! 2326:
! 2327: #if (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5)
! 2328: if (type >= SLJIT_FAST_CALL)
! 2329: FAIL_IF(prepare_blx(compiler));
! 2330: FAIL_IF(push_inst_with_unique_literal(compiler, EMIT_DATA_TRANSFER(WORD_DATA | LOAD_DATA, 1, 0, type <= SLJIT_JUMP ? TMP_PC : TMP_REG1, TMP_PC, 0), 0));
! 2331: if (type >= SLJIT_FAST_CALL)
! 2332: FAIL_IF(emit_blx(compiler));
! 2333: #else
! 2334: FAIL_IF(emit_imm(compiler, TMP_REG1, 0));
! 2335: FAIL_IF(push_inst(compiler, (type <= SLJIT_JUMP ? BX : BLX) | RM(TMP_REG1)));
! 2336: #endif
! 2337: jump->addr = compiler->size;
! 2338: }
! 2339: else {
! 2340: if (src >= SLJIT_TEMPORARY_REG1 && src <= SLJIT_NO_REGISTERS)
! 2341: return push_inst(compiler, (type <= SLJIT_JUMP ? BX : BLX) | RM(src));
! 2342:
! 2343: SLJIT_ASSERT(src & SLJIT_MEM);
! 2344: FAIL_IF(emit_op(compiler, SLJIT_MOV, ALLOW_ANY_IMM, TMP_REG2, 0, TMP_REG1, 0, src, srcw));
! 2345: return push_inst(compiler, (type <= SLJIT_JUMP ? BX : BLX) | RM(TMP_REG2));
! 2346: }
! 2347:
! 2348: return SLJIT_SUCCESS;
! 2349: }
! 2350:
! 2351: SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_cond_value(struct sljit_compiler *compiler, int op, int dst, sljit_w dstw, int type)
! 2352: {
! 2353: int reg;
! 2354: sljit_uw cc;
! 2355:
! 2356: CHECK_ERROR();
! 2357: check_sljit_emit_cond_value(compiler, op, dst, dstw, type);
! 2358:
! 2359: if (dst == SLJIT_UNUSED)
! 2360: return SLJIT_SUCCESS;
! 2361:
! 2362: cc = get_cc(type);
! 2363: if (GET_OPCODE(op) == SLJIT_OR) {
! 2364: if (dst >= SLJIT_TEMPORARY_REG1 && dst <= SLJIT_NO_REGISTERS) {
! 2365: EMIT_INSTRUCTION((EMIT_DATA_PROCESS_INS(ORR_DP, 0, dst, dst, SRC2_IMM | 1) & ~COND_MASK) | cc);
! 2366: if (op & SLJIT_SET_E)
! 2367: return push_inst(compiler, EMIT_DATA_PROCESS_INS(MOV_DP, SET_FLAGS, TMP_REG1, SLJIT_UNUSED, RM(dst)));
! 2368: return SLJIT_SUCCESS;
! 2369: }
! 2370:
! 2371: EMIT_INSTRUCTION(EMIT_DATA_PROCESS_INS(MOV_DP, 0, TMP_REG1, SLJIT_UNUSED, SRC2_IMM | 0));
! 2372: EMIT_INSTRUCTION((EMIT_DATA_PROCESS_INS(MOV_DP, 0, TMP_REG1, SLJIT_UNUSED, SRC2_IMM | 1) & ~COND_MASK) | cc);
! 2373: #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) || (defined SLJIT_DEBUG && SLJIT_DEBUG)
! 2374: compiler->skip_checks = 1;
! 2375: #endif
! 2376: return emit_op(compiler, op, ALLOW_IMM, dst, dstw, TMP_REG1, 0, dst, dstw);
! 2377: }
! 2378:
! 2379: reg = (dst >= SLJIT_TEMPORARY_REG1 && dst <= SLJIT_NO_REGISTERS) ? dst : TMP_REG2;
! 2380:
! 2381: EMIT_INSTRUCTION(EMIT_DATA_PROCESS_INS(MOV_DP, 0, reg, SLJIT_UNUSED, SRC2_IMM | 0));
! 2382: EMIT_INSTRUCTION((EMIT_DATA_PROCESS_INS(MOV_DP, 0, reg, SLJIT_UNUSED, SRC2_IMM | 1) & ~COND_MASK) | cc);
! 2383:
! 2384: if (reg == TMP_REG2)
! 2385: return emit_op(compiler, SLJIT_MOV, ALLOW_ANY_IMM, dst, dstw, TMP_REG1, 0, TMP_REG2, 0);
! 2386: return SLJIT_SUCCESS;
! 2387: }
! 2388:
! 2389: SLJIT_API_FUNC_ATTRIBUTE struct sljit_const* sljit_emit_const(struct sljit_compiler *compiler, int dst, sljit_w dstw, sljit_w init_value)
! 2390: {
! 2391: struct sljit_const *const_;
! 2392: int reg;
! 2393:
! 2394: CHECK_ERROR_PTR();
! 2395: check_sljit_emit_const(compiler, dst, dstw, init_value);
! 2396:
! 2397: const_ = (struct sljit_const*)ensure_abuf(compiler, sizeof(struct sljit_const));
! 2398: PTR_FAIL_IF(!const_);
! 2399:
! 2400: reg = (dst >= SLJIT_TEMPORARY_REG1 && dst <= SLJIT_NO_REGISTERS) ? dst : TMP_REG2;
! 2401:
! 2402: #if (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5)
! 2403: PTR_FAIL_IF(push_inst_with_unique_literal(compiler, EMIT_DATA_TRANSFER(WORD_DATA | LOAD_DATA, 1, 0, reg, TMP_PC, 0), init_value));
! 2404: compiler->patches++;
! 2405: #else
! 2406: PTR_FAIL_IF(emit_imm(compiler, reg, init_value));
! 2407: #endif
! 2408: set_const(const_, compiler);
! 2409:
! 2410: if (reg == TMP_REG2 && dst != SLJIT_UNUSED)
! 2411: if (emit_op(compiler, SLJIT_MOV, ALLOW_ANY_IMM, dst, dstw, TMP_REG1, 0, TMP_REG2, 0))
! 2412: return NULL;
! 2413: return const_;
! 2414: }
! 2415:
! 2416: SLJIT_API_FUNC_ATTRIBUTE void sljit_set_jump_addr(sljit_uw addr, sljit_uw new_addr)
! 2417: {
! 2418: inline_set_jump_addr(addr, new_addr, 1);
! 2419: }
! 2420:
! 2421: SLJIT_API_FUNC_ATTRIBUTE void sljit_set_const(sljit_uw addr, sljit_w new_constant)
! 2422: {
! 2423: inline_set_const(addr, new_constant, 1);
! 2424: }
E-mail:
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sljitNativeARM_v5.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [parser3project] / win32 / pcre / sljit