Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from http://www.ncbi.nlm.nih.gov/IEB/ToolBox/CPP_DOC/doxyhtml/sljitNativeARM__64_8c_source.html below:

NCBI C++ ToolKit: src/util/regexp/sljit/sljitNativeARM_64.c Source File

SLJIT_CPUINFO;

31, 0, 1, 2, 3, 4, 5, 6, 7, 11, 12, 13, 14, 15, 16, 17, 8, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 31, 9, 10, 30, 29

0, 0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 15, 14, 13, 12, 11, 10, 9, 8, 30, 31

(jump->

& JUMP_ADDR)

target_addr = jump->

.

;

(jump->

& IS_COND) {

diff += SSIZE_OF(ins);

(diff <= 0xfffff && diff >= -0x100000) {

*(--code_ptr) ^= (jump->

& IS_CBZ) ? (0x1 << 24) : 0x1;

jump->

|= PATCH_COND;

diff -= SSIZE_OF(ins);

(diff <= 0x7ffffff && diff >= -0x8000000) {

(jump->

& IS_COND)

code_ptr[-1] -= (4 << 5);

jump->

|= PATCH_B;

(target_addr < 0x100000000l) {

(jump->

& IS_COND)

code_ptr[-1] -= (2 << 5);

code_ptr[2] = code_ptr[0];

(diff <= 0xfffff000l && diff >= -0x100000000l) {

(jump->

& IS_COND)

code_ptr[-1] -= (2 << 5);

jump->

|= PATCH_B32;

code_ptr[2] = code_ptr[0];

(target_addr < 0x1000000000000l) {

(jump->

& IS_COND)

code_ptr[-1] -= (1 << 5);

jump->

|= PATCH_ABS48;

code_ptr[3] = code_ptr[0];

jump->

|= PATCH_ABS64;

code_ptr[4] = code_ptr[0];

(jump->

& JUMP_ADDR)

(diff <= 0xfffff && diff >= -0x100000) {

jump->

|= PATCH_B;

(diff <= 0xfffff000l && diff >= -0x100000000l) {

jump->

|= PATCH_B32;

(

< 0x100000000l) {

(

< 0x1000000000000l) {

jump->

|= PATCH_ABS48;

jump->

|= PATCH_ABS64;

(!(jump->

& JUMP_MOV_ADDR)) {

(jump->

& PATCH_COND) {

= (

- (

)SLJIT_ADD_EXEC_OFFSET(buf_ptr, executable_offset)) >> 2;

(jump->

& PATCH_B) {

= (

- (

)SLJIT_ADD_EXEC_OFFSET(buf_ptr, executable_offset)) >> 2;

dst = (buf_ptr[0] >> 5) & 0x1f;

(jump->

& PATCH_B32) {

(jump->

& PATCH_B) {

-= (

)SLJIT_ADD_EXEC_OFFSET(buf_ptr, executable_offset);

(jump->

& PATCH_B32) {

buf_ptr[1] =

| (((

)(

>> 16) & 0xffff) << 5) | (1 << 21) | dst;

(jump->

& (PATCH_ABS48 | PATCH_ABS64))

buf_ptr[2] =

| (((

)(

>> 32) & 0xffff) << 5) | (2 << 21) | dst;

(jump->

& PATCH_ABS64)

SLJIT_NEXT_DEFINE_TYPES;

jump = compiler->

;

const_ = compiler->

;

SLJIT_NEXT_INIT_TYPES();

SLJIT_GET_NEXT_MIN();

(next_min_addr == SLJIT_MAX_ADDRESS)

(next_min_addr == next_label_size) {

->size -= size_reduce;

next_label_size = SLJIT_GET_NEXT_SIZE(

);

(next_min_addr == next_const_addr) {

const_->

-= size_reduce;

const_ = const_->

;

next_const_addr = SLJIT_GET_NEXT_ADDRESS(const_);

(next_min_addr != next_jump_addr)

jump->

-= size_reduce;

(!(jump->

& JUMP_MOV_ADDR)) {

(jump->

& JUMP_ADDR) {

(jump->

.

< 0x100000000l)

(jump->

.

< 0x1000000000000l)

((jump->

& IS_COND) && (diff + 1) <= (0xfffff / SSIZE_OF(ins)) && (diff + 1) >= (-0x100000 / SSIZE_OF(ins)))

(diff <= (0x7ffffff / SSIZE_OF(ins)) && diff >= (-0x8000000 / SSIZE_OF(ins)))

(diff <= (0xfffff000l / SSIZE_OF(ins)) && diff >= (-0x100000000l / SSIZE_OF(ins)))

(!(jump->

& JUMP_ADDR)) {

(diff <= (0xfffff / SSIZE_OF(ins)) && diff >= (-0x100000 / SSIZE_OF(ins)))

(diff <= (0xfffff000l / SSIZE_OF(ins)) && diff >= (-0x100000000l / SSIZE_OF(ins)))

}

(jump->

.

< 0x100000000l)

(jump->

.

< 0x1000000000000l)

next_jump_addr = SLJIT_GET_NEXT_ADDRESS(jump);

compiler->

-= size_reduce;

SLJIT_NEXT_DEFINE_TYPES;

CHECK_PTR(check_sljit_generate_code(compiler));

= (

*)allocate_executable_memory(compiler->

*

(

), options, exec_allocator_data, &executable_offset);

reverse_buf(compiler);

jump = compiler->

;

const_ = compiler->

;

SLJIT_NEXT_INIT_TYPES();

SLJIT_GET_NEXT_MIN();

buf_end = buf_ptr + (

->used_size >> 2);

*code_ptr = *buf_ptr++;

(next_min_addr == word_count) {

(next_min_addr == next_label_size) {

->u.addr = (

)SLJIT_ADD_EXEC_OFFSET(code_ptr, executable_offset);

next_label_size = SLJIT_GET_NEXT_SIZE(

);

(next_min_addr == next_jump_addr) {

(!(jump->

& JUMP_MOV_ADDR)) {

word_count = word_count - 1 + (jump->

>> JUMP_SIZE_SHIFT);

word_count += jump->

>> JUMP_SIZE_SHIFT;

next_jump_addr = SLJIT_GET_NEXT_ADDRESS(jump);

}

(next_min_addr == next_const_addr) {

const_ = const_->

;

next_const_addr = SLJIT_GET_NEXT_ADDRESS(const_);

SLJIT_GET_NEXT_MIN();

}

(buf_ptr < buf_end);

->u.addr = (

)SLJIT_ADD_EXEC_OFFSET(code_ptr, executable_offset);

jump = compiler->

;

code_ptr = (

*)SLJIT_ADD_EXEC_OFFSET(code_ptr, executable_offset);

(feature_type) {

(

== 32 && (imm == 0 || imm == -1))

ins = (0x3f - ((

<< 1) - 1)) << 10;

ins | ((

- ones - 1) << 10) | ((

- ones - right) << 16);

ins | ((ones - 1) << 10) | ((

- right) << 16);

(simm < 0 && simm >= -0x10000)

(imm <= 0xffffffffl) {

((imm & 0xffff) == 0)

((imm & 0xffff0000l) == 0xffff0000)

((imm & 0xffff) == 0xffff)

(simm < 0 && simm >= -0x100000000l) {

((imm & 0xffff) == 0xffff)

(

= 4;

> 0;

--) {

((simm & 0xffff) == 0)

((simm & 0xffff) == 0xffff)

(

= 0;

< 4;

++) {

(!(simm & 0xffff)) {

(

= 0;

< 4;

++) {

(!(simm & 0xffff)) {

(imm > 0 && imm <= 0xfff) {

(nimm > 0 && nimm <= 0xfff) {

(imm > 0 && imm <= 0xffffff && !(imm & 0xfff)) {

(nimm > 0 && nimm <= 0xffffff && !(nimm & 0xfff)) {

(compiler, (

^ inv_bits) |

(dst) |

(reg) | inst_bits);

inv_bits |= inv_bits >> 9;

inv_bits |= inv_bits >> 9;

inst_bits = ((

)imm << 16) | (31 << 10);

inv_bits |= inv_bits >> 9;

(compiler, (

^ inv_bits) |

(dst) |

(arg2) | (7 << 10));

inv_bits |= inv_bits >> 9;

(compiler, (

^ inv_bits) |

(dst) |

(arg2) | (7 << 10));

inv_bits |= inv_bits >> 9;

(compiler, (

^ inv_bits) |

(dst) |

(arg2) | (15 << 10));

inv_bits |= inv_bits >> 9;

(compiler, (

^ inv_bits) |

(dst) |

(arg2) | (15 << 10));

(compiler,

| (1 << 22) |

(dst) |

(arg2) | (31 << 10));

inv_bits |= inv_bits >> 21;

inv_bits |= inv_bits >> 9;

(compiler,

| (1 << 22) |

(dst) |

(dst) | (31 << 10));

compiler->status_flags_state = 0;

compiler->status_flags_state = 0;

(argw == 0 || argw == shift)

|

(arg & REG_MASK) |

(OFFS_REG(arg)) | (argw ? (1 << 12) : 0));

argw = (argw >> shift) & 0xfff;

((argw & ((1 << shift) - 1)) == 0) {

((argw >> shift) <= 0xfff)

(argw <= 0xffffff) {

argw = ((argw & 0xfff) >> shift);

}

(argw < -256 && argw >= -0xfff000) {

argw = ((0x1000 + argw) & 0xfff) >> shift;

(argw <= 0xff && argw >= -0x100)

(((argw + 0x100) & 0xfff) <= 0x1ff && argw <= 0xfff0ff && argw >= -0xfff100) {

(!(argw & 0x100))

saved_arg_count = SLJIT_KEPT_SAVEDS_COUNT(options);

(check_sljit_emit_enter(compiler, options, arg_types, scratches, saveds, fscratches, fsaveds, local_size));

set_emit_enter(compiler, options, arg_types, scratches, saveds, fscratches, fsaveds, local_size);

saved_regs_size = GET_SAVED_REGISTERS_SIZE(scratches, saveds - saved_arg_count, 2);

saved_regs_size += GET_SAVED_FLOAT_REGISTERS_SIZE(fscratches, fsaveds, f64);

local_size = (local_size + saved_regs_size + 0xf) & ~0xf;

(local_size <= 512) {

offs = (

)(local_size - 2 * SSIZE_OF(

)) << (15 - 3);

saved_regs_size = ((saved_regs_size - 2 * SSIZE_OF(

)) + 0xf) & ~0xf;

offs = (

)(saved_regs_size - 2 * SSIZE_OF(

)) << (15 - 3);

local_size -= saved_regs_size;

(local_size > 4096)

saved_arg_count = 0;

(local_size > 4096) {

(local_size < 4 * 4096) {

(local_size >= 2 * 4096) {

(local_size >= 3 * 4096) {

local_size &= 0xfff;

(local_size > 0) {

(local_size <= 512)

(local_size >= 4096)

local_size = (1 << (22 - 10));

(local_size != 0) {

(local_size > 0xfff) {

local_size &= 0xfff;

(local_size > 512 || local_size == 0) {

(local_size != 0)

(check_sljit_set_context(compiler, options, arg_types, scratches, saveds, fscratches, fsaveds, local_size));

set_set_context(compiler, options, arg_types, scratches, saveds, fscratches, fsaveds, local_size);

saved_regs_size = GET_SAVED_REGISTERS_SIZE(scratches, saveds - SLJIT_KEPT_SAVEDS_COUNT(options), 2);

saved_regs_size += GET_SAVED_FLOAT_REGISTERS_SIZE(fscratches, fsaveds, f64);

compiler->

= (local_size + saved_regs_size + 0xf) & ~0xf;

(!is_return_to) {

(local_size > 512 && local_size <= 512 + 496) {

(local_size > 512 && local_size <= 512 + 248) {

(local_size > 512) {

(local_size > 0xfff) {

| (((

)local_size >> 12) << 10) | (1 << 22)));

local_size &= 0xfff;

offs = (

)(local_size - 2 * SSIZE_OF(

)) << (15 - 3);

(check_sljit_emit_return_void(compiler));

(check_sljit_emit_return_to(compiler, src, srcw));

ADJUST_LOCAL_OFFSET(src, srcw);

SLJIT_SKIP_CHECKS(compiler);

(check_sljit_emit_op0(compiler, op));

op = GET_OPCODE(op);

(check_sljit_emit_op1(compiler, op, dst, dstw, src, srcw));

ADJUST_LOCAL_OFFSET(dst, dstw);

ADJUST_LOCAL_OFFSET(src, srcw);

dst_r = FAST_IS_REG(dst) ? dst :

;

op = GET_OPCODE(op);

(FAST_IS_REG(dst) && FAST_IS_REG(src))

(check_sljit_emit_op2(compiler, op, 0, dst, dstw, src1, src1w, src2, src2w));

ADJUST_LOCAL_OFFSET(dst, dstw);

ADJUST_LOCAL_OFFSET(src1, src1w);

ADJUST_LOCAL_OFFSET(src2, src2w);

dst_r = FAST_IS_REG(dst) ? dst :

;

(check_sljit_emit_op2(compiler, op, 1, 0, 0, src1, src1w, src2, src2w));

SLJIT_SKIP_CHECKS(compiler);

(check_sljit_emit_op2r(compiler, op, dst_reg, src1, src1w, src2, src2w));

(GET_OPCODE(op)) {

SLJIT_SKIP_CHECKS(compiler);

(compiler, op, dst_reg, 0, src1, src1w, src2, src2w);

(check_sljit_emit_shift_into(compiler, op, dst_reg, src1_reg, src2_reg, src3, src3w));

(src1_reg == src2_reg) {

SLJIT_SKIP_CHECKS(compiler);

ADJUST_LOCAL_OFFSET(src3, src3w);

= inv_bits ? 0x1f : 0x3f;

src3w = (src3w ^

) + 1;

(compiler, (

^ (inv_bits | (inv_bits >> 9))) |

(dst_reg)

|

(is_left ? src1_reg : src2_reg) |

(is_left ? src2_reg : src1_reg) | ((

)src3w << 10));

}

(dst_reg == src3) {

imm = (

)(inv_bits ? ((1 << 16) | (31 << 10)) : ((1 << 16) | (63 << 10) | (1 << 22)));

imm = (

)(inv_bits ? ((31 << 16) | (30 << 10)) : ((63 << 16) | (62 << 10) | (1 << 22)));

imm = (

)(inv_bits ? (4 << 10) : ((5 << 10) | (1 << 22)));

(check_sljit_emit_op_src(compiler, op, src, srcw));

ADJUST_LOCAL_OFFSET(src, srcw);

(FAST_IS_REG(src))

(check_sljit_emit_op_dst(compiler, op, dst, dstw));

ADJUST_LOCAL_OFFSET(dst, dstw);

(FAST_IS_REG(dst))

dst_r = FAST_IS_REG(dst) ? dst :

;

CHECK_REG_INDEX(check_sljit_get_register_index(

, reg));

(check_sljit_emit_op_custom(compiler, instruction,

));

(arg & OFFS_REG_MASK) {

(argw == 0 || argw == shift)

|

(arg & REG_MASK) |

(OFFS_REG(arg)) | (argw ? (1 << 12) : 0));

argw = (argw >> shift) & 0xfff;

(argw >= 0 && (argw & ((1 << shift) - 1)) == 0) {

((argw >> shift) <= 0xfff)

(argw <= 0xffffff) {

argw = ((argw & 0xfff) >> shift);

(argw <= 255 && argw >= -256)

SELECT_FOP1_OPERATION_WITH_CHECKS(compiler, op, dst, dstw, src, srcw);

inv_bits = (op &

) ? (1 << 22) : 0;

dst_r = FAST_IS_REG(dst) ? dst :

;

(GET_OPCODE(op)) {

(check_sljit_emit_fop2(compiler, op, dst, dstw, src1, src1w, src2, src2w));

ADJUST_LOCAL_OFFSET(dst, dstw);

ADJUST_LOCAL_OFFSET(src1, src1w);

ADJUST_LOCAL_OFFSET(src2, src2w);

dst_r = FAST_IS_REG(dst) ? dst :

;

(GET_OPCODE(op)) {

(check_sljit_emit_fset32(compiler, freg,

));

((u.imm << (32 - 19)) == 0) {

exp = (u.imm >> (23 + 2)) & 0x3f;

(exp == 0x20 || exp == 0x1f)

(compiler, (

^ (1 << 22)) | (

)((((u.imm >> 24) & 0x80) | ((u.imm >> 19) & 0x7f)) << 13) |

(freg));

(check_sljit_emit_fset64(compiler, freg,

));

((u.imm << (64 - 48)) == 0) {

exp = (u.imm >> (52 + 2)) & 0x1ff;

(exp == 0x100 || exp == 0xff)

(check_sljit_emit_fcopy(compiler, op, freg, reg));

inst =

|

(reg) |

(freg) | (1 << 16);

inst ^=

| (1 << 22);

CHECK_PTR(check_sljit_emit_label(compiler));

set_label(

, compiler);

CHECK_PTR(check_sljit_emit_jump(compiler,

));

jump->

|= IS_COND;

jump->

|= IS_BL;

compiler->

+= JUMP_MAX_SIZE - 1;

CHECK_PTR(check_sljit_emit_call(compiler,

, arg_types));

SLJIT_SKIP_CHECKS(compiler);

ADJUST_LOCAL_OFFSET(src, srcw);

jump->

|= IS_CBZ | IS_COND;

inv_bits |= 1 << 24;

compiler->

+= JUMP_MAX_SIZE - 1;

(check_sljit_emit_ijump(compiler,

, src, srcw));

ADJUST_LOCAL_OFFSET(src, srcw);

compiler->

+= JUMP_MAX_SIZE - 1;

(check_sljit_emit_icall(compiler,

, arg_types, src, srcw));

ADJUST_LOCAL_OFFSET(src, srcw);

SLJIT_SKIP_CHECKS(compiler);

(check_sljit_emit_op_flags(compiler, op, dst, dstw,

));

ADJUST_LOCAL_OFFSET(dst, dstw);

dst_r = FAST_IS_REG(dst) ? dst :

;

(check_sljit_emit_select(compiler,

, dst_reg, src1, src1w, src2_reg));

ADJUST_LOCAL_OFFSET(src1, src1w);

(compiler, (

^ inv_bits) | (cc << 12) |

(dst_reg) |

(src2_reg) |

(src1));

(check_sljit_emit_fselect(compiler,

, dst_freg, src1, src1w, src2_freg));

ADJUST_LOCAL_OFFSET(src1, src1w);

(compiler, (

^ inv_bits) | (cc << 12) |

(dst_freg) |

(src2_freg) |

(src1));

(check_sljit_emit_mem(compiler,

, reg, mem, memw));

(!(reg & REG_PAIR_MASK))

sljit_emit_mem_unaligned(compiler,

, reg, mem, memw);

ADJUST_LOCAL_OFFSET(mem, memw);

(!(mem & REG_MASK)) {

}

(mem & OFFS_REG_MASK) {

}

((memw & 0x7) != 0 || memw > 0x1f8 || memw < -0x200) {

}

((memw & 0x7) == 0 && memw <= 0x7ff0) {

(compiler, inst |

(REG_PAIR_SECOND(reg)) |

(mem & REG_MASK) | ((

)(memw + 0x8) << 7));

}

((

)memw <= 0xffffff) {

((memw & 0xe07) != 0) {

((memw & 0x7) == 0 && memw <= 0x1f8 && memw >= -0x200);

(check_sljit_emit_mem_update(compiler,

, reg, mem, memw));

((mem & OFFS_REG_MASK) || (memw > 255 || memw < -256))

(

& 0xff) {

inst |= sign ? 0x00800000 : 0x00400000;

(compiler, inst |

(reg) |

(mem & REG_MASK) | (

)((memw & 0x1ff) << 12));

(check_sljit_emit_fmem_update(compiler,

, freg, mem, memw));

((mem & OFFS_REG_MASK) || (memw > 255 || memw < -256))

(compiler, inst |

(freg) |

(mem & REG_MASK) | (

)((memw & 0x1ff) << 12));

(!(mem & REG_MASK)) {

(memw < -0xffffff || memw > 0xffffff) {

(check_sljit_emit_simd_mov(compiler,

, freg, srcdst, srcdstw));

ADJUST_LOCAL_OFFSET(srcdst, srcdstw);

(reg_size != 3 && reg_size != 4)

ins =

(srcdst) |

(freg) |

(freg);

ins =

(freg) |

(srcdst) |

(srcdst);

(elem_size) {

(

<= 0xff) {

((

& 0xff) == 0) {

(

<= 0xff) {

(check_sljit_emit_simd_replicate(compiler,

, freg, src, srcw));

ADJUST_LOCAL_OFFSET(src, srcw);

(reg_size != 3 && reg_size != 4)

ins = (

)1 << (16 + elem_size);

(check_sljit_emit_simd_lane_mov(compiler,

, freg, lane_index, srcdst, srcdstw));

ADJUST_LOCAL_OFFSET(srcdst, srcdstw);

(reg_size != 3 && reg_size != 4)

ins = (reg_size == 3) ? 0 : ((

)1 << 30);

(elem_size == 0)

lane_index = lane_index << elem_size;

ins |= (

)(((lane_index & 0x8) << 27) | ((lane_index & 0x7) << 10));

ins =

| ((((

)lane_index << 1) | 1) << (16 + elem_size)) |

(freg) |

(srcdst);

ins =

(srcdst) |

(freg);

ins =

|

(freg) |

(srcdst);

(compiler, ins | ((((

)lane_index << 1) | 1) << (16 + elem_size)));

(check_sljit_emit_simd_lane_replicate(compiler,

, freg, src, src_lane_index));

(reg_size != 3 && reg_size != 4)

ins = (((

)src_lane_index << 1) | 1) << (16 + elem_size);

(check_sljit_emit_simd_extend(compiler,

, freg, src, srcw));

ADJUST_LOCAL_OFFSET(src, srcw);

(reg_size != 3 && reg_size != 4)

(reg_size == 4 && elem2_size - elem_size == 1)

| ((

)1 << (19 + elem_size)) |

(freg) |

(src)));

}

(++elem_size < elem2_size);

(check_sljit_emit_simd_sign(compiler,

, freg, dst, dstw));

ADJUST_LOCAL_OFFSET(dst, dstw);

(reg_size != 3 && reg_size != 4)

(elem_size) {

ins =

| (0x9 << 16);

imms = (reg_size == 4) ? 0x643219 : 0x6231;

ins =

| (0x11 << 16);

imms = (reg_size == 4) ? 0x6231 : 0x61;

ins =

| (0x21 << 16);

ins =

| (0x41 << 16);

(reg_size == 4 && elem_size > 0)

(imms >= 0x100) {

ins = (reg_size == 4 && elem_size == 0) ? (1 << 30) : 0;

}

(imms >= 0x100);

dst_r = FAST_IS_REG(dst) ? dst :

;

(reg_size == 4 && elem_size == 0) {

(check_sljit_emit_simd_op2(compiler,

, dst_freg, src1_freg, src2_freg));

(reg_size != 3 && reg_size != 4)

(SLJIT_SIMD_GET_OPCODE(

)) {

(compiler, ins |

(dst_freg) |

(src1_freg) |

(src2_freg));

(check_sljit_emit_atomic_load(compiler, op, dst_reg, mem_reg));

(GET_OPCODE(op)) {

ins =

^ (1 << 30);

(GET_OPCODE(op)) {

ins =

^ (1 << 30);

(compiler, ins |

(mem_reg) |

(dst_reg));

(check_sljit_emit_atomic_store(compiler, op, src_reg, mem_reg, temp_reg));

(GET_OPCODE(op)) {

ins =

^ (1 << 30);

(GET_OPCODE(op)) {

ins =

^ (1 << 30);

(check_sljit_get_local_base(compiler, dst, dstw,

));

dst_reg = FAST_IS_REG(dst) ? dst :

;

(offset <= 0xffffff && offset >= -0xffffff) {

CHECK_PTR(check_sljit_emit_const(compiler, dst, dstw, init_value));

ADJUST_LOCAL_OFFSET(dst, dstw);

set_const(const_, compiler);

dst_r = FAST_IS_REG(dst) ? dst :

;

CHECK_PTR(check_sljit_emit_mov_addr(compiler, dst, dstw));

ADJUST_LOCAL_OFFSET(dst, dstw);

dst_r = FAST_IS_REG(dst) ? dst :

;

set_mov_addr(jump, compiler, 1);

compiler->

+= 3;

dst = inst[0] & 0x1f;

((inst[0] & 0xffe00000) ==

&& (inst[1] & 0xffe00000) == (

| (1 << 21)));

inst[0] =

| dst | (((

)new_target & 0xffff) << 5);

inst[1] =

| dst | (((

)(new_target >> 16) & 0xffff) << 5) | (1 << 21);

inst[2] =

| dst | (((

)(new_target >> 32) & 0xffff) << 5) | (2 << 21);

inst[3] =

| dst | ((

)(new_target >> 48) << 5) | (3 << 21);

inst = (

*)SLJIT_ADD_EXEC_OFFSET(inst, executable_offset);

ncbi::TMaskedQueryRegions mask

#define CHECK_ERROR(name, s)

static DLIST_TYPE *DLIST_NAME() first(DLIST_LIST_TYPE *list)

static DLIST_TYPE *DLIST_NAME() prev(DLIST_LIST_TYPE *list, DLIST_TYPE *item)

static const char label[]

const struct ncbi::grid::netcache::search::fields::SIZE size

const GenericPointer< typename T::ValueType > T2 value

#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_UNUSED_ARG(arg)

#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_ARG_TYPE_SCRATCH_REG

#define SLJIT_SIMD_OP2_AND

#define SLJIT_ORDERED_LESS_EQUAL

#define SLJIT_CONV_F64_FROM_S32

#define SLJIT_CONV_S32_FROM_F64

#define SLJIT_FAST_RETURN

#define SLJIT_SIMD_REG_64

#define SLJIT_ATOMIC_NOT_STORED

#define SLJIT_FIRST_SAVED_REG

#define SLJIT_CONV_F64_FROM_U32

#define SLJIT_UNORDERED_OR_GREATER

#define SLJIT_ORDERED_GREATER_EQUAL

#define SLJIT_PREFETCH_L3

#define SLJIT_SIG_GREATER_EQUAL

#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_ORDERED_GREATER

#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_FIRST_SAVED_FLOAT_REG

#define SLJIT_SIMD_OP2_OR

#define SLJIT_SHIFT_INTO_NON_ZERO

#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_COPY_TO_F64

#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_UNORDERED_OR_GREATER_EQUAL

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)

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)

static const sljit_u8 freg_map[SLJIT_NUMBER_OF_FLOAT_REGISTERS+3]

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)

SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_has_cpu_feature(sljit_s32 feature_type)

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)

SLJIT_API_FUNC_ATTRIBUTE struct sljit_label * sljit_emit_label(struct sljit_compiler *compiler)

SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_cmp_info(sljit_s32 type)

static sljit_s32 load_immediate(struct sljit_compiler *compiler, sljit_s32 dst, sljit_sw simm)

SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_get_local_base(struct sljit_compiler *compiler, sljit_s32 dst, sljit_sw dstw, sljit_sw offset)

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_ins get_cc(struct sljit_compiler *compiler, sljit_s32 type)

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)

SLJIT_API_FUNC_ATTRIBUTE void sljit_set_const(sljit_uw addr, sljit_sw new_constant, sljit_sw executable_offset)

static 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_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)

#define CHECK_FLAGS(flag_bits)

SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_ijump(struct sljit_compiler *compiler, sljit_s32 type, sljit_s32 src, sljit_sw srcw)

SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump * sljit_emit_mov_addr(struct sljit_compiler *compiler, sljit_s32 dst, sljit_sw dstw)

SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_fset32(struct sljit_compiler *compiler, sljit_s32 freg, sljit_f32 value)

static sljit_s32 push_inst(struct sljit_compiler *compiler, sljit_ins ins)

#define COUNT_TRAILING_ZERO(value, result)

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)

static SLJIT_INLINE sljit_ins * detect_jump_type(struct sljit_jump *jump, sljit_ins *code_ptr, sljit_ins *code, sljit_sw executable_offset)

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)

SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_op0(struct sljit_compiler *compiler, sljit_s32 op)

static SLJIT_INLINE sljit_s32 emit_imm64_const(struct sljit_compiler *compiler, sljit_s32 dst, sljit_uw imm)

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)

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)

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)

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)

static sljit_ins logical_imm(sljit_sw imm, sljit_u32 len)

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_INLINE struct sljit_jump * emit_cmp_to0(struct sljit_compiler *compiler, sljit_s32 type, sljit_s32 src, sljit_sw srcw)

static sljit_s32 emit_fop_mem(struct sljit_compiler *compiler, sljit_s32 flags, sljit_s32 reg, sljit_s32 arg, sljit_sw argw)

#define LOGICAL_IMM_CHECK

SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_fset64(struct sljit_compiler *compiler, sljit_s32 freg, sljit_f64 value)

static sljit_s32 emit_op_imm(struct sljit_compiler *compiler, sljit_s32 flags, sljit_s32 dst, sljit_sw arg1, sljit_sw arg2)

SLJIT_API_FUNC_ATTRIBUTE void sljit_set_jump_addr(sljit_uw addr, sljit_uw new_target, sljit_sw executable_offset)

static sljit_s32 emit_stack_frame_release(struct sljit_compiler *compiler, sljit_s32 is_return_to)

SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_op_dst(struct sljit_compiler *compiler, sljit_s32 op, sljit_s32 dst, sljit_sw dstw)

#define MEM_SIZE_SHIFT(flags)

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)

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)

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)

static const sljit_u8 reg_map[SLJIT_NUMBER_OF_REGISTERS+8]

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_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 SLJIT_INLINE sljit_sw mov_addr_get_length(struct sljit_jump *jump, sljit_ins *code_ptr, sljit_ins *code, sljit_sw executable_offset)

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)

SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_fmem_update(struct sljit_compiler *compiler, sljit_s32 type, sljit_s32 freg, sljit_s32 mem, sljit_sw memw)

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)

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

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