SLJIT_CPUINFO
" ABI:softfp";
32 return "ARM-Thumb2"SLJIT_CPUINFO
" ABI:hardfp";
40 #define TMP_REG1 (SLJIT_NUMBER_OF_REGISTERS + 2) 41 #define TMP_REG2 (SLJIT_NUMBER_OF_REGISTERS + 3) 42 #define TMP_PC (SLJIT_NUMBER_OF_REGISTERS + 4) 44 #define TMP_FREG1 (SLJIT_NUMBER_OF_FLOAT_REGISTERS + 1) 45 #define TMP_FREG2 (SLJIT_NUMBER_OF_FLOAT_REGISTERS + 2) 490, 0, 1, 2, 3, 11, 10, 9, 8, 7, 6, 5, 4, 13, 12, 14, 15
540, 1, 2, 3, 4, 5, 15, 14, 13, 12, 11, 10, 9, 8,
560, 1, 2, 3, 4, 5, 15, 14, 13, 12, 11, 10, 9, 8,
620, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
641, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
68 #define COPY_BITS(src, from, to, bits) \ 69 ((from >= to ? ((sljit_ins)(src) >> (from - to)) : ((sljit_ins)(src) << (to - from))) & (((1 << bits) - 1) << to)) 71 #define NEGATE(uimm) ((sljit_uw)-(sljit_sw)(uimm)) 74 #define RD3(rd) ((sljit_ins)reg_map[rd]) 75 #define RN3(rn) ((sljit_ins)reg_map[rn] << 3) 76 #define RM3(rm) ((sljit_ins)reg_map[rm] << 6) 77 #define RDN3(rdn) ((sljit_ins)reg_map[rdn] << 8) 78 #define IMM3(imm) ((sljit_ins)imm << 6) 79 #define IMM8(imm) ((sljit_ins)imm) 82 #define SET_REGS44(rd, rn) \ 83 (((sljit_ins)reg_map[rn] << 3) | ((sljit_ins)reg_map[rd] & 0x7) | (((sljit_ins)reg_map[rd] & 0x8) << 4)) 84 #define IS_2_LO_REGS(reg1, reg2) \ 85 (reg_map[reg1] <= 7 && reg_map[reg2] <= 7) 86 #define IS_3_LO_REGS(reg1, reg2, reg3) \ 87 (reg_map[reg1] <= 7 && reg_map[reg2] <= 7 && reg_map[reg3] <= 7) 90 #define RM4(rm) ((sljit_ins)reg_map[rm]) 91 #define RD4(rd) ((sljit_ins)reg_map[rd] << 8) 92 #define RT4(rt) ((sljit_ins)reg_map[rt] << 12) 93 #define RN4(rn) ((sljit_ins)reg_map[rn] << 16) 95 #define VM4(vm) (((sljit_ins)freg_map[vm]) | ((sljit_ins)freg_ebit_map[vm] << 5)) 96 #define VD4(vd) (((sljit_ins)freg_map[vd] << 12) | ((sljit_ins)freg_ebit_map[vd] << 22)) 97 #define VN4(vn) (((sljit_ins)freg_map[vn] << 16) | ((sljit_ins)freg_ebit_map[vn] << 7)) 100 (COPY_BITS(imm, 2, 12, 3) | (((sljit_ins)imm & 0x3) << 6)) 102 (COPY_BITS(imm, 11, 26, 1) | COPY_BITS(imm, 8, 12, 3) | ((sljit_ins)imm & 0xff)) 110 #define ADCI 0xf1400000 112 #define ADC_W 0xeb400000 115 #define ADDSI3 0x1c00 116 #define ADDSI8 0x3000 117 #define ADDWI 0xf2000000 118 #define ADD_SP 0x4485 119 #define ADD_SP_I 0xb000 120 #define ADD_W 0xeb000000 121 #define ADD_WI 0xf1000000 122 #define ANDI 0xf0000000 124 #define AND_W 0xea000000 127 #define ASR_W 0xfa40f000 128 #define ASR_WI 0xea4f0020 130 #define BICI 0xf0200000 134 #define CLZ 0xfab0f080 135 #define CMNI_W 0xf1100f00 138 #define CMPI_W 0xf1b00f00 140 #define CMP_W 0xebb00f00 141 #define EORI 0xf0800000 143 #define EOR_W 0xea800000 145 #define LDR 0xf8d00000 146 #define LDR_SP 0x9800 147 #define LDRD 0xe9500000 148 #define LDREX 0xe8500f00 149 #define LDREXB 0xe8d00f4f 150 #define LDREXH 0xe8d00f5f 151 #define LDRI 0xf8500800 154 #define LSL_W 0xfa00f000 155 #define LSL_WI 0xea4f0000 158 #define LSR_W 0xfa20f000 159 #define LSR_WI 0xea4f0010 160 #define MLA 0xfb000000 164 #define MOVT 0xf2c00000 165 #define MOVW 0xf2400000 166 #define MOV_W 0xea4f0000 167 #define MOV_WI 0xf04f0000 168 #define MUL 0xfb00f000 170 #define MVN_W 0xea6f0000 171 #define MVN_WI 0xf06f0000 173 #define ORNI 0xf0600000 174 #define ORRI 0xf0400000 176 #define ORR_W 0xea400000 178 #define POP_W 0xe8bd0000 180 #define PUSH_W 0xe92d0000 182 #define REV_W 0xfa90f080 184 #define REV16_W 0xfa90f090 185 #define RBIT 0xfa90f0a0 187 #define ROR_W 0xfa60f000 188 #define ROR_WI 0xea4f0030 189 #define RSB_WI 0xf1c00000 191 #define SBCI 0xf1600000 193 #define SBC_W 0xeb600000 194 #define SDIV 0xfb90f0f0 195 #define SMULL 0xfb800000 196 #define STR_SP 0x9000 197 #define STRD 0xe9400000 198 #define STREX 0xe8400000 199 #define STREXB 0xe8c00f40 200 #define STREXH 0xe8c00f50 202 #define SUBSI3 0x1e00 203 #define SUBSI8 0x3800 204 #define SUB_W 0xeba00000 205 #define SUBWI 0xf2a00000 206 #define SUB_SP_I 0xb080 207 #define SUB_WI 0xf1a00000 209 #define SXTB_W 0xfa4ff080 211 #define SXTH_W 0xfa0ff080 213 #define TSTI 0xf0000f00 214 #define TST_W 0xea000f00 215 #define UDIV 0xfbb0f0f0 216 #define UMULL 0xfba00000 218 #define UXTB_W 0xfa5ff080 220 #define UXTH_W 0xfa1ff080 221 #define VABS_F32 0xeeb00ac0 222 #define VADD_F32 0xee300a00 223 #define VAND 0xef000110 224 #define VCMP_F32 0xeeb40a40 225 #define VCVT_F32_S32 0xeeb80ac0 226 #define VCVT_F32_U32 0xeeb80a40 227 #define VCVT_F64_F32 0xeeb70ac0 228 #define VCVT_S32_F32 0xeebd0ac0 229 #define VDIV_F32 0xee800a00 230 #define VDUP 0xee800b10 231 #define VDUP_s 0xffb00c00 232 #define VEOR 0xff000110 233 #define VLD1 0xf9200000 234 #define VLD1_r 0xf9a00c00 235 #define VLD1_s 0xf9a00000 236 #define VLDR_F32 0xed100a00 237 #define VMOV_F32 0xeeb00a40 238 #define VMOV 0xee000a10 239 #define VMOV2 0xec400a10 240 #define VMOV_i 0xef800010 241 #define VMOV_s 0xee000b10 242 #define VMOVN 0xffb20200 243 #define VMRS 0xeef1fa10 244 #define VMUL_F32 0xee200a00 245 #define VNEG_F32 0xeeb10a40 246 #define VORR 0xef200110 247 #define VPOP 0xecbd0b00 248 #define VPUSH 0xed2d0b00 249 #define VSHLL 0xef800a10 250 #define VSHR 0xef800010 251 #define VSRA 0xef800110 252 #define VST1 0xf9000000 253 #define VST1_s 0xf9800000 254 #define VSTR_F32 0xed000a00 255 #define VSUB_F32 0xee300a40 257 #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS) 292compiler->
size+= 2;
310inst[3] = (
sljit_u16)(dst |
COPY_BITS(new_imm, 8 + 16, 12, 3) | ((new_imm & 0xff0000) >> 16));
316 SLJIT_ASSERT(((inst[0] & 0xfbf0) == (
MOVW>> 16)) && ((inst[2] & 0xfbf0) == (
MOVT>> 16)) && dst == (inst[3] & 0x0f00));
327 if(jump->
flags& JUMP_ADDR) {
329 if(!(jump->
u.
target& 0x1))
337 if(jump->
flags& IS_COND) {
340diff += SSIZE_OF(u16);
341 if(diff <= 0xff && diff >= -0x100) {
342jump->
flags|= PATCH_TYPE1;
346 if(diff <= 0xfffff && diff >= -0x100000) {
347jump->
flags|= PATCH_TYPE2;
351diff -= SSIZE_OF(u16);
352}
else if(jump->
flags& IS_BL) {
354 if(diff <= 0xffffff && diff >= -0x1000000) {
355jump->
flags|= PATCH_TYPE5;
359}
else if(diff <= 0x7ff && diff >= -0x800) {
360jump->
flags|= PATCH_TYPE3;
364 if(diff <= 0xffffff && diff >= -0x1000000) {
365jump->
flags|= PATCH_TYPE4;
370code_ptr[4] = code_ptr[0];
372 if(jump->
flags& IS_COND) {
373code_ptr[3] = code_ptr[-1];
386 if(jump->
flags& JUMP_ADDR)
396 if(diff <= 0xffd + 2 * SSIZE_OF(u16) && diff >= -0xfff + 2 * SSIZE_OF(u16)) {
397jump->
flags|= PATCH_TYPE6;
421diff -= (
sljit_sw)SLJIT_ADD_EXEC_OFFSET(jump_inst + 2, executable_offset) & ~(
sljit_sw)0x3;
431jump_inst[1] = (
sljit_u16)(jump_inst[0] |
COPY_BITS(diff, 8, 12, 3) | (diff & 0xff));
454jump_inst[0] = (
sljit_u16)(0xe000 | (diff & 0x7ff));
461diff ^= ((diff >> 2) & 0x600000) ^ 0x600000;
470jump_inst[1] |= 0x9000;
472jump_inst[1] |= 0xd000;
480SLJIT_NEXT_DEFINE_TYPES;
486jump = compiler->
jumps;
487const_ = compiler->
consts;
488SLJIT_NEXT_INIT_TYPES();
491SLJIT_GET_NEXT_MIN();
493 if(next_min_addr == SLJIT_MAX_ADDRESS)
496 if(next_min_addr == next_label_size) {
497 label->size -= size_reduce;
500next_label_size = SLJIT_GET_NEXT_SIZE(
label);
503 if(next_min_addr == next_const_addr) {
504const_->
addr-= size_reduce;
505const_ = const_->
next;
506next_const_addr = SLJIT_GET_NEXT_ADDRESS(const_);
510 if(next_min_addr != next_jump_addr)
513jump->
addr-= size_reduce;
514 if(!(jump->
flags& JUMP_MOV_ADDR)) {
521 if(jump->
flags& IS_COND) {
524 if(diff <= (0xff / SSIZE_OF(u16)) && diff >= (-0x100 / SSIZE_OF(u16)))
526 else if(diff <= (0xfffff / SSIZE_OF(u16)) && diff >= (-0x100000 / SSIZE_OF(u16)))
529}
else if(!(jump->
flags& IS_BL) && diff <= (0x7ff / SSIZE_OF(u16)) && diff >= (-0x800 / SSIZE_OF(u16)))
532 if(
total_size== JUMP_MAX_SIZE && diff <= (0xffffff / SSIZE_OF(u16)) && diff >= (-0x1000000 / SSIZE_OF(u16)))
541 if(!(jump->
flags& JUMP_ADDR)) {
544 if(diff <= (0xffd / SSIZE_OF(u16)) && diff >= (-0xfff / SSIZE_OF(u16)))
553next_jump_addr = SLJIT_GET_NEXT_ADDRESS(jump);
556compiler->
size-= size_reduce;
567SLJIT_NEXT_DEFINE_TYPES;
576CHECK_PTR(check_sljit_generate_code(compiler));
580 code= (
sljit_u16*)allocate_executable_memory(compiler->
size*
sizeof(
sljit_u16), options, exec_allocator_data, &executable_offset);
583reverse_buf(compiler);
589jump = compiler->
jumps;
590const_ = compiler->
consts;
591SLJIT_NEXT_INIT_TYPES();
592SLJIT_GET_NEXT_MIN();
596buf_end = buf_ptr + (
buf->used_size >> 1);
598*code_ptr = *buf_ptr++;
599 if(next_min_addr == half_count) {
605 if(next_min_addr == next_label_size) {
606 label->u.addr = ((
sljit_uw)SLJIT_ADD_EXEC_OFFSET(code_ptr, executable_offset)) | 0x1;
609next_label_size = SLJIT_GET_NEXT_SIZE(
label);
612 if(next_min_addr == next_jump_addr) {
613 if(!(jump->
flags& JUMP_MOV_ADDR)) {
614half_count = half_count - 1 + (jump->
flags>> JUMP_SIZE_SHIFT);
618((jump->
flags>> JUMP_SIZE_SHIFT) + ((jump->
flags& 0xf0) <= PATCH_TYPE2)) *
sizeof(
sljit_u16));
620half_count += jump->
flags>> JUMP_SIZE_SHIFT;
627next_jump_addr = SLJIT_GET_NEXT_ADDRESS(jump);
628}
else if(next_min_addr == next_const_addr) {
630const_ = const_->
next;
631next_const_addr = SLJIT_GET_NEXT_ADDRESS(const_);
634SLJIT_GET_NEXT_MIN();
638}
while(buf_ptr < buf_end);
644 label->u.addr = ((
sljit_uw)SLJIT_ADD_EXEC_OFFSET(code_ptr, executable_offset)) | 0x1;
654jump = compiler->
jumps;
665code_ptr = (
sljit_u16*)SLJIT_ADD_EXEC_OFFSET(code_ptr, executable_offset);
676 switch(feature_type) {
680 #ifdef SLJIT_IS_FPU_AVAILABLE 708 #define INVALID_IMM 0x80000000 717 if((imm & 0xffff) == (imm >> 16)) {
720 return(1 << 12) | (imm & 0xff);
722 return(2 << 12) | ((imm >> 8) & 0xff);
723 if((imm & 0xff00) == ((imm & 0xff) << 8))
724 return(3 << 12) | (imm & 0xff);
729 if(!(imm & 0xffff0000)) {
733 if(!(imm & 0xff000000)) {
737 if(!(imm & 0xf0000000)) {
741 if(!(imm & 0xc0000000)) {
745 if(!(imm & 0x80000000)) {
752 if(imm & 0x00ffffff)
764 if(imm >= 0x10000) {
784 #define ARG1_IMM 0x0010000 785 #define ARG2_IMM 0x0020000 787 #define SET_FLAGS 0x0100000 788 #define UNUSED_RETURN 0x0200000 789 #define REGISTER_OP 0x0400000 810 switch(
flags& 0xffff) {
875 if(imm <= 0xff &&
reg_map[reg] <= 7)
968 switch(
flags& 0xffff) {
985imm = (imm ^ 0x1f) + 1;
1009 switch(
flags& 0xffff) {
1097compiler->status_flags_state = 0;
1155compiler->status_flags_state = 0;
1166 #define WORD_SIZE 0x00 1167 #define BYTE_SIZE 0x04 1168 #define HALF_SIZE 0x08 1169 #define PRELOAD 0x0c 1171 #define IS_WORD_SIZE(flags) (!((flags) & (BYTE_SIZE | HALF_SIZE))) 1172 #define ALIGN_CHECK(argw, imm, shift) (!((argw) & ~((imm) << (shift)))) 1223 #define MEM_IMM8 0xc00 1224 #define MEM_IMM12 0x800000 1250 if(
value<= 0xfff)
1258 if(
value<= 0xfff)
1274 SLJIT_ASSERT((arg & REG_MASK) != tmp_reg || (arg ==
SLJIT_MEM1(tmp_reg) && argw >= -0xff && argw <= 0xfff));
1291other_r = OFFS_REG(arg);
1306argw = argw & 0xfff;
1309 else if(argw < -0xff) {
1349 if(argw >= 0 && argw <= 0xfff)
1351 else if(argw < 0 && argw >= -0xff)
1374 sljit_s32saved_arg_count = SLJIT_KEPT_SAVEDS_COUNT(options);
1386 CHECK(check_sljit_emit_enter(compiler, options, arg_types, scratches, saveds, fscratches, fsaveds, local_size));
1387set_emit_enter(compiler, options, arg_types, scratches, saveds, fscratches, fsaveds, local_size);
1402 size= GET_SAVED_REGISTERS_SIZE(scratches, saveds - saved_arg_count, 1);
1405 if((
size& SSIZE_OF(
sw)) != 0) {
1410 if(fsaveds + fscratches >= SLJIT_NUMBER_OF_FLOAT_REGISTERS) {
1420local_size = ((
size+ local_size + 0x7) & ~0x7) -
size;
1428saved_arg_count = 0;
1433float_arg_count = 0;
1436 switch(arg_types & SLJIT_ARG_MASK) {
1464 tmp= word_arg_count;
1483compiler->args_size =
offset;
1490 switch(arg_types & SLJIT_ARG_MASK) {
1492 if(
offset!= old_offset)
1498 if(f32_offset != 0) {
1502 if(
offset!= old_offset)
1504f32_offset = old_offset;
1523 while(remap_ptr > remap)
1528 if(local_size >= 4096) {
1534 if(local_size < 4 * 4096) {
1535 if(local_size > 2 * 4096) {
1536 if(local_size > 3 * 4096) {
1553local_size &= 0xfff;
1556 if(local_size >= 256) {
1559 if(local_size <= (127 << 2))
1565}
else if(local_size > 0)
1568 if(local_size > 0) {
1569 if(local_size <= (127 << 2))
1586 CHECK(check_sljit_set_context(compiler, options, arg_types, scratches, saveds, fscratches, fsaveds, local_size));
1587set_set_context(compiler, options, arg_types, scratches, saveds, fscratches, fsaveds, local_size);
1589 size= GET_SAVED_REGISTERS_SIZE(scratches, saveds - SLJIT_KEPT_SAVEDS_COUNT(options), 1);
1604 if(imm <= (127u << 2))
1630fsaveds = compiler->
fsaveds;
1636 if(fsaveds + fscratches >= SLJIT_NUMBER_OF_FLOAT_REGISTERS) {
1645local_size = GET_SAVED_REGISTERS_SIZE(compiler->
scratches, compiler->
saveds, 1) & 0x7;
1648 if(frame_size < 0) {
1651}
else if(frame_size > 0) {
1652 SLJIT_ASSERT(frame_size == 1 || (frame_size & 0x7) == 0);
1663}
while(--
i>
tmp);
1674 if(lr_dst ==
TMP_REG2&& reg_list == 0) {
1680 if(lr_dst == 0 && (reg_list & (reg_list - 1)) == 0) {
1683 if(reg_list != 0) {
1685 if(local_size <= 0xfff) {
1686 if(local_size == 0) {
1688 if(frame_size == 0)
1690 if(frame_size > 2 * SSIZE_OF(
sw))
1694 if(
reg_map[restored_reg] <= 7 && local_size <= 0x3fc)
1699}
else if(frame_size == 0) {
1700frame_size = (restored_reg ==
TMP_REG2) ? SSIZE_OF(
sw) : 2 * SSIZE_OF(
sw);
1706local_size += SSIZE_OF(
sw);
1710local_size += SSIZE_OF(
sw);
1712 if(frame_size > local_size)
1714 else if(frame_size < local_size)
1721frame_size -= SSIZE_OF(
sw);
1723frame_size -= SSIZE_OF(
sw);
1725 if(
reg_map[restored_reg] <= 7)
1731 tmp= (restored_reg ==
TMP_REG2) ? 0x304 : 0x308;
1738 if(!(reg_list & 0xff00) && lr_dst !=
TMP_REG2) {
1740reg_list |= 1u << 8;
1768 CHECK(check_sljit_emit_return_void(compiler));
1777 CHECK(check_sljit_emit_return_to(compiler, src, srcw));
1791SLJIT_SKIP_CHECKS(compiler);
1799 #if !(defined __ARM_FEATURE_IDIV) && !(defined __ARM_ARCH_EXT_IDIV__) 1806 extern unsigned long long__rt_udiv(
unsigned intdenominator,
unsigned intnumerator);
1807 extern long long__rt_sdiv(
intdenominator,
intnumerator);
1808 #elif defined(__GNUC__) 1809 extern unsigned int__aeabi_uidivmod(
unsigned intnumerator,
int unsigneddenominator);
1810 extern int__aeabi_idivmod(
intnumerator,
intdenominator);
1812 #error "Software divmod functions are needed" 1823 #if !(defined __ARM_FEATURE_IDIV) && !(defined __ARM_ARCH_EXT_IDIV__) 1829 CHECK(check_sljit_emit_op0(compiler, op));
1831op = GET_OPCODE(op);
1841 #if (defined __ARM_FEATURE_IDIV) || (defined __ARM_ARCH_EXT_IDIV__) 1859saved_reg_count = 0;
1861saved_reg_list[saved_reg_count++] = 3;
1863saved_reg_list[saved_reg_count++] = 2;
1865saved_reg_list[saved_reg_count++] = 1;
1867 if(saved_reg_count > 0) {
1869| (saved_reg_list[0] << 12)
));
1870 if(saved_reg_count >= 2) {
1874 if(saved_reg_count >= 3) {
1886 #elif defined(__GNUC__) 1890 #error "Software divmod functions are needed" 1893 if(saved_reg_count > 0) {
1894 if(saved_reg_count >= 3) {
1898 if(saved_reg_count >= 2) {
1902 return push_inst32(compiler, 0xf85d0b00 | (saved_reg_count >= 3 ? 16 : 8)
1903| (saved_reg_list[0] << 12)
);
1922 CHECK(check_sljit_emit_op1(compiler, op, dst, dstw, src, srcw));
1923ADJUST_LOCAL_OFFSET(dst, dstw);
1924ADJUST_LOCAL_OFFSET(src, srcw);
1926dst_r = FAST_IS_REG(dst) ? dst :
TMP_REG2;
1928op = GET_OPCODE(op);
1968 else if(FAST_IS_REG(dst))
2008 CHECK(check_sljit_emit_op2(compiler, op, 0, dst, dstw, src1, src1w, src2, src2w));
2009ADJUST_LOCAL_OFFSET(dst, dstw);
2010ADJUST_LOCAL_OFFSET(src1, src1w);
2011ADJUST_LOCAL_OFFSET(src2, src2w);
2013dst_reg = FAST_IS_REG(dst) ? dst :
TMP_REG2;
2024src2w = src2_tmp_reg;
2048 CHECK(check_sljit_emit_op2(compiler, op, 1, 0, 0, src1, src1w, src2, src2w));
2050SLJIT_SKIP_CHECKS(compiler);
2060 CHECK(check_sljit_emit_op2r(compiler, op, dst_reg, src1, src1w, src2, src2w));
2062 switch(GET_OPCODE(op)) {
2064SLJIT_SKIP_CHECKS(compiler);
2065 return sljit_emit_op2(compiler, op, dst_reg, 0, src1, src1w, src2, src2w);
2080 CHECK(check_sljit_emit_shift_into(compiler, op, dst_reg, src1_reg, src2_reg, src3, src3w));
2082op = GET_OPCODE(op);
2085 if(src1_reg == src2_reg) {
2086SLJIT_SKIP_CHECKS(compiler);
2090ADJUST_LOCAL_OFFSET(src3, src3w);
2103src3w = (src3w ^ 0x1f) + 1;
2117 if(dst_reg == src1_reg &&
IS_2_LO_REGS(dst_reg, src3))
2132 CHECK(check_sljit_emit_op_src(compiler, op, src, srcw));
2133ADJUST_LOCAL_OFFSET(src, srcw);
2139 if(FAST_IS_REG(src))
2163 CHECK(check_sljit_emit_op_dst(compiler, op, dst, dstw));
2164ADJUST_LOCAL_OFFSET(dst, dstw);
2170 if(FAST_IS_REG(dst))
2178 if((
size& SSIZE_OF(
sw)) == 0)
2186dst_r = FAST_IS_REG(dst) ? dst :
TMP_REG2;
2199CHECK_REG_INDEX(check_sljit_get_register_index(
type, reg));
2217 CHECK(check_sljit_emit_op_custom(compiler, instruction,
size));
2228 #define FPU_LOAD (1 << 20) 2244 if((arg & REG_MASK) && (argw & 0x3) == 0) {
2245 if(!(argw & ~0x3fc))
2247 if(!(-argw & ~0x3fc))
2251 if(arg & REG_MASK) {
2290 if(FAST_IS_REG(dst))
2303 if(FAST_IS_REG(src))
2370SELECT_FOP1_OPERATION_WITH_CHECKS(compiler, op, dst, dstw, src, srcw);
2372dst_r = FAST_IS_REG(dst) ? dst :
TMP_FREG1;
2382 switch(GET_OPCODE(op)) {
2416 CHECK(check_sljit_emit_fop2(compiler, op, dst, dstw, src1, src1w, src2, src2w));
2417ADJUST_LOCAL_OFFSET(dst, dstw);
2418ADJUST_LOCAL_OFFSET(src1, src1w);
2419ADJUST_LOCAL_OFFSET(src2, src2w);
2423dst_r = FAST_IS_REG(dst) ? dst :
TMP_FREG1;
2433 switch(GET_OPCODE(op)) {
2462 #if defined(__ARM_NEON) && __ARM_NEON 2472 CHECK(check_sljit_emit_fset32(compiler, freg,
value));
2476 #if defined(__ARM_NEON) && __ARM_NEON 2477 if((u.imm << (32 - 19)) == 0) {
2478exp = (u.imm >> (23 + 2)) & 0x3f;
2480 if(exp == 0x20 || exp == 0x1f) {
2481ins = ((u.imm >> 24) & 0x80) | ((u.imm >> 19) & 0x7f);
2494 #if defined(__ARM_NEON) && __ARM_NEON 2504 CHECK(check_sljit_emit_fset64(compiler, freg,
value));
2508 #if defined(__ARM_NEON) && __ARM_NEON 2509 if(u.imm[0] == 0 && (u.imm[1] << (64 - 48)) == 0) {
2510exp = (u.imm[1] >> ((52 - 32) + 2)) & 0x1ff;
2512 if(exp == 0x100 || exp == 0xff) {
2513ins = ((u.imm[1] >> (56 - 32)) & 0x80) | ((u.imm[1] >> (48 - 32)) & 0x7f);
2514 return push_inst32(compiler, (
VMOV_F32^ (1 << 6)) | (1 << 8) | ((ins & 0xf0) << 12) |
VD4(freg) | (ins & 0xf));
2520 if(u.imm[0] == u.imm[1])
2534 CHECK(check_sljit_emit_fcopy(compiler, op, freg, reg));
2536 if(reg & REG_PAIR_MASK) {
2537reg2 = REG_PAIR_SECOND(reg);
2538reg = REG_PAIR_FIRST(reg);
2652CHECK_PTR(check_sljit_emit_label(compiler));
2659set_label(
label, compiler);
2669CHECK_PTR(check_sljit_emit_jump(compiler,
type));
2677jump->
flags|= IS_COND;
2679jump->
flags|= cc << 8;
2687jump->
flags|= IS_BL;
2692compiler->
size+= JUMP_MAX_SIZE - 1;
2709 if(src && FAST_IS_REG(*src))
2717 switch(arg_types & SLJIT_ARG_MASK) {
2733word_arg_offset +=
sizeof(
sljit_sw);
2763 switch(
types& SLJIT_ARG_MASK) {
2766 offset= *(--offset_ptr);
2778| (float_arg_count << 12) | ((
offset- 4 *
sizeof(
sljit_sw)) >> 2)));
2782 offset= *(--offset_ptr);
2785 if(src_offset ==
offset) {
2792| (float_arg_count << 12) | ((
offset- 4 *
sizeof(
sljit_sw)) >> 2)));
2795word_arg_offset -=
sizeof(
sljit_sw);
2796 offset= *(--offset_ptr);
2800 if(
offset!= word_arg_offset) {
2802 if(src_offset ==
offset) {
2806 else if(src_offset == word_arg_offset) {
2845 switch(arg_types & SLJIT_ARG_MASK) {
2847 if(
offset!= new_offset)
2854 if(f32_offset != 0) {
2858 if(
offset!= new_offset)
2860f32_offset = new_offset;
2883CHECK_PTR(check_sljit_emit_call(compiler,
type, arg_types));
2887 PTR_FAIL_IF(softfloat_call_with_args(compiler, arg_types,
NULL, &extra_space));
2893SLJIT_SKIP_CHECKS(compiler);
2897 if(extra_space > 0) {
2911 PTR_FAIL_IF(softfloat_post_call_with_args(compiler, arg_types));
2927SLJIT_SKIP_CHECKS(compiler);
2936 CHECK(check_sljit_emit_ijump(compiler,
type, src, srcw));
2937ADJUST_LOCAL_OFFSET(src, srcw);
2942 if(FAST_IS_REG(src)) {
2960compiler->
size+= JUMP_MAX_SIZE - 1;
2973 CHECK(check_sljit_emit_icall(compiler,
type, arg_types, src, srcw));
2987 FAIL_IF(softfloat_call_with_args(compiler, arg_types, &src, &extra_space));
2993SLJIT_SKIP_CHECKS(compiler);
2996 if(extra_space > 0) {
3008 returnsoftfloat_post_call_with_args(compiler, arg_types);
3023SLJIT_SKIP_CHECKS(compiler);
3035SLJIT_SKIP_CHECKS(compiler);
3039 if(FAST_IS_REG(src)) {
3045SLJIT_SKIP_CHECKS(compiler);
3062 CHECK(check_sljit_emit_op_flags(compiler, op, dst, dstw,
type));
3063ADJUST_LOCAL_OFFSET(dst, dstw);
3065op = GET_OPCODE(op);
3067dst_r = FAST_IS_REG(dst) ? dst :
TMP_REG1;
3115 CHECK(check_sljit_emit_select(compiler,
type, dst_reg, src1, src1w, src2_reg));
3117ADJUST_LOCAL_OFFSET(src1, src1w);
3119 if(src2_reg != dst_reg && src1 == dst_reg) {
3129 if(src2_reg != dst_reg) {
3137}
else if(dst_reg != src2_reg)
3149 if(
tmp< 0x10000) {
3183 CHECK(check_sljit_emit_fselect(compiler,
type, dst_freg, src1, src1w, src2_freg));
3185ADJUST_LOCAL_OFFSET(src1, src1w);
3189 if(dst_freg != src2_freg) {
3190 if(dst_freg == src1) {
3215 CHECK(check_sljit_emit_mem(compiler,
type, reg, mem, memw));
3217 if(!(reg & REG_PAIR_MASK))
3218 returnsljit_emit_mem_unaligned(compiler,
type, reg, mem, memw);
3221 if((mem & REG_MASK) == 0) {
3222 if((memw & 0xfff) >= (0x1000 - SSIZE_OF(
sw))) {
3226memw = (memw & 0xfff) - 0x1000;
3241}
else if(mem & OFFS_REG_MASK) {
3245}
else if(memw < -0xff) {
3247 if((-memw & 0xfff) <= SSIZE_OF(
sw))
3266}
else if(memw >= (0x1000 - SSIZE_OF(
sw))) {
3267 if((memw & 0xfff) >= (0x1000 - SSIZE_OF(
sw))) {
3271memw = (memw & 0xfff) - 0x1000;
3297}
else if(REG_PAIR_FIRST(reg) == (mem & REG_MASK)) {
3308 if((mem & REG_MASK) == 0) {
3317memw = (memw & 0x3fc) >> 2;
3320memw = 0x100 - memw;
3328}
else if(mem & OFFS_REG_MASK) {
3332}
else if(memw < 0) {
3333 if((-memw & ~0x3fc) == 0) {
3342memw = (-memw & 0x3fc) >> 2;
3347memw = 0x100 - memw;
3356}
else if((memw & ~0x3fc) != 0) {
3362memw = (memw & 0x3fc) >> 2;
3365memw = 0x100 - memw;
3390 CHECK(check_sljit_emit_mem_update(compiler,
type, reg, mem, memw));
3392 if((mem & OFFS_REG_MASK) || (memw > 255 || memw < -255))
3398 switch(
type& 0xff) {
3456 if(argw <= max_offset && argw >= -0xff) {
3465*memw = -(-argw & 0xff);
3468}
else if((argw & 0xfff) <= max_offset) {
3472*memw = argw & 0xfff;
3479*memw = (argw & 0xfff) - 0x1000;
3487 if((argw & 0xfff) > max_offset) {
3489*memw = (argw & 0xfff) - 0x1000;
3491*memw = argw & 0xfff;
3506 CHECK(check_sljit_emit_fmem(compiler,
type, freg, mem, memw));
3582 #define SLJIT_QUAD_OTHER_HALF(freg) ((((freg) & 0x1) << 1) - 1) 3594 CHECK(check_sljit_emit_simd_mov(compiler,
type, freg, srcdst, srcdstw));
3596ADJUST_LOCAL_OFFSET(srcdst, srcdstw);
3598 if(reg_size != 3 && reg_size != 4)
3615ins =
VD4(srcdst) |
VN4(freg) |
VM4(freg);
3617ins =
VD4(freg) |
VN4(srcdst) |
VM4(srcdst);
3631| (
sljit_ins)((reg_size == 3) ? (0x7 << 8) : (0xa << 8));
3637 else if(alignment >= 4)
3657 switch(elem_size) {
3667 if(
value<= 0xff) {
3672 if((
value& 0xff) == 0) {
3690 if(
value<= 0xff) {
3746 CHECK(check_sljit_emit_simd_replicate(compiler,
type, freg, src, srcw));
3748ADJUST_LOCAL_OFFSET(src, srcw);
3750 if(reg_size != 3 && reg_size != 4)
3771}
else if(freg != src)
3819 switch(elem_size) {
3846 CHECK(check_sljit_emit_simd_lane_mov(compiler,
type, freg, lane_index, srcdst, srcdstw));
3848ADJUST_LOCAL_OFFSET(srcdst, srcdstw);
3850 if(reg_size != 3 && reg_size != 4)
3863ins = (reg_size == 3) ? 0 : ((
sljit_ins)1 << 6);
3866 if(elem_size == 3 && !(srcdst &
SLJIT_MEM)) {
3867 if(lane_index == 1)
3887 if(reg_size == 4 && lane_index >= (0x8 >> elem_size)) {
3888lane_index -= (0x8 >> elem_size);
3898lane_index = lane_index << elem_size;
3899ins = (
sljit_ins)((elem_size << 10) | (lane_index << 5));
3904 if(elem_size == 3) {
3912 if(lane_index == 1)
3936 else if(elem_size == 1)
3941lane_index = lane_index << elem_size;
3942ins |= (
sljit_ins)(((lane_index & 0x4) << 19) | ((lane_index & 0x3) << 5));
3963 CHECK(check_sljit_emit_simd_lane_replicate(compiler,
type, freg, src, src_lane_index));
3965 if(reg_size != 3 && reg_size != 4)
3974 if(reg_size == 4) {
3978 if(src_lane_index >= (0x8 >> elem_size)) {
3979src_lane_index -= (0x8 >> elem_size);
3984 if(elem_size == 3) {
3995ins = ((((
sljit_ins)src_lane_index << 1) | 1) << (16 + elem_size));
4013 CHECK(check_sljit_emit_simd_extend(compiler,
type, freg, src, srcw));
4015ADJUST_LOCAL_OFFSET(src, srcw);
4017 if(reg_size != 3 && reg_size != 4)
4031 if(reg_size == 4 && elem2_size - elem_size == 1)
4036}
else if(reg_size == 4)
4040dst_reg = (reg_size == 4) ? freg :
TMP_FREG2;
4046}
while(++elem_size < elem2_size);
4078 CHECK(check_sljit_emit_simd_sign(compiler,
type, freg, dst, dstw));
4080ADJUST_LOCAL_OFFSET(dst, dstw);
4082 if(reg_size != 3 && reg_size != 4)
4091 switch(elem_size) {
4094ins =
VSHR| (1 << 28) | (0x9 << 16);
4097imms = (reg_size == 4) ? 0x243219 : 0x2231;
4098ins =
VSHR| (1 << 28) | (0x11 << 16);
4101imms = (reg_size == 4) ? 0x2231 : 0x21;
4102ins =
VSHR| (1 << 28) | (0x21 << 16);
4106ins =
VSHR| (1 << 28) | (0x1 << 16) | (1 << 7);
4110 if(reg_size == 4) {
4118 if(reg_size == 4 && elem_size > 0)
4121ins = (reg_size == 4 && elem_size == 0) ? (1 << 6) : 0;
4123 while(imms >= 0x100) {
4130dst_r = FAST_IS_REG(dst) ? dst :
TMP_REG1;
4133 if(reg_size == 4 && elem_size == 0) {
4153 CHECK(check_sljit_emit_simd_op2(compiler,
type, dst_freg, src1_freg, src2_freg));
4155 if(reg_size != 3 && reg_size != 4)
4161 switch(SLJIT_SIMD_GET_OPCODE(
type)) {
4176 if(reg_size == 4) {
4195 CHECK(check_sljit_emit_atomic_load(compiler, op, dst_reg, mem_reg));
4197 switch(GET_OPCODE(op)) {
4223 CHECK(check_sljit_emit_atomic_store(compiler, op, src_reg, mem_reg, temp_reg));
4225 switch(GET_OPCODE(op)) {
4250CHECK_PTR(check_sljit_emit_const(compiler, dst, dstw, init_value));
4251ADJUST_LOCAL_OFFSET(dst, dstw);
4255set_const(const_, compiler);
4257dst_r = FAST_IS_REG(dst) ? dst :
TMP_REG1;
4271CHECK_PTR(check_sljit_emit_mov_addr(compiler, dst, dstw));
4272ADJUST_LOCAL_OFFSET(dst, dstw);
4276set_mov_addr(jump, compiler, 0);
4278dst_r = FAST_IS_REG(dst) ? dst :
TMP_REG1;
4280compiler->
size+= 3;
4295inst = (
sljit_u16*)SLJIT_ADD_EXEC_OFFSET(inst, executable_offset);
#define CHECK_ERROR(name, s)
static const struct type types[]
static const char label[]
const struct ncbi::grid::netcache::search::fields::SIZE size
const GenericPointer< typename T::ValueType > T2 value
static PCRE2_SIZE * offsets
#define SLJIT_UNREACHABLE()
unsigned short int sljit_u16
signed short int sljit_s16
#define SLJIT_UNLIKELY(x)
#define SLJIT_API_FUNC_ATTRIBUTE
#define SLJIT_COMPILE_ASSERT(x, description)
#define SLJIT_F64_SECOND(reg)
#define SLJIT_UNUSED_ARG(arg)
#define SLJIT_NUMBER_OF_SCRATCH_FLOAT_REGISTERS
#define SLJIT_TMP_FREGISTER_BASE
#define SLJIT_CACHE_FLUSH(from, to)
#define SLJIT_UPDATE_WX_FLAGS(from, to, enable_exec)
static sljit_uw total_size
#define PTR_FAIL_IF(expr)
#define PTR_FAIL_WITH_EXEC_IF(ptr)
#define CHECK_ERROR_PTR()
#define SLJIT_UNORDERED_OR_LESS_EQUAL
#define SLJIT_SKIP_FRAMES_BEFORE_FAST_RETURN
#define SLJIT_CALL_REG_ARG
#define SLJIT_ARG_TYPE_SCRATCH_REG
#define SLJIT_SIMD_OP2_AND
#define SLJIT_ORDERED_LESS_EQUAL
#define SLJIT_FAST_RETURN
#define SLJIT_MEM_UNALIGNED
#define SLJIT_SIMD_REG_64
#define SLJIT_ATOMIC_NOT_STORED
#define SLJIT_FIRST_SAVED_REG
#define SLJIT_UNORDERED_OR_GREATER
#define SLJIT_ARG_TYPE_F32
#define SLJIT_ORDERED_GREATER_EQUAL
#define SLJIT_FUNC_ADDR(func_name)
#define SLJIT_PREFETCH_L3
#define SLJIT_SIG_GREATER_EQUAL
#define SLJIT_RETURN_FREG
#define SLJIT_UNORDERED_OR_NOT_EQUAL
#define SLJIT_ARG_TYPE_F64
#define SLJIT_SIMD_EXTEND_SIGNED
#define SLJIT_PREFETCH_L1
#define SLJIT_SIMD_OP2_XOR
#define SLJIT_COPYSIGN_F64
#define SLJIT_ORDERED_EQUAL
#define SLJIT_ERR_UNSUPPORTED
#define SLJIT_UNORDERED_OR_LESS
#define SLJIT_MEM_ALIGNED_16
#define SLJIT_ORDERED_GREATER
#define SLJIT_SIMD_REGS_ARE_PAIRS
#define SLJIT_SIG_LESS_EQUAL
#define SLJIT_UNORDERED_OR_EQUAL
#define SLJIT_CALL_RETURN
#define SLJIT_REWRITABLE_JUMP
#define SLJIT_NOT_OVERFLOW
#define SLJIT_F_NOT_EQUAL
#define SLJIT_F_GREATER_EQUAL
#define SLJIT_CURRENT_FLAGS_ADD
#define SLJIT_HAS_PREFETCH
#define SLJIT_ENTER_REG_ARG
#define SLJIT_SIG_GREATER
#define SLJIT_SIMD_LANE_ZERO
#define SLJIT_FLOAT_REGISTER
#define SLJIT_ATOMIC_STORED
#define SLJIT_GET_RETURN_ADDRESS
#define SLJIT_MEM_ALIGNED_32
#define SLJIT_HAS_F64_AS_F32_PAIR
#define SLJIT_FIRST_SAVED_FLOAT_REG
#define SLJIT_SIMD_OP2_OR
#define SLJIT_SIMD_LANE_SIGNED
#define SLJIT_GREATER_EQUAL
#define SLJIT_GP_REGISTER
#define SLJIT_SKIP_FRAMES_BEFORE_RETURN
#define SLJIT_ERR_COMPILED
#define SLJIT_HAS_COPY_F64
#define SLJIT_SIMD_REG_128
#define SLJIT_F_LESS_EQUAL
#define SLJIT_ORDERED_LESS
#define SLJIT_HAS_COPY_F32
#define SLJIT_CONV_F64_FROM_F32
#define SLJIT_REG_PAIR(r1, r2)
#define SLJIT_PREFETCH_L2
#define SLJIT_SET_ATOMIC_STORED
#define SLJIT_CURRENT_FLAGS_SUB
#define SLJIT_PREFETCH_ONCE
#define SLJIT_ORDERED_NOT_EQUAL
#define SLJIT_COPY_FROM_F64
#define SLJIT_UNORDERED_OR_GREATER_EQUAL
static sljit_uw get_cc(struct sljit_compiler *compiler, sljit_s32 type)
SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_op_flags(struct sljit_compiler *compiler, sljit_s32 op, sljit_s32 dst, sljit_sw dstw, sljit_s32 type)
SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump * sljit_emit_jump(struct sljit_compiler *compiler, sljit_s32 type)
#define COPY_BITS(src, from, to, bits)
SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_op2r(struct sljit_compiler *compiler, sljit_s32 op, sljit_s32 dst_reg, sljit_s32 src1, sljit_sw src1w, sljit_s32 src2, sljit_sw src2w)
SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_select(struct sljit_compiler *compiler, sljit_s32 type, sljit_s32 dst_reg, sljit_s32 src1, sljit_sw src1w, sljit_s32 src2_reg)
SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_mem(struct sljit_compiler *compiler, sljit_s32 type, sljit_s32 reg, sljit_s32 mem, sljit_sw memw)
SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_return_to(struct sljit_compiler *compiler, sljit_s32 src, sljit_sw srcw)
static sljit_s32 emit_add_sp(struct sljit_compiler *compiler, sljit_uw imm)
SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_has_cpu_feature(sljit_s32 feature_type)
static SLJIT_INLINE void modify_imm32_const(sljit_u16 *inst, sljit_uw new_imm)
SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_op2u(struct sljit_compiler *compiler, sljit_s32 op, sljit_s32 src1, sljit_sw src1w, sljit_s32 src2, sljit_sw src2w)
static SLJIT_INLINE void generate_jump_or_mov_addr(struct sljit_jump *jump, sljit_sw executable_offset)
static sljit_s32 load_immediate(struct sljit_compiler *compiler, sljit_s32 dst, sljit_uw imm)
SLJIT_API_FUNC_ATTRIBUTE struct sljit_label * sljit_emit_label(struct sljit_compiler *compiler)
SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_atomic_load(struct sljit_compiler *compiler, sljit_s32 op, sljit_s32 dst_reg, sljit_s32 mem_reg)
SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_get_register_index(sljit_s32 type, sljit_s32 reg)
static sljit_s32 emit_stack_frame_release(struct sljit_compiler *compiler, sljit_s32 frame_size)
#define ALIGN_CHECK(argw, imm, shift)
SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_simd_replicate(struct sljit_compiler *compiler, sljit_s32 type, sljit_s32 freg, sljit_s32 src, sljit_sw srcw)
SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_simd_op2(struct sljit_compiler *compiler, sljit_s32 type, sljit_s32 dst_freg, sljit_s32 src1_freg, sljit_s32 src2_freg)
static sljit_s32 sljit_emit_simd_mem_offset(struct sljit_compiler *compiler, sljit_s32 *mem_ptr, sljit_sw memw)
static const sljit_u8 freg_map[((SLJIT_NUMBER_OF_FLOAT_REGISTERS+2)<< 1)+1]
#define IS_3_LO_REGS(reg1, reg2, reg3)
SLJIT_API_FUNC_ATTRIBUTE void sljit_set_const(sljit_uw addr, sljit_sw new_constant, sljit_sw executable_offset)
static SLJIT_INLINE sljit_s32 sljit_emit_fop1_conv_f64_from_sw(struct sljit_compiler *compiler, sljit_s32 op, sljit_s32 dst, sljit_sw dstw, sljit_s32 src, sljit_sw srcw)
static const sljit_ins sljit_mem32[13]
SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_ijump(struct sljit_compiler *compiler, sljit_s32 type, sljit_s32 src, sljit_sw srcw)
static const sljit_u8 freg_ebit_map[((SLJIT_NUMBER_OF_FLOAT_REGISTERS+2)<< 1)+1]
SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump * sljit_emit_mov_addr(struct sljit_compiler *compiler, sljit_s32 dst, sljit_sw dstw)
static SLJIT_INLINE sljit_s32 emit_op_mem(struct sljit_compiler *compiler, sljit_s32 flags, sljit_s32 reg, sljit_s32 arg, sljit_sw argw, sljit_s32 tmp_reg)
static sljit_s32 push_inst16(struct sljit_compiler *compiler, sljit_ins inst)
static sljit_s32 emit_op_imm(struct sljit_compiler *compiler, sljit_s32 flags, sljit_s32 dst, sljit_uw arg1, sljit_uw arg2)
SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_fset32(struct sljit_compiler *compiler, sljit_s32 freg, sljit_f32 value)
static SLJIT_INLINE sljit_u16 * detect_jump_type(struct sljit_jump *jump, sljit_u16 *code_ptr, sljit_u16 *code, sljit_sw executable_offset)
SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_fcopy(struct sljit_compiler *compiler, sljit_s32 op, sljit_s32 freg, sljit_s32 reg)
SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_return_void(struct sljit_compiler *compiler)
SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_mem_update(struct sljit_compiler *compiler, sljit_s32 type, sljit_s32 reg, sljit_s32 mem, sljit_sw memw)
SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_set_context(struct sljit_compiler *compiler, sljit_s32 options, sljit_s32 arg_types, sljit_s32 scratches, sljit_s32 saveds, sljit_s32 fscratches, sljit_s32 fsaveds, sljit_s32 local_size)
SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_simd_lane_mov(struct sljit_compiler *compiler, sljit_s32 type, sljit_s32 freg, sljit_s32 lane_index, sljit_s32 srcdst, sljit_sw srcdstw)
static sljit_s32 update_mem_addr(struct sljit_compiler *compiler, sljit_s32 *mem, sljit_sw *memw, sljit_s32 max_offset)
SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_op0(struct sljit_compiler *compiler, sljit_s32 op)
static SLJIT_INLINE sljit_s32 sljit_emit_fop1_conv_f64_from_uw(struct sljit_compiler *compiler, sljit_s32 op, sljit_s32 dst, sljit_sw dstw, sljit_s32 src, sljit_sw srcw)
SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_fop2(struct sljit_compiler *compiler, sljit_s32 op, sljit_s32 dst, sljit_sw dstw, sljit_s32 src1, sljit_sw src1w, sljit_s32 src2, sljit_sw src2w)
SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_fop1(struct sljit_compiler *compiler, sljit_s32 op, sljit_s32 dst, sljit_sw dstw, sljit_s32 src, sljit_sw srcw)
static const sljit_u8 reg_map[SLJIT_NUMBER_OF_REGISTERS+5]
SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_shift_into(struct sljit_compiler *compiler, sljit_s32 op, sljit_s32 dst_reg, sljit_s32 src1_reg, sljit_s32 src2_reg, sljit_s32 src3, sljit_sw src3w)
SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_simd_extend(struct sljit_compiler *compiler, sljit_s32 type, sljit_s32 freg, sljit_s32 src, sljit_sw srcw)
static sljit_s32 push_inst32(struct sljit_compiler *compiler, sljit_ins inst)
SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_enter(struct sljit_compiler *compiler, sljit_s32 options, sljit_s32 arg_types, sljit_s32 scratches, sljit_s32 saveds, sljit_s32 fscratches, sljit_s32 fsaveds, sljit_s32 local_size)
#define IS_WORD_SIZE(flags)
SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_simd_mov(struct sljit_compiler *compiler, sljit_s32 type, sljit_s32 freg, sljit_s32 srcdst, sljit_sw srcdstw)
#define IS_2_LO_REGS(reg1, reg2)
static sljit_s32 sljit_emit_fop1_conv_f64_from_w(struct sljit_compiler *compiler, sljit_ins ins, sljit_s32 dst, sljit_sw dstw, sljit_s32 src, sljit_sw srcw)
static void reduce_code_size(struct sljit_compiler *compiler)
static sljit_s32 emit_fop_mem(struct sljit_compiler *compiler, sljit_s32 flags, sljit_s32 reg, sljit_s32 arg, sljit_sw argw)
static sljit_uw get_imm(sljit_uw imm)
static SLJIT_INLINE sljit_sw mov_addr_get_length(struct sljit_jump *jump, sljit_u16 *code_ptr, sljit_u16 *code, sljit_sw executable_offset)
#define SET_REGS44(rd, rn)
SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_fset64(struct sljit_compiler *compiler, sljit_s32 freg, sljit_f64 value)
static SLJIT_INLINE sljit_s32 simd_get_quad_reg_index(sljit_s32 freg)
SLJIT_API_FUNC_ATTRIBUTE void sljit_set_jump_addr(sljit_uw addr, sljit_uw new_target, sljit_sw executable_offset)
SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_op_dst(struct sljit_compiler *compiler, sljit_s32 op, sljit_s32 dst, sljit_sw dstw)
static sljit_s32 emit_set_delta(struct sljit_compiler *compiler, sljit_s32 dst, sljit_s32 reg, sljit_sw value)
SLJIT_API_FUNC_ATTRIBUTE struct sljit_const * sljit_emit_const(struct sljit_compiler *compiler, sljit_s32 dst, sljit_sw dstw, sljit_sw init_value)
SLJIT_API_FUNC_ATTRIBUTE const char * sljit_get_platform_name(void)
static sljit_s32 emit_imm32_const(struct sljit_compiler *compiler, sljit_s32 dst, sljit_uw imm)
SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_atomic_store(struct sljit_compiler *compiler, sljit_s32 op, sljit_s32 src_reg, sljit_s32 mem_reg, sljit_s32 temp_reg)
static void set_imm32_const(sljit_u16 *inst, sljit_ins dst, sljit_uw new_imm)
SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_fselect(struct sljit_compiler *compiler, sljit_s32 type, sljit_s32 dst_freg, sljit_s32 src1, sljit_sw src1w, sljit_s32 src2_freg)
#define SLJIT_QUAD_OTHER_HALF(freg)
static const sljit_ins sljit_mem16[12]
SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_op_src(struct sljit_compiler *compiler, sljit_s32 op, sljit_s32 src, sljit_sw srcw)
SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump * sljit_emit_call(struct sljit_compiler *compiler, sljit_s32 type, sljit_s32 arg_types)
static SLJIT_INLINE sljit_s32 sljit_emit_fop1_cmp(struct sljit_compiler *compiler, sljit_s32 op, sljit_s32 src1, sljit_sw src1w, sljit_s32 src2, sljit_sw src2w)
SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_simd_sign(struct sljit_compiler *compiler, sljit_s32 type, sljit_s32 freg, sljit_s32 dst, sljit_sw dstw)
SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_fmem(struct sljit_compiler *compiler, sljit_s32 type, sljit_s32 freg, sljit_s32 mem, sljit_sw memw)
SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_op2(struct sljit_compiler *compiler, sljit_s32 op, sljit_s32 dst, sljit_sw dstw, sljit_s32 src1, sljit_sw src1w, sljit_s32 src2, sljit_sw src2w)
static const sljit_ins sljit_mem16_imm5[12]
static sljit_ins simd_get_imm(sljit_s32 elem_size, sljit_uw value)
SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_op_custom(struct sljit_compiler *compiler, void *instruction, sljit_u32 size)
SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_icall(struct sljit_compiler *compiler, sljit_s32 type, sljit_s32 arg_types, sljit_s32 src, sljit_sw srcw)
static SLJIT_INLINE sljit_s32 sljit_emit_fop1_conv_sw_from_f64(struct sljit_compiler *compiler, sljit_s32 op, sljit_s32 dst, sljit_sw dstw, sljit_s32 src, sljit_sw srcw)
static sljit_s32 hardfloat_call_with_args(struct sljit_compiler *compiler, sljit_s32 arg_types)
SLJIT_API_FUNC_ATTRIBUTE void * sljit_generate_code(struct sljit_compiler *compiler, sljit_s32 options, void *exec_allocator_data)
SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_op1(struct sljit_compiler *compiler, sljit_s32 op, sljit_s32 dst, sljit_sw dstw, sljit_s32 src, sljit_sw srcw)
SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_simd_lane_replicate(struct sljit_compiler *compiler, sljit_s32 type, sljit_s32 freg, sljit_s32 src, sljit_s32 src_lane_index)
#define SLJIT_IS_FPU_AVAILABLE
static SLJIT_INLINE sljit_s32 emit_fmov_before_return(struct sljit_compiler *compiler, sljit_s32 op, sljit_s32 src, sljit_sw srcw)
struct sljit_const * consts
sljit_sw executable_offset
struct sljit_jump * jumps
struct sljit_label * last_label
struct sljit_memory_fragment * buf
struct sljit_label * labels
struct sljit_const * next
union sljit_jump::@1235 u
struct sljit_label * label
union sljit_label::@1234 u
RetroSearch is an open source project built by @garambo | Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4