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__32_8c_source.html below:

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

0, 0, 1, 2, 3, 11, 10, 9, 8, 7, 6, 5, 4, 13, 12, 14, 15

0, 1, 2, 3, 4, 5, 15, 14, 13, 12, 11, 10, 9, 8,

0, 1, 2, 3, 4, 5, 15, 14, 13, 12, 11, 10, 9, 8,

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

(compiler->cpool_fill > 0 && compiler->cpool_fill <= CPOOL_SIZE);

*inst = 0xff000000 | compiler->cpool_fill;

cpool_ptr = compiler->cpool;

cpool_end = cpool_ptr + compiler->cpool_fill;

(cpool_ptr < cpool_end) {

*inst = *cpool_ptr++;

compiler->cpool_fill = 0;

(push_cpool(compiler));

(push_cpool(compiler));

(compiler->cpool_fill > 0) {

cpool_ptr = compiler->cpool;

cpool_end = cpool_ptr + compiler->cpool_fill;

cpool_unique_ptr = compiler->cpool_unique;

((*cpool_ptr ==

) && !(*cpool_unique_ptr)) {

cpool_index = (

)(cpool_ptr - compiler->cpool);

}

(cpool_ptr < cpool_end);

(cpool_index == CPOOL_SIZE) {

(compiler->cpool_fill < CPOOL_SIZE) {

cpool_index = compiler->cpool_fill;

compiler->cpool_fill++;

(push_cpool(compiler));

compiler->cpool_fill = 1;

*ptr = inst | cpool_index;

compiler->cpool[cpool_index] =

;

compiler->cpool_unique[cpool_index] = 0;

compiler->cpool_diff = compiler->

;

(push_cpool(compiler));

(compiler->cpool_fill < CPOOL_SIZE && (inst & 0xfff) == 0);

*ptr = inst | compiler->cpool_fill;

compiler->cpool[compiler->cpool_fill] =

;

compiler->cpool_unique[compiler->cpool_fill] = 1;

compiler->cpool_fill++;

compiler->cpool_diff = compiler->

;

push_cpool(compiler);

* clear_const_pool = const_pool;

* clear_const_pool_end = const_pool + cpool_size;

(clear_const_pool < clear_const_pool_end)

*clear_const_pool++ = (

)(-1);

(last_pc_patch < code_ptr) {

((*last_pc_patch & 0x0e0f0000) == 0x040f0000) {

diff = (

)(const_pool - last_pc_patch);

ind = (*last_pc_patch) & 0xfff;

(ind < cpool_size && !(*last_pc_patch & (1 << 25)) && (*last_pc_patch & (1 << 20)));

const_pool[ind] = counter;

ind = const_pool[ind];

(diff >= 2 || ind > 0) {

diff = (diff + (

)ind - 2) << 2;

*last_pc_patch = (*last_pc_patch & ~(

)0xfff) | diff;

*last_pc_patch = (*last_pc_patch & ~(

)(0xfff | (1 << 23))) | 0x004;

future_patch {

future_patch*

;

future_patch *curr_patch, *prev_patch;

= cpool_start_address[cpool_current_index];

curr_patch = *first_patch;

= cpool_start_address[cpool_current_index];

((

)curr_patch->index == cpool_current_index) {

prev_patch->next = curr_patch->next;

*first_patch = curr_patch->next;

prev_patch = curr_patch;

curr_patch = curr_patch->next;

(

> cpool_current_index) {

(*first_patch) {

curr_patch = *first_patch;

*first_patch = (*first_patch)->next;

curr_patch->next = *first_patch;

curr_patch->value = (

)cpool_start_address[

];

*first_patch = curr_patch;

cpool_start_address[

] = *buf_ptr;

(jump->

& IS_BL)

(jump->

& JUMP_ADDR)

(jump->

& IS_BL) {

(diff <= 0x01ffffff && diff >= -0x02000000) {

jump->

|= PATCH_B;

(diff <= 0x01ffffff && diff >= -0x02000000) {

jump->

|= PATCH_B;

(diff <= 0x01ffffff && diff >= -0x02000000) {

jump->

|= PATCH_B;

(diff <= 0x7fffff && diff >= -0x800000) {

inst = (

*)SLJIT_ADD_EXEC_OFFSET(inst, executable_offset);

inst = (

*)SLJIT_ADD_EXEC_OFFSET(inst, executable_offset);

(mov_pc & (1 << 23))

ptr = inst + ((mov_pc & 0xfff) >> 2) + 2;

(*inst != mov_pc) {

inst = (

*)SLJIT_ADD_EXEC_OFFSET(inst, executable_offset);

inst = (

*)SLJIT_ADD_EXEC_OFFSET(inst, executable_offset);

inst[0] =

| (inst[0] & 0xf000) | ((new_addr << 4) & 0xf0000) | (new_addr & 0xfff);

inst[1] =

| (inst[1] & 0xf000) | ((new_addr >> 12) & 0xf0000) | ((new_addr >> 16) & 0xfff);

inst = (

*)SLJIT_ADD_EXEC_OFFSET(inst, executable_offset);

*inst = 0xe3a00000 | (ldr_literal & 0xf000) | src2;

inst = (

*)SLJIT_ADD_EXEC_OFFSET(inst, executable_offset);

src2 =

(~new_constant);

*inst = 0xe3e00000 | (ldr_literal & 0xf000) | src2;

inst = (

*)SLJIT_ADD_EXEC_OFFSET(inst, executable_offset);

(ldr_literal & (1 << 23))

ptr = inst + ((ldr_literal & 0xfff) >> 2) + 2;

(*inst != ldr_literal) {

inst = (

*)SLJIT_ADD_EXEC_OFFSET(inst, executable_offset);

inst[0] =

| (inst[0] & 0xf000) | ((new_constant << 4) & 0xf0000) | (new_constant & 0xfff);

inst[1] =

| (inst[1] & 0xf000) | ((new_constant >> 12) & 0xf0000) | ((new_constant >> 16) & 0xfff);

inst = (

*)SLJIT_ADD_EXEC_OFFSET(inst, executable_offset);

(jump->

& JUMP_ADDR)

((diff & 0x3) == 0 && diff <= (0x3fc + 2 * SSIZE_OF(ins)) && diff >= (-0x3fc + 2 * SSIZE_OF(ins))) {

jump->

|= PATCH_B;

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)) {

(diff <= (0x01ffffff / SSIZE_OF(ins)) && diff >= (-0x02000000 / SSIZE_OF(ins)))

size_reduce += JUMP_MAX_SIZE - 1 -

;

(!(jump->

& JUMP_ADDR)) {

(diff <= 0xff + 2 && diff >= -0xff + 2)

next_jump_addr = SLJIT_GET_NEXT_ADDRESS(jump);

compiler->

-= size_reduce;

SLJIT_NEXT_DEFINE_TYPES;

future_patch *first_patch;

CHECK_PTR(check_sljit_generate_code(compiler));

compiler->

+= (compiler->patches << 1);

(compiler->cpool_fill > 0)

= (

*)allocate_executable_memory(compiler->

*

(

), options, exec_allocator_data, &executable_offset);

reverse_buf(compiler);

cpool_skip_alignment = 0;

cpool_current_index = 0;

cpool_start_address =

;

last_pc_patch =

;

jump = compiler->

;

const_ = compiler->

;

SLJIT_NEXT_INIT_TYPES();

SLJIT_GET_NEXT_MIN();

buf_end = buf_ptr + (

->used_size >> 2);

(cpool_size > 0) {

(cpool_skip_alignment > 0) {

cpool_skip_alignment--;

(

(resolve_const_pool_index(compiler, &first_patch, cpool_current_index, cpool_start_address, buf_ptr))) {

SLJIT_FREE_EXEC(

, exec_allocator_data);

(++cpool_current_index >= cpool_size) {

}

((*buf_ptr & 0xff000000) !=

) {

*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 += jump->

>> JUMP_SIZE_SHIFT;

code_ptr[2] = code_ptr[0];

= ((code_ptr[0] & 0xf) << 12);

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();

cpool_current_index = patch_pc_relative_loads(last_pc_patch, code_ptr, cpool_start_address, cpool_size);

(cpool_current_index > 0) {

*code_ptr =

| (((

)(cpool_start_address - code_ptr) + cpool_current_index - 2) & ~

);

code_ptr = (

*)(cpool_start_address + cpool_current_index);

cpool_current_index = 0;

last_pc_patch = code_ptr;

}

(buf_ptr < buf_end);

->u.addr = (

)SLJIT_ADD_EXEC_OFFSET(code_ptr, executable_offset);

(compiler->cpool_fill > 0) {

cpool_current_index = patch_pc_relative_loads(last_pc_patch, code_ptr, cpool_start_address, compiler->cpool_fill);

(cpool_current_index > 0)

code_ptr = (

*)(cpool_start_address + cpool_current_index);

buf_ptr = compiler->cpool;

buf_end = buf_ptr + compiler->cpool_fill;

cpool_current_index = 0;

(buf_ptr < buf_end) {

(

(resolve_const_pool_index(compiler, &first_patch, cpool_current_index, cpool_start_address, buf_ptr))) {

SLJIT_FREE_EXEC(

, exec_allocator_data);

cpool_current_index++;

jump = compiler->

;

(jump->

& JUMP_MOV_ADDR) {

(jump->

& PATCH_B) {

diff = ((

)

- (

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

buf_ptr[0] =

| (buf_ptr[0] & 0xf000) |

(

) | (1 << 25) | (0xf << 8) | (

)(diff & 0xff);

buf_ptr[((buf_ptr[0] & 0xfff) >> 2) + 2] =

;

buf_ptr[1] =

| buf_ptr[0] | ((

>> 12) & 0xf0000) | ((

>> 16) & 0xfff);

buf_ptr[0] =

| buf_ptr[0] | ((

<< 4) & 0xf0000) | (

& 0xfff);

}

(jump->

& PATCH_B) {

(diff <= 0x01ffffff && diff >= -0x02000000);

*buf_ptr |= (diff >> 2) & 0x00ffffff;

(jump->

& IS_BL)

code_ptr[1] = *buf_ptr;

(*buf_ptr & (1 << 23))

buf_ptr += ((*buf_ptr & 0xfff) >> 2) + 2;

jump = jump->

;

const_ = compiler->

;

code_ptr[1] = *buf_ptr;

(*buf_ptr & (1 << 23))

buf_ptr += ((*buf_ptr & 0xfff) >> 2) + 2;

const_ = const_->

;

code_ptr = (

*)SLJIT_ADD_EXEC_OFFSET(code_ptr, executable_offset);

(feature_type) {

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);

= GET_SAVED_REGISTERS_SIZE(scratches, saveds - saved_arg_count, 1);

((

& SSIZE_OF(

)) != 0) {

(fsaveds + fscratches >= SLJIT_NUMBER_OF_FLOAT_REGISTERS) {

local_size = ((

+ local_size + 0x7) & ~0x7) -

;

saved_arg_count = 0;

float_arg_count = 0;

(arg_types & SLJIT_ARG_MASK) {

= word_arg_count;

compiler->args_size =

;

(arg_types & SLJIT_ARG_MASK) {

(

!= old_offset)

(f32_offset != 0) {

(

!= old_offset)

f32_offset = old_offset;

(remap_ptr > remap)

(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);

= GET_SAVED_REGISTERS_SIZE(scratches, saveds - SLJIT_KEPT_SAVEDS_COUNT(options), 1);

fsaveds = compiler->

;

(fsaveds + fscratches >= SLJIT_NUMBER_OF_FLOAT_REGISTERS) {

local_size = GET_SAVED_REGISTERS_SIZE(compiler->

, compiler->

, 1) & 0x7;

(frame_size < 0) {

}

(frame_size > 0) {

(frame_size == 1 || (frame_size & 0x7) == 0);

}

(--

>

);

(lr_dst ==

&& reg_list == 0) {

(lr_dst == 0 && (reg_list & (reg_list - 1)) == 0) {

(reg_list != 0) {

(local_size <= 0xfff) {

(local_size == 0) {

(frame_size == 0)

(frame_size > 2 * SSIZE_OF(

))

}

(frame_size == 0) {

frame_size = (restored_reg ==

) ? SSIZE_OF(

) : 2 * SSIZE_OF(

);

local_size += SSIZE_OF(

);

local_size += SSIZE_OF(

);

(frame_size > local_size)

(frame_size < local_size)

frame_size -= SSIZE_OF(

);

frame_size -= SSIZE_OF(

);

= (restored_reg ==

) ? 0x800004 : 0x800008;

((reg_list & (reg_list - 1)) == 0) {

(check_sljit_emit_return_void(compiler));

(check_sljit_emit_return_to(compiler, src, srcw));

SLJIT_SKIP_CHECKS(compiler);

|

(dst) |

(src1) | ((src2 &

) ? src2 :

(src2)));

|

(dst) |

(src1) | ((src2 &

) ? src2 :

(src2)));

compiler->status_flags_state = 0;

|

(dst) |

(src1) | ((src2 &

) ? src2 :

(src2)));

(compiler->shift_imm == 0x20) {

compiler->shift_imm = (

)(-(

)compiler->shift_imm) & 0x1f;

(compiler->shift_imm != 0x20) {

(compiler->shift_imm != 0)

(dst) | (compiler->shift_imm << 7) | (shift_type << 5) |

(src2));

|

(src2) | (

)(shift_type << 5) | 0x10 |

(src1));

(!(imm & 0xff000000)) {

imm = (imm << 24) | (imm >> 8);

(!(imm & 0xff000000)) {

(!(imm & 0xf0000000)) {

(!(imm & 0xc0000000)) {

(!(imm & 0x00ffffff))

| (imm >> 24) | (rol << 8);

(!(imm &

)) {

imm = (imm << rol) | (imm >> (32 - rol));

rol = 4 + (rol >> 1);

imm = (imm << 8) | (imm >> 24);

(!(imm &

)) {

imm = (imm << rol) | (imm >> (32 - rol));

rol = (rol >> 1) - 8;

(!(imm & 0xff000000)) {

imm1 =

| ((imm >> 16) & 0xff) | (((rol + 4) & 0xf) << 8);

*imm2 =

| ((imm >> 8) & 0xff) | (((rol + 8) & 0xf) << 8);

}

(imm & 0xc0000000) {

imm1 =

| ((imm >> 24) & 0xff) | ((rol & 0xf) << 8);

(!(imm & 0xff000000)) {

(!(imm & 0xf0000000)) {

(!(imm & 0xc0000000)) {

(!(imm & 0x00ffffff))

*imm2 =

| (imm >> 24) | ((rol & 0xf) << 8);

(!(imm & 0xf0000000)) {

(!(imm & 0xc0000000)) {

imm1 =

| ((imm >> 24) & 0xff) | ((rol & 0xf) << 8);

(!(imm & 0xf0000000)) {

(!(imm & 0xc0000000)) {

(!(imm & 0x00ffffff))

*imm2 =

| (imm >> 24) | ((rol & 0xf) << 8);

(compiler,

|

(reg) | ((imm << 4) & 0xf0000) | (imm & 0xfff));

(compiler,

|

(reg) | ((imm >> 12) & 0xf0000) | ((imm >> 16) & 0xfff));

(arg & OFFS_REG_MASK) {

offset_reg = OFFS_REG(arg);

(argw != 0 && (

== 0xff)) {

(offset_reg) | (

== 0xff ? 0 : (1 << 25)) | ((

)argw << 7)));

}

(argw < -

) {

(argw <= mask && argw >= -

) {

(tmp_reg) | (

== 0xff ? 0 : (1 << 25))));

op = GET_OPCODE(op);

op = neg_op | GET_ALL_FLAGS(op);

op = neg_op | GET_ALL_FLAGS(op);

dst_reg = FAST_IS_REG(dst) ? dst :

;

(FAST_IS_REG(src2))

(FAST_IS_REG(src2) && dst_reg !=

)

src2_tmp_reg = dst_reg;

(src2_reg == 0 && (src2 &

)) {

src2_reg = src2_tmp_reg;

(FAST_IS_REG(src1))

(src2_reg == 0) {

src2_reg = src2_tmp_reg;

(FAST_IS_REG(src2))

(src1_reg == 0) {

(src2_reg == 0 && neg_op != 0) {

(src2_reg == 0) {

src2_reg = src2_tmp_reg;

(src1_reg == 0) {

(src1_reg == 0 && neg_op != 0) {

(src1_reg == 0) {

__aeabi_uidivmod(

numerator,

denominator);

__aeabi_idivmod(

numerator,

denominator);

(check_sljit_emit_op0(compiler, op));

op = GET_OPCODE(op);

saved_reg_count = 0;

saved_reg_list[saved_reg_count++] = 3;

saved_reg_list[saved_reg_count++] = 2;

saved_reg_list[saved_reg_count++] = 1;

(saved_reg_count > 0) {

| (saved_reg_list[0] << 12)

));

(saved_reg_count >= 2) {

(saved_reg_count >= 3) {

(saved_reg_count > 0) {

(saved_reg_count >= 3) {

(saved_reg_count >= 2) {

(compiler, (

^ (1 << 24)) | 0x8d0000 | (

)(saved_reg_count >= 3 ? 16 : 8)

| (saved_reg_list[0] << 12)

);

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

ADJUST_LOCAL_OFFSET(dst, dstw);

ADJUST_LOCAL_OFFSET(src, srcw);

(GET_OPCODE(op)) {

(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);

(GET_OPCODE(op)) {

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

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

compiler->shift_imm = src2w & 0x1f;

(compiler, op, 0, dst, dstw,

, 0, src1, src1w);

compiler->shift_imm = 0x20;

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

(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));

ADJUST_LOCAL_OFFSET(src1, src1w);

ADJUST_LOCAL_OFFSET(src2, src2w);

(GET_OPCODE(op)) {

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

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

op = GET_OPCODE(op);

(src1_reg == src2_reg) {

SLJIT_SKIP_CHECKS(compiler);

ADJUST_LOCAL_OFFSET(src3, src3w);

src3w = (src3w ^ 0x1f) + 1;

(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))

((

& SSIZE_OF(

)) == 0)

dst_r = FAST_IS_REG(dst) ? dst :

;

CHECK_REG_INDEX(check_sljit_get_register_index(

, reg));

(check_sljit_emit_op_custom(compiler, instruction,

));

(!(argw & ~0x3fc))

(!(-argw & ~0x3fc))

(FAST_IS_REG(dst))

(FAST_IS_REG(src))

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

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) {

ins = ((u.imm >> 24) & 0x80) | ((u.imm >> 19) & 0x7f);

(compiler, (

^ (1 << 6)) | ((ins & 0xf0) << 12) |

(freg) | (ins & 0xf));

(check_sljit_emit_fset64(compiler, freg,

));

(u.imm[0] == 0 && (u.imm[1] << (64 - 48)) == 0) {

exp = (u.imm[1] >> ((52 - 32) + 2)) & 0x1ff;

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

ins = ((u.imm[1] >> (56 - 32)) & 0x80) | ((u.imm[1] >> (48 - 32)) & 0x7f);

(compiler, (

^ (1 << 6)) | (1 << 8) | ((ins & 0xf0) << 12) |

(freg) | (ins & 0xf));

(u.imm[0] == u.imm[1])

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

(reg & REG_PAIR_MASK) {

reg2 = REG_PAIR_SECOND(reg);

reg = REG_PAIR_FIRST(reg);

inst =

|

(freg) |

(reg);

CHECK_PTR(check_sljit_emit_label(compiler));

set_label(

, compiler);

CHECK_PTR(check_sljit_emit_jump(compiler,

));

compiler->patches++;

jump->

|= IS_BL;

jump->

|= IS_BL;

compiler->

+= JUMP_MAX_SIZE - 1;

(src && FAST_IS_REG(*src))

(arg_types & SLJIT_ARG_MASK) {

word_arg_offset +=

(

);

(

& SLJIT_ARG_MASK) {

= *(--offset_ptr);

| (float_arg_count << 12) | ((

- 4 *

(

)) >> 2)));

= *(--offset_ptr);

(src_offset ==

) {

| (float_arg_count << 12) | ((

- 4 *

(

)) >> 2)));

word_arg_offset -=

(

);

= *(--offset_ptr);

(

!= word_arg_offset) {

(src_offset ==

) {

(src_offset == word_arg_offset) {

(arg_types & SLJIT_ARG_MASK) {

(

!= new_offset)

(f32_offset != 0) {

0x400000, f32_offset,

, 0)));

(

!= new_offset)

0, new_offset,

, 0)));

f32_offset = new_offset;

CHECK_PTR(check_sljit_emit_call(compiler,

, arg_types));

(softfloat_call_with_args(compiler, arg_types,

, &extra_space));

SLJIT_SKIP_CHECKS(compiler);

(extra_space > 0) {

(softfloat_post_call_with_args(compiler, arg_types));

SLJIT_SKIP_CHECKS(compiler);

(check_sljit_emit_ijump(compiler,

, src, srcw));

ADJUST_LOCAL_OFFSET(src, srcw);

(FAST_IS_REG(src)) {

(prepare_blx(compiler));

compiler->

+= JUMP_MAX_SIZE - 1;

(check_sljit_emit_icall(compiler,

, arg_types, src, srcw));

(softfloat_call_with_args(compiler, arg_types, &src, &extra_space));

SLJIT_SKIP_CHECKS(compiler);

(extra_space > 0) {

softfloat_post_call_with_args(compiler, arg_types);

SLJIT_SKIP_CHECKS(compiler);

SLJIT_SKIP_CHECKS(compiler);

(FAST_IS_REG(src)) {

SLJIT_SKIP_CHECKS(compiler);

(check_sljit_emit_op_flags(compiler, op, dst, dstw,

));

ADJUST_LOCAL_OFFSET(dst, dstw);

op = GET_OPCODE(op);

dst_reg = FAST_IS_REG(dst) ? dst :

;

(check_sljit_emit_select(compiler,

, dst_reg, src1, src1w, src2_reg));

ADJUST_LOCAL_OFFSET(src1, src1w);

(src2_reg != dst_reg && src1 == dst_reg) {

(src2_reg != dst_reg) {

}

(dst_reg != src2_reg)

(check_sljit_emit_fselect(compiler,

, dst_freg, src1, src1w, src2_freg));

ADJUST_LOCAL_OFFSET(src1, src1w);

(dst_freg != src2_freg) {

(dst_freg == src1) {

(argw <= max_offset && argw >= -

) {

(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);

(REG_PAIR_FIRST(reg) == (mem & REG_MASK)) {

(check_sljit_emit_mem_update(compiler,

, reg, mem, memw));

is_type1_transfer = 1;

(

& 0xff) {

is_type1_transfer = 0;

is_type1_transfer = 0;

is_type1_transfer = 0;

(!is_type1_transfer && memw != 0)

(is_type1_transfer) {

(memw > 4095 || memw < -4095)

}

(memw > 255 || memw < -255)

(is_type1_transfer)

(is_type1_transfer) {

(check_sljit_emit_fmem(compiler,

, freg, mem, memw));

(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);

| (

)((reg_size == 3) ? (0x7 << 8) : (0xa << 8));

(alignment >= 3)

(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)

(compiler,

| ((reg_size == 4) ? (1 << 6) : 0) |

(freg));

}

(freg != src)

(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 << 6);

(elem_size == 3 && !(srcdst &

)) {

(lane_index == 1)

(reg_size == 4 && lane_index >= (0x8 >> elem_size)) {

lane_index -= (0x8 >> elem_size);

lane_index = lane_index << elem_size;

ins = (

)((elem_size << 10) | (lane_index << 5));

(elem_size == 3) {

(lane_index == 1)

(elem_size == 1)

lane_index = lane_index << elem_size;

ins |= (

)(((lane_index & 0x4) << 19) | ((lane_index & 0x3) << 5));

(check_sljit_emit_simd_lane_replicate(compiler,

, freg, src, src_lane_index));

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

(reg_size == 4) {

(src_lane_index >= (0x8 >> elem_size)) {

src_lane_index -= (0x8 >> elem_size);

(elem_size == 3) {

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)

}

(reg_size == 4)

dst_reg = (reg_size == 4) ? freg :

;

| ((

)1 << (19 + elem_size)) |

(dst_reg) |

(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 =

| (1 << 24) | (0x9 << 16);

imms = (reg_size == 4) ? 0x243219 : 0x2231;

ins =

| (1 << 24) | (0x11 << 16);

imms = (reg_size == 4) ? 0x2231 : 0x21;

ins =

| (1 << 24) | (0x21 << 16);

ins =

| (1 << 24) | (0x1 << 16) | (1 << 7);

(reg_size == 4) {

(reg_size == 4 && elem_size > 0)

ins = (reg_size == 4 && elem_size == 0) ? (1 << 6) : 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(

)) {

(reg_size == 4) {

(compiler, ins |

(dst_freg) |

(src1_freg) |

(src2_freg));

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

(GET_OPCODE(op)) {

(compiler, ins |

(mem_reg) |

(dst_reg));

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

(GET_OPCODE(op)) {

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 :

;

(push_inst_with_unique_literal(compiler,

compiler->patches++;

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

ADJUST_LOCAL_OFFSET(dst, dstw);

dst_r = FAST_IS_REG(dst) ? dst :

;

compiler->patches++;

set_mov_addr(jump, compiler, 1);

compiler->

+= 1;

ncbi::TMaskedQueryRegions mask

#define CHECK_ERROR(name, s)

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

static const struct type types[]

CTempString literal(const char(&str)[Size])

Templatized initialization from a string literal.

static const char label[]

if(yy_accept[yy_current_state])

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_MALLOC(size, allocator_data)

#define SLJIT_FREE(ptr, allocator_data)

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

#define SLJIT_SIMD_REGS_ARE_PAIRS

#define SLJIT_SIG_LESS_EQUAL

#define SLJIT_UNORDERED_OR_EQUAL

#define SLJIT_ERR_ALLOC_FAILED

#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

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)

#define EMIT_DATA_TRANSFER(type, add, target_reg, base_reg, arg)

SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump * sljit_emit_jump(struct sljit_compiler *compiler, sljit_s32 type)

static SLJIT_INLINE sljit_s32 emit_imm(struct sljit_compiler *compiler, sljit_s32 reg, sljit_sw imm)

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)

static sljit_uw compute_imm(sljit_uw imm, sljit_uw *imm2)

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 load_immediate(struct sljit_compiler *compiler, sljit_s32 reg, sljit_uw imm)

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)

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_s32 push_inst(struct sljit_compiler *compiler, sljit_ins inst)

SLJIT_API_FUNC_ATTRIBUTE struct sljit_label * sljit_emit_label(struct sljit_compiler *compiler)

#define CONST_POOL_ALIGNMENT

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)

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)

static const sljit_u8 freg_map[((SLJIT_NUMBER_OF_FLOAT_REGISTERS+2)<< 1)+1]

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 MAX_DIFFERENCE(max_diff)

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)

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

static SLJIT_INLINE sljit_s32 emit_single_op(struct sljit_compiler *compiler, sljit_s32 op, sljit_s32 flags, sljit_uw dst, sljit_uw src1, sljit_uw src2)

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)

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)

static void set_const_value(sljit_uw addr, sljit_sw executable_offset, sljit_uw new_constant, sljit_s32 flush_cache)

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_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 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 void set_jump_addr(sljit_uw jump_ptr, sljit_sw executable_offset, sljit_uw new_addr, sljit_s32 flush_cache)

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)

#define EMIT_FPU_DATA_TRANSFER(inst, add, base, freg, offs)

#define ALIGN_INSTRUCTION(ptr)

static sljit_s32 emit_op(struct sljit_compiler *compiler, sljit_s32 op, sljit_s32 inp_flags, sljit_s32 dst, sljit_sw dstw, sljit_s32 src1, sljit_sw src1w, sljit_s32 src2, sljit_sw src2w)

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)

static const sljit_ins data_transfer_insts[16]

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 SLJIT_INLINE sljit_s32 detect_jump_type(struct sljit_jump *jump, sljit_uw *code_ptr, sljit_uw *code, sljit_sw executable_offset)

#define IS_TYPE1_TRANSFER(type)

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)

#define EMIT_FPU_OPERATION(opcode, mode, dst, src1, src2)

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

#define TYPE2_TRANSFER_IMM(imm)

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)

static void reduce_code_size(struct sljit_compiler *compiler)

#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