/[pcre]/code/trunk/sljit/sljitNativeARM_v5.c
ViewVC logotype

Diff of /code/trunk/sljit/sljitNativeARM_v5.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1214 by zherczeg, Wed Nov 7 07:25:07 2012 UTC revision 1215 by zherczeg, Fri Nov 9 08:13:13 2012 UTC
# Line 824  static sljit_si emit_op(struct sljit_com Line 824  static sljit_si emit_op(struct sljit_com
824          sljit_si src1, sljit_sw src1w,          sljit_si src1, sljit_sw src1w,
825          sljit_si src2, sljit_sw src2w);          sljit_si src2, sljit_sw src2w);
826    
827  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_enter(struct sljit_compiler *compiler, sljit_si args, sljit_si temporaries, sljit_si saveds, sljit_si local_size)  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_enter(struct sljit_compiler *compiler, sljit_si args, sljit_si scratches, sljit_si saveds, sljit_si local_size)
828  {  {
829          sljit_si size;          sljit_si size;
830          sljit_uw push;          sljit_uw push;
831    
832          CHECK_ERROR();          CHECK_ERROR();
833          check_sljit_emit_enter(compiler, args, temporaries, saveds, local_size);          check_sljit_emit_enter(compiler, args, scratches, saveds, local_size);
834    
835          compiler->temporaries = temporaries;          compiler->scratches = scratches;
836          compiler->saveds = saveds;          compiler->saveds = saveds;
837  #if (defined SLJIT_DEBUG && SLJIT_DEBUG)  #if (defined SLJIT_DEBUG && SLJIT_DEBUG)
838          compiler->logical_local_size = local_size;          compiler->logical_local_size = local_size;
# Line 841  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_ Line 841  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_
841          /* Push saved registers, temporary registers          /* Push saved registers, temporary registers
842             stmdb sp!, {..., lr} */             stmdb sp!, {..., lr} */
843          push = PUSH | (1 << 14);          push = PUSH | (1 << 14);
844          if (temporaries >= 5)          if (scratches >= 5)
845                  push |= 1 << 11;                  push |= 1 << 11;
846          if (temporaries >= 4)          if (scratches >= 4)
847                  push |= 1 << 10;                  push |= 1 << 10;
848          if (saveds >= 5)          if (saveds >= 5)
849                  push |= 1 << 8;                  push |= 1 << 8;
# Line 859  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_ Line 859  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_
859    
860          /* Stack must be aligned to 8 bytes: */          /* Stack must be aligned to 8 bytes: */
861          size = (1 + saveds) * sizeof(sljit_uw);          size = (1 + saveds) * sizeof(sljit_uw);
862          if (temporaries >= 4)          if (scratches >= 4)
863                  size += (temporaries - 3) * sizeof(sljit_uw);                  size += (scratches - 3) * sizeof(sljit_uw);
864          local_size += size;          local_size += size;
865          local_size = (local_size + 7) & ~7;          local_size = (local_size + 7) & ~7;
866          local_size -= size;          local_size -= size;
# Line 869  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_ Line 869  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_
869                  FAIL_IF(emit_op(compiler, SLJIT_SUB, ALLOW_IMM, SLJIT_LOCALS_REG, 0, SLJIT_LOCALS_REG, 0, SLJIT_IMM, local_size));                  FAIL_IF(emit_op(compiler, SLJIT_SUB, ALLOW_IMM, SLJIT_LOCALS_REG, 0, SLJIT_LOCALS_REG, 0, SLJIT_IMM, local_size));
870    
871          if (args >= 1)          if (args >= 1)
872                  EMIT_INSTRUCTION(EMIT_DATA_PROCESS_INS(MOV_DP, 0, SLJIT_SAVED_REG1, SLJIT_UNUSED, RM(SLJIT_TEMPORARY_REG1)));                  EMIT_INSTRUCTION(EMIT_DATA_PROCESS_INS(MOV_DP, 0, SLJIT_SAVED_REG1, SLJIT_UNUSED, RM(SLJIT_SCRATCH_REG1)));
873          if (args >= 2)          if (args >= 2)
874                  EMIT_INSTRUCTION(EMIT_DATA_PROCESS_INS(MOV_DP, 0, SLJIT_SAVED_REG2, SLJIT_UNUSED, RM(SLJIT_TEMPORARY_REG2)));                  EMIT_INSTRUCTION(EMIT_DATA_PROCESS_INS(MOV_DP, 0, SLJIT_SAVED_REG2, SLJIT_UNUSED, RM(SLJIT_SCRATCH_REG2)));
875          if (args >= 3)          if (args >= 3)
876                  EMIT_INSTRUCTION(EMIT_DATA_PROCESS_INS(MOV_DP, 0, SLJIT_SAVED_REG3, SLJIT_UNUSED, RM(SLJIT_TEMPORARY_REG3)));                  EMIT_INSTRUCTION(EMIT_DATA_PROCESS_INS(MOV_DP, 0, SLJIT_SAVED_REG3, SLJIT_UNUSED, RM(SLJIT_SCRATCH_REG3)));
877    
878          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
879  }  }
880    
881  SLJIT_API_FUNC_ATTRIBUTE void sljit_set_context(struct sljit_compiler *compiler, sljit_si args, sljit_si temporaries, sljit_si saveds, sljit_si local_size)  SLJIT_API_FUNC_ATTRIBUTE void sljit_set_context(struct sljit_compiler *compiler, sljit_si args, sljit_si scratches, sljit_si saveds, sljit_si local_size)
882  {  {
883          sljit_si size;          sljit_si size;
884    
885          CHECK_ERROR_VOID();          CHECK_ERROR_VOID();
886          check_sljit_set_context(compiler, args, temporaries, saveds, local_size);          check_sljit_set_context(compiler, args, scratches, saveds, local_size);
887    
888          compiler->temporaries = temporaries;          compiler->scratches = scratches;
889          compiler->saveds = saveds;          compiler->saveds = saveds;
890  #if (defined SLJIT_DEBUG && SLJIT_DEBUG)  #if (defined SLJIT_DEBUG && SLJIT_DEBUG)
891          compiler->logical_local_size = local_size;          compiler->logical_local_size = local_size;
892  #endif  #endif
893    
894          size = (1 + saveds) * sizeof(sljit_uw);          size = (1 + saveds) * sizeof(sljit_uw);
895          if (temporaries >= 4)          if (scratches >= 4)
896                  size += (temporaries - 3) * sizeof(sljit_uw);                  size += (scratches - 3) * sizeof(sljit_uw);
897          local_size += size;          local_size += size;
898          local_size = (local_size + 7) & ~7;          local_size = (local_size + 7) & ~7;
899          local_size -= size;          local_size -= size;
# Line 915  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_ Line 915  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_
915          pop = POP | (1 << 15);          pop = POP | (1 << 15);
916          /* Push saved registers, temporary registers          /* Push saved registers, temporary registers
917             ldmia sp!, {..., pc} */             ldmia sp!, {..., pc} */
918          if (compiler->temporaries >= 5)          if (compiler->scratches >= 5)
919                  pop |= 1 << 11;                  pop |= 1 << 11;
920          if (compiler->temporaries >= 4)          if (compiler->scratches >= 4)
921                  pop |= 1 << 10;                  pop |= 1 << 10;
922          if (compiler->saveds >= 5)          if (compiler->saveds >= 5)
923                  pop |= 1 << 8;                  pop |= 1 << 8;
# Line 1613  static sljit_si getput_arg(struct sljit_ Line 1613  static sljit_si getput_arg(struct sljit_
1613          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
1614  }  }
1615    
1616    static SLJIT_INLINE sljit_si emit_op_mem(struct sljit_compiler *compiler, sljit_si flags, sljit_si reg, sljit_si arg, sljit_sw argw)
1617    {
1618            if (getput_arg_fast(compiler, flags, reg, arg, argw))
1619                    return compiler->error;
1620            compiler->cache_arg = 0;
1621            compiler->cache_argw = 0;
1622            return getput_arg(compiler, flags, reg, arg, argw, 0, 0);
1623    }
1624    
1625    static SLJIT_INLINE sljit_si emit_op_mem2(struct sljit_compiler *compiler, sljit_si flags, sljit_si reg, sljit_si arg1, sljit_sw arg1w, sljit_si arg2, sljit_sw arg2w)
1626    {
1627            if (getput_arg_fast(compiler, flags, reg, arg1, arg1w))
1628                    return compiler->error;
1629            return getput_arg(compiler, flags, reg, arg1, arg1w, arg2, arg2w);
1630    }
1631    
1632  static sljit_si emit_op(struct sljit_compiler *compiler, sljit_si op, sljit_si inp_flags,  static sljit_si emit_op(struct sljit_compiler *compiler, sljit_si op, sljit_si inp_flags,
1633          sljit_si dst, sljit_sw dstw,          sljit_si dst, sljit_sw dstw,
1634          sljit_si src1, sljit_sw src1w,          sljit_si src1, sljit_sw src1w,
# Line 1634  static sljit_si emit_op(struct sljit_com Line 1650  static sljit_si emit_op(struct sljit_com
1650          compiler->cache_argw = 0;          compiler->cache_argw = 0;
1651    
1652          /* Destination check. */          /* Destination check. */
1653          if (dst >= SLJIT_TEMPORARY_REG1 && dst <= TMP_REG3) {          if (SLJIT_UNLIKELY(dst == SLJIT_UNUSED)) {
1654                    if (op >= SLJIT_MOV && op <= SLJIT_MOVU_SI && !(src2 & SLJIT_MEM))
1655                            return SLJIT_SUCCESS;
1656                    dst_r = TMP_REG2;
1657            }
1658            else if (dst <= TMP_REG3) {
1659                  dst_r = dst;                  dst_r = dst;
1660                  flags |= REG_DEST;                  flags |= REG_DEST;
1661                  if (op >= SLJIT_MOV && op <= SLJIT_MOVU_SI)                  if (op >= SLJIT_MOV && op <= SLJIT_MOVU_SI)
1662                          sugg_src2_r = dst_r;                          sugg_src2_r = dst_r;
1663          }          }
         else if (dst == SLJIT_UNUSED) {  
                 if (op >= SLJIT_MOV && op <= SLJIT_MOVU_SI && !(src2 & SLJIT_MEM))  
                         return SLJIT_SUCCESS;  
                 dst_r = TMP_REG2;  
         }  
1664          else {          else {
1665                  SLJIT_ASSERT(dst & SLJIT_MEM);                  SLJIT_ASSERT(dst & SLJIT_MEM);
1666                  if (getput_arg_fast(compiler, inp_flags | ARG_TEST, TMP_REG2, dst, dstw)) {                  if (getput_arg_fast(compiler, inp_flags | ARG_TEST, TMP_REG2, dst, dstw)) {
# Line 1658  static sljit_si emit_op(struct sljit_com Line 1674  static sljit_si emit_op(struct sljit_com
1674          }          }
1675    
1676          /* Source 1. */          /* Source 1. */
1677          if (src1 >= SLJIT_TEMPORARY_REG1 && src1 <= TMP_REG3)          if (src1 <= TMP_REG3)
1678                  src1_r = src1;                  src1_r = src1;
1679          else if (src2 >= SLJIT_TEMPORARY_REG1 && src2 <= TMP_REG3) {          else if (src2 <= TMP_REG3) {
1680                  flags |= ARGS_SWAPPED;                  flags |= ARGS_SWAPPED;
1681                  src1_r = src2;                  src1_r = src2;
1682                  src2 = src1;                  src2 = src1;
# Line 1706  static sljit_si emit_op(struct sljit_com Line 1722  static sljit_si emit_op(struct sljit_com
1722    
1723          /* Source 2. */          /* Source 2. */
1724          if (src2_r == 0) {          if (src2_r == 0) {
1725                  if (src2 >= SLJIT_TEMPORARY_REG1 && src2 <= TMP_REG3) {                  if (src2 <= TMP_REG3) {
1726                          src2_r = src2;                          src2_r = src2;
1727                          flags |= REG_SOURCE;                          flags |= REG_SOURCE;
1728                          if (!(flags & REG_DEST) && op >= SLJIT_MOV && op <= SLJIT_MOVU_SI)                          if (!(flags & REG_DEST) && op >= SLJIT_MOV && op <= SLJIT_MOVU_SI)
# Line 1835  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_ Line 1851  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_
1851          case SLJIT_SMUL:          case SLJIT_SMUL:
1852  #if (defined SLJIT_CONFIG_ARM_V7 && SLJIT_CONFIG_ARM_V7)  #if (defined SLJIT_CONFIG_ARM_V7 && SLJIT_CONFIG_ARM_V7)
1853                  return push_inst(compiler, (op == SLJIT_UMUL ? UMULL : SMULL)                  return push_inst(compiler, (op == SLJIT_UMUL ? UMULL : SMULL)
1854                          | (reg_map[SLJIT_TEMPORARY_REG2] << 16)                          | (reg_map[SLJIT_SCRATCH_REG2] << 16)
1855                          | (reg_map[SLJIT_TEMPORARY_REG1] << 12)                          | (reg_map[SLJIT_SCRATCH_REG1] << 12)
1856                          | (reg_map[SLJIT_TEMPORARY_REG1] << 8)                          | (reg_map[SLJIT_SCRATCH_REG1] << 8)
1857                          | reg_map[SLJIT_TEMPORARY_REG2]);                          | reg_map[SLJIT_SCRATCH_REG2]);
1858  #else  #else
1859                  EMIT_INSTRUCTION(EMIT_DATA_PROCESS_INS(MOV_DP, 0, TMP_REG1, SLJIT_UNUSED, RM(SLJIT_TEMPORARY_REG2)));                  EMIT_INSTRUCTION(EMIT_DATA_PROCESS_INS(MOV_DP, 0, TMP_REG1, SLJIT_UNUSED, RM(SLJIT_SCRATCH_REG2)));
1860                  return push_inst(compiler, (op == SLJIT_UMUL ? UMULL : SMULL)                  return push_inst(compiler, (op == SLJIT_UMUL ? UMULL : SMULL)
1861                          | (reg_map[SLJIT_TEMPORARY_REG2] << 16)                          | (reg_map[SLJIT_SCRATCH_REG2] << 16)
1862                          | (reg_map[SLJIT_TEMPORARY_REG1] << 12)                          | (reg_map[SLJIT_SCRATCH_REG1] << 12)
1863                          | (reg_map[SLJIT_TEMPORARY_REG1] << 8)                          | (reg_map[SLJIT_SCRATCH_REG1] << 8)
1864                          | reg_map[TMP_REG1]);                          | reg_map[TMP_REG1]);
1865  #endif  #endif
1866          case SLJIT_UDIV:          case SLJIT_UDIV:
1867          case SLJIT_SDIV:          case SLJIT_SDIV:
1868                  if (compiler->temporaries >= 3)                  if (compiler->scratches >= 3)
1869                          EMIT_INSTRUCTION(0xe52d2008 /* str r2, [sp, #-8]! */);                          EMIT_INSTRUCTION(0xe52d2008 /* str r2, [sp, #-8]! */);
1870  #if defined(__GNUC__)  #if defined(__GNUC__)
1871                  FAIL_IF(sljit_emit_ijump(compiler, SLJIT_FAST_CALL, SLJIT_IMM,                  FAIL_IF(sljit_emit_ijump(compiler, SLJIT_FAST_CALL, SLJIT_IMM,
# Line 1857  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_ Line 1873  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_
1873  #else  #else
1874  #error "Software divmod functions are needed"  #error "Software divmod functions are needed"
1875  #endif  #endif
1876                  if (compiler->temporaries >= 3)                  if (compiler->scratches >= 3)
1877                          return push_inst(compiler, 0xe49d2008 /* ldr r2, [sp], #8 */);                          return push_inst(compiler, 0xe49d2008 /* ldr r2, [sp], #8 */);
1878                  return SLJIT_SUCCESS;                  return SLJIT_SUCCESS;
1879          }          }
# Line 2214  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_ Line 2230  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_
2230          check_sljit_emit_fast_enter(compiler, dst, dstw);          check_sljit_emit_fast_enter(compiler, dst, dstw);
2231          ADJUST_LOCAL_OFFSET(dst, dstw);          ADJUST_LOCAL_OFFSET(dst, dstw);
2232    
2233          if (dst >= SLJIT_TEMPORARY_REG1 && dst <= SLJIT_NO_REGISTERS)          /* For UNUSED dst. Uncommon, but possible. */
2234            if (dst == SLJIT_UNUSED)
2235                    return SLJIT_SUCCESS;
2236    
2237            if (dst <= TMP_REG3)
2238                  return push_inst(compiler, EMIT_DATA_PROCESS_INS(MOV_DP, 0, dst, SLJIT_UNUSED, RM(TMP_REG3)));                  return push_inst(compiler, EMIT_DATA_PROCESS_INS(MOV_DP, 0, dst, SLJIT_UNUSED, RM(TMP_REG3)));
         else if (dst & SLJIT_MEM) {  
                 if (getput_arg_fast(compiler, WORD_DATA, TMP_REG3, dst, dstw))  
                         return compiler->error;  
                 EMIT_INSTRUCTION(EMIT_DATA_PROCESS_INS(MOV_DP, 0, TMP_REG2, SLJIT_UNUSED, RM(TMP_REG3)));  
                 compiler->cache_arg = 0;  
                 compiler->cache_argw = 0;  
                 return getput_arg(compiler, WORD_DATA, TMP_REG2, dst, dstw, 0, 0);  
         }  
2239    
2240          return SLJIT_SUCCESS;          /* Memory. */
2241            if (getput_arg_fast(compiler, WORD_DATA, TMP_REG3, dst, dstw))
2242                    return compiler->error;
2243            /* TMP_REG3 is used for caching. */
2244            EMIT_INSTRUCTION(EMIT_DATA_PROCESS_INS(MOV_DP, 0, TMP_REG2, SLJIT_UNUSED, RM(TMP_REG3)));
2245            compiler->cache_arg = 0;
2246            compiler->cache_argw = 0;
2247            return getput_arg(compiler, WORD_DATA, TMP_REG2, dst, dstw, 0, 0);
2248  }  }
2249    
2250  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_fast_return(struct sljit_compiler *compiler, sljit_si src, sljit_sw srcw)  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_fast_return(struct sljit_compiler *compiler, sljit_si src, sljit_sw srcw)
# Line 2234  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_ Line 2253  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_
2253          check_sljit_emit_fast_return(compiler, src, srcw);          check_sljit_emit_fast_return(compiler, src, srcw);
2254          ADJUST_LOCAL_OFFSET(src, srcw);          ADJUST_LOCAL_OFFSET(src, srcw);
2255    
2256          if (src >= SLJIT_TEMPORARY_REG1 && src <= SLJIT_NO_REGISTERS)          if (src <= TMP_REG3)
2257                  EMIT_INSTRUCTION(EMIT_DATA_PROCESS_INS(MOV_DP, 0, TMP_REG3, SLJIT_UNUSED, RM(src)));                  EMIT_INSTRUCTION(EMIT_DATA_PROCESS_INS(MOV_DP, 0, TMP_REG3, SLJIT_UNUSED, RM(src)));
2258          else if (src & SLJIT_MEM) {          else if (src & SLJIT_MEM) {
2259                  if (getput_arg_fast(compiler, WORD_DATA | LOAD_DATA, TMP_REG3, src, srcw))                  if (getput_arg_fast(compiler, WORD_DATA | LOAD_DATA, TMP_REG3, src, srcw))
# Line 2394  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_ Line 2413  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_
2413                  jump->addr = compiler->size;                  jump->addr = compiler->size;
2414          }          }
2415          else {          else {
2416                  if (src >= SLJIT_TEMPORARY_REG1 && src <= SLJIT_NO_REGISTERS)                  if (src <= TMP_REG3)
2417                          return push_inst(compiler, (type <= SLJIT_JUMP ? BX : BLX) | RM(src));                          return push_inst(compiler, (type <= SLJIT_JUMP ? BX : BLX) | RM(src));
2418    
2419                  SLJIT_ASSERT(src & SLJIT_MEM);                  SLJIT_ASSERT(src & SLJIT_MEM);
2420                  FAIL_IF(emit_op(compiler, SLJIT_MOV, ALLOW_ANY_IMM, TMP_REG2, 0, TMP_REG1, 0, src, srcw));                  FAIL_IF(emit_op_mem(compiler, WORD_DATA | LOAD_DATA, TMP_REG2, src, srcw));
2421                  return push_inst(compiler, (type <= SLJIT_JUMP ? BX : BLX) | RM(TMP_REG2));                  return push_inst(compiler, (type <= SLJIT_JUMP ? BX : BLX) | RM(TMP_REG2));
2422          }          }
2423    
# Line 2410  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_ Line 2429  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_
2429          sljit_si src, sljit_sw srcw,          sljit_si src, sljit_sw srcw,
2430          sljit_si type)          sljit_si type)
2431  {  {
2432          sljit_si reg;          sljit_si dst_r, flags = GET_ALL_FLAGS(op);
2433          sljit_uw cc;          sljit_uw cc, ins;
2434    
2435          CHECK_ERROR();          CHECK_ERROR();
2436          check_sljit_emit_op_flags(compiler, op, dst, dstw, src, srcw, type);          check_sljit_emit_op_flags(compiler, op, dst, dstw, src, srcw, type);
2437          ADJUST_LOCAL_OFFSET(dst, dstw);          ADJUST_LOCAL_OFFSET(dst, dstw);
2438            ADJUST_LOCAL_OFFSET(src, srcw);
2439    
2440          if (dst == SLJIT_UNUSED)          if (dst == SLJIT_UNUSED)
2441                  return SLJIT_SUCCESS;                  return SLJIT_SUCCESS;
2442    
2443            op = GET_OPCODE(op);
2444          cc = get_cc(type);          cc = get_cc(type);
2445          if (GET_OPCODE(op) < SLJIT_ADD) {          dst_r = (dst <= TMP_REG3) ? dst : TMP_REG2;
                 reg = (dst >= SLJIT_TEMPORARY_REG1 && dst <= SLJIT_NO_REGISTERS) ? dst : TMP_REG2;  
2446    
2447                  EMIT_INSTRUCTION(EMIT_DATA_PROCESS_INS(MOV_DP, 0, reg, SLJIT_UNUSED, SRC2_IMM | 0));          if (op < SLJIT_ADD) {
2448                  EMIT_INSTRUCTION((EMIT_DATA_PROCESS_INS(MOV_DP, 0, reg, SLJIT_UNUSED, SRC2_IMM | 1) & ~COND_MASK) | cc);                  EMIT_INSTRUCTION(EMIT_DATA_PROCESS_INS(MOV_DP, 0, dst_r, SLJIT_UNUSED, SRC2_IMM | 0));
2449                    EMIT_INSTRUCTION((EMIT_DATA_PROCESS_INS(MOV_DP, 0, dst_r, SLJIT_UNUSED, SRC2_IMM | 1) & ~COND_MASK) | cc);
2450                  return (reg == TMP_REG2) ? emit_op(compiler, SLJIT_MOV, ALLOW_ANY_IMM, dst, dstw, TMP_REG1, 0, TMP_REG2, 0) : SLJIT_SUCCESS;                  return (dst_r == TMP_REG2) ? emit_op_mem(compiler, WORD_DATA, TMP_REG2, dst, dstw) : SLJIT_SUCCESS;
2451          }          }
2452    
2453          if (dst <= SLJIT_NO_REGISTERS) {          ins = (op == SLJIT_AND ? AND_DP : (op == SLJIT_OR ? ORR_DP : EOR_DP));
2454                  EMIT_INSTRUCTION((EMIT_DATA_PROCESS_INS(GET_OPCODE(op) == SLJIT_AND ? AND_DP : (GET_OPCODE(op) == SLJIT_OR ? ORR_DP : EOR_DP),          if ((op == SLJIT_OR || op == SLJIT_XOR) && dst <= TMP_REG3 && dst == src) {
2455                          0, dst, dst, SRC2_IMM | 1) & ~COND_MASK) | cc);                  EMIT_INSTRUCTION((EMIT_DATA_PROCESS_INS(ins, 0, dst, dst, SRC2_IMM | 1) & ~COND_MASK) | cc);
2456                  /* The condition must always be set, even if the AND/ORR is not executed above. */                  /* The condition must always be set, even if the ORR/EOR is not executed above. */
2457                  return (op & SLJIT_SET_E) ? push_inst(compiler, EMIT_DATA_PROCESS_INS(MOV_DP, SET_FLAGS, TMP_REG1, SLJIT_UNUSED, RM(dst))) : SLJIT_SUCCESS;                  return (flags & SLJIT_SET_E) ? push_inst(compiler, EMIT_DATA_PROCESS_INS(MOV_DP, SET_FLAGS, TMP_REG1, SLJIT_UNUSED, RM(dst))) : SLJIT_SUCCESS;
2458          }          }
2459    
2460          EMIT_INSTRUCTION(EMIT_DATA_PROCESS_INS(MOV_DP, 0, TMP_REG1, SLJIT_UNUSED, SRC2_IMM | 0));          compiler->cache_arg = 0;
2461          EMIT_INSTRUCTION((EMIT_DATA_PROCESS_INS(MOV_DP, 0, TMP_REG1, SLJIT_UNUSED, SRC2_IMM | 1) & ~COND_MASK) | cc);          compiler->cache_argw = 0;
2462  #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) || (defined SLJIT_DEBUG && SLJIT_DEBUG)          if (src & SLJIT_MEM) {
2463          compiler->skip_checks = 1;                  FAIL_IF(emit_op_mem2(compiler, WORD_DATA | LOAD_DATA, TMP_REG1, src, srcw, dst, dstw));
2464  #endif                  src = TMP_REG1;
2465          return emit_op(compiler, op, ALLOW_IMM, dst, dstw, TMP_REG1, 0, dst, dstw);                  srcw = 0;
2466            } else if (src & SLJIT_IMM) {
2467                    FAIL_IF(load_immediate(compiler, TMP_REG1, srcw));
2468                    src = TMP_REG1;
2469                    srcw = 0;
2470            }
2471    
2472            EMIT_INSTRUCTION((EMIT_DATA_PROCESS_INS(ins, 0, dst_r, src, SRC2_IMM | 1) & ~COND_MASK) | cc);
2473            EMIT_INSTRUCTION((EMIT_DATA_PROCESS_INS(ins, 0, dst_r, src, SRC2_IMM | 0) & ~COND_MASK) | (cc ^ 0x10000000));
2474            if (dst_r == TMP_REG2)
2475                    FAIL_IF(emit_op_mem2(compiler, WORD_DATA, TMP_REG2, dst, dstw, 0, 0));
2476    
2477            return (flags & SLJIT_SET_E) ? push_inst(compiler, EMIT_DATA_PROCESS_INS(MOV_DP, SET_FLAGS, TMP_REG1, SLJIT_UNUSED, RM(dst_r))) : SLJIT_SUCCESS;
2478  }  }
2479    
2480  SLJIT_API_FUNC_ATTRIBUTE struct sljit_const* sljit_emit_const(struct sljit_compiler *compiler, sljit_si dst, sljit_sw dstw, sljit_sw init_value)  SLJIT_API_FUNC_ATTRIBUTE struct sljit_const* sljit_emit_const(struct sljit_compiler *compiler, sljit_si dst, sljit_sw dstw, sljit_sw init_value)
# Line 2457  SLJIT_API_FUNC_ATTRIBUTE struct sljit_co Line 2489  SLJIT_API_FUNC_ATTRIBUTE struct sljit_co
2489          const_ = (struct sljit_const*)ensure_abuf(compiler, sizeof(struct sljit_const));          const_ = (struct sljit_const*)ensure_abuf(compiler, sizeof(struct sljit_const));
2490          PTR_FAIL_IF(!const_);          PTR_FAIL_IF(!const_);
2491    
2492          reg = (dst >= SLJIT_TEMPORARY_REG1 && dst <= SLJIT_NO_REGISTERS) ? dst : TMP_REG2;          reg = (dst <= TMP_REG3) ? dst : TMP_REG2;
2493    
2494  #if (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5)  #if (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5)
2495          PTR_FAIL_IF(push_inst_with_unique_literal(compiler, EMIT_DATA_TRANSFER(WORD_DATA | LOAD_DATA, 1, 0, reg, TMP_PC, 0), init_value));          PTR_FAIL_IF(push_inst_with_unique_literal(compiler, EMIT_DATA_TRANSFER(WORD_DATA | LOAD_DATA, 1, 0, reg, TMP_PC, 0), init_value));
# Line 2468  SLJIT_API_FUNC_ATTRIBUTE struct sljit_co Line 2500  SLJIT_API_FUNC_ATTRIBUTE struct sljit_co
2500          set_const(const_, compiler);          set_const(const_, compiler);
2501    
2502          if (reg == TMP_REG2 && dst != SLJIT_UNUSED)          if (reg == TMP_REG2 && dst != SLJIT_UNUSED)
2503                  if (emit_op(compiler, SLJIT_MOV, ALLOW_ANY_IMM, dst, dstw, TMP_REG1, 0, TMP_REG2, 0))                  PTR_FAIL_IF(emit_op_mem(compiler, WORD_DATA, TMP_REG2, dst, dstw));
                         return NULL;  
2504          return const_;          return const_;
2505  }  }
2506    

Legend:
Removed from v.1214  
changed lines
  Added in v.1215

  ViewVC Help
Powered by ViewVC 1.1.5