30 #define ENABLE_STATIC_FACILITY_DETECTION 1
32 #define ENABLE_STATIC_FACILITY_DETECTION 0
34 #define ENABLE_DYNAMIC_FACILITY_DETECTION 1
38 return "s390x" SLJIT_CPUINFO;
47 #define TMP_REG1 (SLJIT_NUMBER_OF_REGISTERS + 2)
48 #define TMP_REG2 (SLJIT_NUMBER_OF_REGISTERS + 3)
51 0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 15, 0, 1
104 #define IS_GPR_REG(reg) ((reg > 0) && (reg) <= SLJIT_SP)
112 #define TMP_FREG1 (0)
115 1, 0, 2, 4, 6, 3, 5, 7, 15, 14, 13, 12, 11, 10, 9, 8,
119 #define R4A(r) ((r) << 4)
120 #define R8A(r) ((r) << 8)
121 #define R12A(r) ((r) << 12)
122 #define R16A(r) ((r) << 16)
123 #define R20A(r) ((r) << 20)
124 #define R28A(r) ((r) << 28)
125 #define R32A(r) ((r) << 32)
126 #define R36A(r) ((r) << 36)
128 #define R0(r) ((sljit_ins)reg_map[r])
130 #define F0(r) ((sljit_ins)freg_map[r])
131 #define F4(r) (R4A((sljit_ins)freg_map[r]))
132 #define F20(r) (R20A((sljit_ins)freg_map[r]))
133 #define F36(r) (R36A((sljit_ins)freg_map[r]))
160 if ((ins & 0x00000000ffffL) == ins)
162 if ((ins & 0x0000ffffffffL) == ins)
164 if ((ins & 0xffffffffffffL) == ins)
200 #define SLJIT_ADD_SUB_NO_COMPARE(status_flags_state) \
201 (((status_flags_state) & (SLJIT_CURRENT_FLAGS_ADD | SLJIT_CURRENT_FLAGS_SUB)) \
202 && !((status_flags_state) & SLJIT_CURRENT_FLAGS_COMPARE))
214 sljit_s32 type = GET_FLAG_TYPE(compiler->status_flags_state);
228 sljit_s32 type = GET_FLAG_TYPE(compiler->status_flags_state);
230 return (cc1 | cc2 | cc3);
238 return (cc1 | cc2 | cc3);
244 return (cc0 | cc2 | cc3);
254 return (cc0 | cc1 | cc2);
279 return (cc0 | cc2 | cc3);
295 return (cc0 | cc1 | cc2);
311 #define STORE_FACILITY_LIST_EXTENDED_FACILITY 7
312 #define FAST_LONG_DISPLACEMENT_FACILITY 19
313 #define EXTENDED_IMMEDIATE_FACILITY 21
314 #define GENERAL_INSTRUCTION_EXTENSION_FACILITY 34
315 #define DISTINCT_OPERAND_FACILITY 45
316 #define HIGH_WORD_FACILITY 45
317 #define POPULATION_COUNT_FACILITY 45
318 #define LOAD_STORE_ON_CONDITION_1_FACILITY 45
319 #define MISCELLANEOUS_INSTRUCTION_EXTENSIONS_1_FACILITY 49
320 #define LOAD_STORE_ON_CONDITION_2_FACILITY 53
321 #define MISCELLANEOUS_INSTRUCTION_EXTENSIONS_2_FACILITY 58
322 #define VECTOR_FACILITY 129
323 #define VECTOR_ENHANCEMENTS_1_FACILITY 135
330 #if ENABLE_STATIC_FACILITY_DETECTION
333 return (__ARCH__ >= 6 );
336 return (__ARCH__ >= 7 );
338 return (__ARCH__ >= 8 );
340 return (__ARCH__ >= 9 );
342 return (__ARCH__ >= 10 );
345 return (__ARCH__ >= 11 );
348 return (__ARCH__ >= 12 );
358 static unsigned long hwcap = 0;
360 hwcap = getauxval(AT_HWCAP);
371 return (get_hwcap() & HWCAP_S390_STFLE);
378 #if ENABLE_DYNAMIC_FACILITY_DETECTION
382 size_t size =
sizeof(cpu_features);
384 const sljit_uw bit_index = ((1UL << 63) >> (
x & 63));
391 __asm__ __volatile__ (
395 :
"d" ((
size / 8) - 1),
"a" (&cpu_features)
396 :
"r0",
"cc",
"memory"
400 return (cpu_features.bits[word_index] & bit_index) != 0;
406 #define HAVE_FACILITY(name, bit) \
407 static SLJIT_INLINE int name() \
409 static int have = -1; \
411 if (have_facility_static(bit)) \
413 else if (SLJIT_UNLIKELY(have < 0)) \
414 have = have_facility_dynamic(bit) ? 1 : 0; \
427 #define is_u12(d) (0 <= (d) && (d) <= 0x00000fffL)
428 #define is_u32(d) (0 <= (d) && (d) <= 0xffffffffL)
430 #define CHECK_SIGNED(v, bitlen) \
431 ((v) >= -(1 << ((bitlen) - 1)) && (v) < (1 << ((bitlen) - 1)))
433 #define is_s8(d) CHECK_SIGNED((d), 8)
434 #define is_s16(d) CHECK_SIGNED((d), 16)
435 #define is_s20(d) CHECK_SIGNED((d), 20)
436 #define is_s32(d) ((d) == (sljit_s32)(d))
444 return (dh | dl) << 8;
448 #define SLJIT_S390X_INSTRUCTION(op, ...) \
449 static SLJIT_INLINE sljit_ins op(__VA_ARGS__)
452 #define SLJIT_S390X_RR(name, pattern) \
453 SLJIT_S390X_INSTRUCTION(name, sljit_gpr dst, sljit_gpr src) \
455 return (pattern) | ((dst & 0xf) << 4) | (src & 0xf); \
482 #undef SLJIT_S390X_RR
485 #define SLJIT_S390X_RRE(name, pattern) \
486 SLJIT_S390X_INSTRUCTION(name, sljit_gpr dst, sljit_gpr src) \
488 return (pattern) | R4A(dst) | R0A(src); \
542 #undef SLJIT_S390X_RRE
545 #define SLJIT_S390X_RIA(name, pattern, imm_type) \
546 SLJIT_S390X_INSTRUCTION(name, sljit_gpr reg, imm_type imm) \
548 return (pattern) | R20A(reg) | (imm & 0xffff); \
571 #undef SLJIT_S390X_RIA
574 #define SLJIT_S390X_RILA(name, pattern, imm_type) \
575 SLJIT_S390X_INSTRUCTION(name, sljit_gpr reg, imm_type imm) \
577 SLJIT_ASSERT(have_eimm()); \
578 return (pattern) | R36A(reg) | ((sljit_ins)imm & 0xffffffffu); \
607 #undef SLJIT_S390X_RILA
610 #define SLJIT_S390X_RXA(name, pattern) \
611 SLJIT_S390X_INSTRUCTION(name, sljit_gpr r, sljit_s32 d, sljit_gpr x, sljit_gpr b) \
613 SLJIT_ASSERT((d & 0xfff) == d); \
615 return (pattern) | R20A(r) | R16A(x) | R12A(b) | (sljit_ins)(d & 0xfff); \
639 #undef SLJIT_S390X_RXA
642 #define SLJIT_S390X_RXYA(name, pattern, cond) \
643 SLJIT_S390X_INSTRUCTION(name, sljit_gpr r, sljit_s32 d, sljit_gpr x, sljit_gpr b) \
645 SLJIT_ASSERT(cond); \
647 return (pattern) | R36A(r) | R32A(x) | R28A(b) | disp_s20(d); \
688 #undef SLJIT_S390X_RXYA
691 #define SLJIT_S390X_RSYA(name, pattern, cond) \
692 SLJIT_S390X_INSTRUCTION(name, sljit_gpr dst, sljit_gpr src, sljit_s32 d, sljit_gpr b) \
694 SLJIT_ASSERT(cond); \
696 return (pattern) | R36A(dst) | R32A(src) | R28A(b) | disp_s20(d); \
711 #undef SLJIT_S390X_RSYA
714 #define SLJIT_S390X_RIEF(name, pattern) \
715 SLJIT_S390X_INSTRUCTION(name, sljit_gpr dst, sljit_gpr src, sljit_u8 start, sljit_u8 end, sljit_u8 rot) \
717 sljit_ins i3, i4, i5; \
719 SLJIT_ASSERT(have_genext()); \
720 i3 = (sljit_ins)start << 24; \
721 i4 = (sljit_ins)end << 16; \
722 i5 = (sljit_ins)rot << 8; \
724 return (pattern) | R36A(dst & 0xf) | R32A(src & 0xf) | i3 | i4 | i5; \
746 #undef SLJIT_S390X_RIEF
749 #define SLJIT_S390X_RRFC(name, pattern) \
750 SLJIT_S390X_INSTRUCTION(name, sljit_gpr dst, sljit_gpr src, sljit_uw mask) \
754 SLJIT_ASSERT(have_lscond1()); \
755 m3 = (sljit_ins)(mask & 0xf) << 12; \
757 return (pattern) | m3 | R4A(dst) | R0A(src); \
764 #undef SLJIT_S390X_RRFC
767 #define SLJIT_S390X_RIEG(name, pattern) \
768 SLJIT_S390X_INSTRUCTION(name, sljit_gpr reg, sljit_sw imm, sljit_uw mask) \
772 SLJIT_ASSERT(have_lscond2()); \
773 m3 = (sljit_ins)(mask & 0xf) << 32; \
774 i2 = (sljit_ins)(imm & 0xffffL) << 16; \
776 return (pattern) | R36A(reg) | m3 | i2; \
783 #undef SLJIT_S390X_RIEG
785 #define SLJIT_S390X_RILB(name, pattern, cond) \
786 SLJIT_S390X_INSTRUCTION(name, sljit_gpr reg, sljit_sw ri) \
788 SLJIT_ASSERT(cond); \
790 return (pattern) | R36A(reg) | (sljit_ins)(ri & 0xffffffff); \
802 #undef SLJIT_S390X_RILB
813 return 0xa7040000L | m1 | ri2;
820 return 0xc00400000000L | m1 | ri2;
832 return 0xb2220000 |
R4A(
dst);
847 #undef SLJIT_S390X_INSTRUCTION
857 FAIL_IF(push_inst(compiler, brc(0xc, 2 + 2 + ((
op &
SLJIT_32) ? 1 : 2) + 2 + 3 + 1)));
859 FAIL_IF(push_inst(compiler, (
op &
SLJIT_32) ? or(dst_r, dst_r) : ogr(dst_r, dst_r)));
860 FAIL_IF(push_inst(compiler, brc(0x8, 2 + 3)));
861 FAIL_IF(push_inst(compiler, slfi(
tmp1, 0x10000000)));
920 base = gpr(mem & REG_MASK);
922 if (mem & OFFS_REG_MASK) {
923 index = gpr(OFFS_REG(mem));
933 FAIL_IF(push_load_imm_inst(compiler, tmp, off));
953 base = gpr(mem & REG_MASK);
955 if (mem & OFFS_REG_MASK) {
956 index = gpr(OFFS_REG(mem));
966 FAIL_IF(push_load_imm_inst(compiler, tmp, off));
976 #define EVAL(op, r, addr) op(r, addr.offset, addr.index, addr.base)
977 #define WHEN(cond, r, i1, i2, addr) \
978 (cond) ? EVAL(i1, r, addr) : EVAL(i2, r, addr)
989 if (have_ldisp() || !is_32bit)
999 return push_inst(compiler, ins);
1011 if (have_ldisp() || !is_32bit)
1021 return push_inst(compiler, ins);
1033 return push_load_imm_inst(compiler, dst_r, srcw);
1036 return load_word(compiler, dst_r,
src, srcw, (compiler->mode &
SLJIT_32) != 0);
1039 return push_inst(compiler, (compiler->mode &
SLJIT_32) ? lr(dst_r, src_r) : lgr(dst_r, src_r));
1051 if (FAST_IS_REG(
dst)) {
1056 else if (
dst == src2) {
1063 FAIL_IF(emit_move(compiler, dst_r, src1, src1w));
1065 if (FAST_IS_REG(src2))
1070 FAIL_IF(push_inst(compiler, ins |
R4A(dst_r) |
R0A(src_r)));
1072 if (needs_move != 2)
1075 dst_r = gpr(
dst & REG_MASK);
1076 return push_inst(compiler, (compiler->mode &
SLJIT_32) ? lr(dst_r,
tmp0) : lgr(dst_r,
tmp0));
1086 if (FAST_IS_REG(src1))
1091 return push_inst(compiler, ins |
R4A(dst_r) |
R0A(src_r));
1103 if (FAST_IS_REG(src1))
1108 if (FAST_IS_REG(src2))
1113 return push_inst(compiler, ins |
R4A(dst_r) |
R0A(src1_r) |
R12A(src2_r));
1130 if (FAST_IS_REG(
dst)) {
1138 FAIL_IF(emit_move(compiler, dst_r, src1, src1w));
1141 return push_inst(compiler, ins |
R36A(dst_r) | (src2w & 0xffffffff));
1142 return push_inst(compiler, ins |
R20A(dst_r) | (src2w & 0xffff));
1153 if (!FAST_IS_REG(src1))
1156 src_r = gpr(src1 & REG_MASK);
1158 return push_inst(compiler, ins |
R36A(dst_r) |
R32A(src_r) | (
sljit_ins)(src2w & 0xffff) << 16);
1178 if (FAST_IS_REG(
dst)) {
1183 else if (
dst == (src2 & REG_MASK) || (
dst == OFFS_REG(src2))) {
1190 FAIL_IF(emit_move(compiler, dst_r, src1, src1w));
1192 base = gpr(src2 & REG_MASK);
1195 if (src2 & OFFS_REG_MASK) {
1196 index = gpr(OFFS_REG(src2));
1204 FAIL_IF(push_load_imm_inst(compiler,
tmp1, src2w));
1206 if (src2 & REG_MASK)
1218 FAIL_IF(push_inst(compiler, ins));
1220 if (needs_move != 2)
1224 return push_inst(compiler, (compiler->mode &
SLJIT_32) ? lr(dst_r,
tmp0) : lgr(dst_r,
tmp0));
1235 if (
dst & OFFS_REG_MASK) {
1238 if ((dstw & 0x3) == 0)
1246 else if (!
is_s20(dstw)) {
1247 FAIL_IF(push_load_imm_inst(compiler,
tmp1, dstw));
1255 dst_r = gpr(
dst & REG_MASK);
1257 return push_inst(compiler, ins | ((
sljit_ins)(srcw & 0xff) << 32) |
R28A(dst_r) | disp_s20((
sljit_s32)dstw));
1283 ins20 = forms->
op_y;
1287 ins20 = forms->
op_g;
1290 if (ins12 && ins20) {
1293 || ((src1 & OFFS_REG_MASK) ? (src1w & 0x3) == 0 :
is_s20(src1w)))) {
1294 if ((src2 & OFFS_REG_MASK) ||
is_u12(src2w) || !
is_s20(src2w))
1295 return emit_rx(compiler, ins12,
dst, src1, src1w, src2, src2w,
RX_A);
1297 return emit_rx(compiler, ins20,
dst, src1, src1w, src2, src2w,
RXY_A);
1301 if ((src1 & OFFS_REG_MASK) ||
is_u12(src1w) || !
is_s20(src1w))
1302 return emit_rx(compiler, ins12,
dst, src2, src2w, src1, src1w,
RX_A);
1304 return emit_rx(compiler, ins20,
dst, src2, src2w, src1, src1w,
RXY_A);
1307 else if (ins12 || ins20) {
1320 || ((src1 & OFFS_REG_MASK) ? (src1w & 0x3) == 0 : (rx_type ==
RX_A ?
is_u12(src1w) :
is_s20(src1w)))))
1321 return emit_rx(compiler, ins,
dst, src1, src1w, src2, src2w, rx_type);
1324 return emit_rx(compiler, ins,
dst, src2, src2w, src1, src1w, rx_type);
1330 ins_k = forms->
op_rk;
1339 if (ins && FAST_IS_REG(
dst)) {
1341 return emit_rr(compiler, ins,
dst, src1, src1w, src2, src2w);
1344 return emit_rr(compiler, ins,
dst, src2, src2w, src1, src1w);
1348 return emit_rr(compiler, ins,
dst, src1, src1w, src2, src2w);
1350 return emit_rrf(compiler, ins_k,
dst, src1, src1w, src2, src2w);
1366 ins20 = forms->
op_y;
1370 ins20 = forms->
op_g;
1373 if (ins12 && ins20) {
1374 if ((src2 & OFFS_REG_MASK) ||
is_u12(src2w) || !
is_s20(src2w))
1375 return emit_rx(compiler, ins12,
dst, src1, src1w, src2, src2w,
RX_A);
1377 return emit_rx(compiler, ins20,
dst, src1, src1w, src2, src2w,
RXY_A);
1380 return emit_rx(compiler, ins12,
dst, src1, src1w, src2, src2w,
RX_A);
1382 return emit_rx(compiler, ins20,
dst, src1, src1w, src2, src2w,
RXY_A);
1387 if (ins == 0 || (FAST_IS_REG(
dst) &&
dst == src1))
1390 return emit_rrf(compiler, ins,
dst, src1, src1w, src2, src2w);
1405 void *
code, *code_ptr;
1410 CHECK_PTR(check_sljit_generate_code(compiler));
1411 reverse_buf(compiler);
1415 jump = compiler->
jumps;
1435 if (ins & sljit_ins_const) {
1436 pool_size +=
sizeof(*pool);
1437 ins &= ~sljit_ins_const;
1440 label->size = ins_size;
1443 if (jump && jump->
addr ==
j) {
1450 pool_size +=
sizeof(*pool);
1455 if (put_label && put_label->
addr ==
j) {
1456 pool_size +=
sizeof(*pool);
1457 put_label = put_label->
next;
1459 ins_size += sizeof_ins(ins);
1465 label->size = ins_size;
1475 pad_size = ((ins_size + 7UL) & ~7UL) - ins_size;
1479 code = SLJIT_MALLOC_EXEC(ins_size + pad_size + pool_size,
1483 executable_offset = SLJIT_EXEC_OFFSET(
code);
1503 jump = compiler->
jumps;
1513 if (ins & sljit_ins_const) {
1515 ins &= ~sljit_ins_const;
1536 if (jump && jump->
addr ==
j) {
1542 source = (
sljit_sw)SLJIT_ADD_EXEC_OFFSET(code_ptr, executable_offset);
1549 encode_inst(&code_ptr, lgrl(
tmp1,
offset & 0xffffffff));
1570 source = (
sljit_sw)SLJIT_ADD_EXEC_OFFSET(code_ptr, executable_offset);
1583 if (put_label && put_label->
addr ==
j) {
1584 source = (
sljit_sw)SLJIT_ADD_EXEC_OFFSET(code_ptr, executable_offset);
1599 put_label = put_label->
next;
1601 encode_inst(&code_ptr, ins);
1610 code = SLJIT_ADD_EXEC_OFFSET(
code, executable_offset);
1611 code_ptr = SLJIT_ADD_EXEC_OFFSET(code_ptr, executable_offset);
1620 switch (feature_type) {
1622 return have_eimm() ? 1 : 0;
1624 return have_lscond1() ? 1 : 0;
1643 CHECK(check_sljit_emit_enter(compiler, options, arg_types, scratches, saveds, fscratches, fsaveds, local_size));
1644 set_emit_enter(compiler, options, arg_types, scratches, saveds, fscratches, fsaveds, local_size);
1649 offset = 2 * SSIZE_OF(sw);
1652 offset += 9 * SSIZE_OF(sw);
1667 offset += (saveds + 1) * SSIZE_OF(sw);
1682 local_size = (local_size + SLJIT_S390X_DEFAULT_STACK_FRAME_SIZE + 0xf) & ~0xf;
1685 FAIL_IF(push_inst(compiler, 0xe30000000071 |
R36A(r15) |
R28A(r15) | disp_s20(-local_size)));
1689 while (arg_types > 0) {
1709 CHECK(check_sljit_set_context(compiler, options, arg_types, scratches, saveds, fscratches, fsaveds, local_size));
1710 set_set_context(compiler, options, arg_types, scratches, saveds, fscratches, fsaveds, local_size);
1712 compiler->
local_size = (local_size + SLJIT_S390X_DEFAULT_STACK_FRAME_SIZE + 0xf) & ~0xf;
1726 FAIL_IF(push_inst(compiler, 0xe30000000071 |
R36A(r15) |
R28A(r15) | disp_s20(local_size)));
1728 offset = 2 * SSIZE_OF(sw);
1731 offset += 9 * SSIZE_OF(sw);
1746 offset += (saveds + 1) * SSIZE_OF(sw);
1767 CHECK(check_sljit_emit_return_void(compiler));
1769 FAIL_IF(emit_stack_frame_release(compiler));
1770 return push_inst(compiler, br(r14));
1783 CHECK(check_sljit_emit_op0(compiler,
op));
1789 return push_inst(compiler, 0x0001 );
1791 return push_inst(compiler, 0x0700 );
1793 FAIL_IF(push_inst(compiler, mlgr(arg0, arg0)));
1798 FAIL_IF(push_inst(compiler, srag(
tmp0, arg0, 63, 0)));
1804 FAIL_IF(push_inst(compiler, mlgr(arg0, arg0)));
1816 return push_inst(compiler, lr(
arg1,
tmp0));
1826 return push_inst(compiler, lr(
arg1,
tmp0));
1836 return push_inst(compiler, lgr(
arg1,
tmp0));
1845 return push_inst(compiler, lgr(
arg1,
tmp0));
1858 return push_inst(compiler, lgr(
arg1,
tmp0));
1862 #define WHEN2(cond, i1, i2) (cond) ? LEVAL(i1) : LEVAL(i2)
1875 CHECK(check_sljit_emit_op1(compiler,
op,
dst, dstw,
src, srcw));
1876 ADJUST_LOCAL_OFFSET(
dst, dstw);
1877 ADJUST_LOCAL_OFFSET(
src, srcw);
1881 if (FAST_IS_REG(
dst) && FAST_IS_REG(
src)) {
1887 ins = llcr(dst_r, src_r);
1890 ins = lbr(dst_r, src_r);
1893 ins = llhr(dst_r, src_r);
1896 ins = lhr(dst_r, src_r);
1901 ins = lr(dst_r, src_r);
1905 ins = llgcr(dst_r, src_r);
1908 ins = lgbr(dst_r, src_r);
1911 ins = llghr(dst_r, src_r);
1914 ins = lghr(dst_r, src_r);
1917 ins = llgfr(dst_r, src_r);
1920 ins = lgfr(dst_r, src_r);
1926 ins = lgr(dst_r, src_r);
1933 FAIL_IF(push_inst(compiler, ins));
1959 return push_load_imm_inst(compiler, gpr(
dst), srcw);
1963 #define LEVAL(i) EVAL(i, reg, mem)
2012 FAIL_IF(push_inst(compiler, ins));
2021 FAIL_IF(push_load_imm_inst(compiler, reg, srcw));
2028 return push_inst(compiler,
2032 return push_inst(compiler,
2037 return push_inst(compiler,
2058 return push_inst(compiler,
2065 return push_inst(compiler,
2073 return push_inst(compiler,
2092 dst_r = FAST_IS_REG(
dst) ? gpr(REG_MASK &
dst) :
tmp0;
2093 src_r = FAST_IS_REG(
src) ? gpr(REG_MASK &
src) :
tmp0;
2097 compiler->status_flags_state =
op & (VARIABLE_FLAG_MASK |
SLJIT_SET_Z);
2105 FAIL_IF(push_inst(compiler, lgr(dst_r, src_r)));
2112 FAIL_IF(push_inst(compiler, xilf(dst_r, 0xffffffff)));
2116 FAIL_IF(push_inst(compiler, lr(dst_r, src_r)));
2132 FAIL_IF(push_inst(compiler, sllg(
tmp1, src_r, 32, 0)));
2133 FAIL_IF(push_inst(compiler, iilf(
tmp1, 0xffffffff)));
2146 FAIL_IF(update_zero_overflow(compiler,
op, dst_r));
2157 switch (GET_OPCODE(
op)) {
2174 static const struct ins_forms add_forms = {
2184 static const struct ins_forms logical_add_forms = {
2205 if (!sets_zero_overflow &&
is_s8(src2w) && (src1 &
SLJIT_MEM) && (
dst == src1 && dstw == src1w)) {
2207 ins = (
op &
SLJIT_32) ? 0xeb000000006a : 0xeb000000007a ;
2209 ins = (
op &
SLJIT_32) ? 0xeb000000006e : 0xeb000000007e ;
2210 return emit_siy(compiler, ins,
dst, dstw, src2w);
2215 ins = (
op &
SLJIT_32) ? 0xec00000000d8 : 0xec00000000d9 ;
2217 ins = (
op &
SLJIT_32) ? 0xec00000000da : 0xec00000000db ;
2218 FAIL_IF(emit_rie_d(compiler, ins,
dst, src1, src1w, src2w));
2222 if (!sets_overflow) {
2224 ins = (
op &
SLJIT_32) ? 0xc20b00000000 : 0xc20a00000000 ;
2229 FAIL_IF(emit_ri(compiler, 0xc20400000000 ,
dst, src1, src1w, -src2w,
RIL_A));
2234 ins = (
op &
SLJIT_32) ? 0xc20900000000 : 0xc20800000000 ;
2240 forms = sets_overflow ? &add_forms : &logical_add_forms;
2241 FAIL_IF(emit_commutative(compiler, forms,
dst, src1, src1w, src2, src2w));
2244 if (sets_zero_overflow)
2245 FAIL_IF(update_zero_overflow(compiler,
op, FAST_IS_REG(
dst) ? gpr(
dst & REG_MASK) :
tmp0));
2253 static const struct ins_forms sub_forms = {
2263 static const struct ins_forms logical_sub_forms = {
2290 if (compare_signed || ((
op & VARIABLE_FLAG_MASK) == 0 &&
is_s32(src2w)))
2293 ins = (
op &
SLJIT_32) ? 0xc20d00000000 : 0xc20c00000000 ;
2294 return emit_ri(compiler, ins, src1, src1, src1w, src2w,
RIL_A);
2299 ins = (
op &
SLJIT_32) ? 0xc20f00000000 : 0xc20e00000000 ;
2300 return emit_ri(compiler, ins, src1, src1, src1w, src2w,
RIL_A);
2303 return emit_rie_d(compiler, 0xec00000000db , (
sljit_s32)
tmp0, src1, src1w, src2w);
2308 ins = compare_signed ? 0x59000000 : 0x55000000 ;
2309 return emit_rx(compiler, ins, src1, src1, src1w, src2, src2w,
RX_A);
2313 ins = (
op &
SLJIT_32) ? 0xe30000000059 : 0xe30000000020 ;
2315 ins = (
op &
SLJIT_32) ? 0xe30000000055 : 0xe30000000021 ;
2316 return emit_rx(compiler, ins, src1, src1, src1w, src2, src2w,
RXY_A);
2320 ins = (
op &
SLJIT_32) ? 0x1900 : 0xb9200000 ;
2322 ins = (
op &
SLJIT_32) ? 0x1500 : 0xb9210000 ;
2323 return emit_rr(compiler, ins, src1, src1, src1w, src2, src2w);
2326 if (src1 ==
SLJIT_IMM && src1w == 0 && (flag_type == 0 || sets_signed)) {
2327 ins = (
op &
SLJIT_32) ? 0x1300 : 0xb9030000 ;
2328 FAIL_IF(emit_rr1(compiler, ins,
dst, src2, src2w));
2335 if (sets_signed || neg_src2w != 0 || (
op & (
SLJIT_SET_Z | VARIABLE_FLAG_MASK)) == 0) {
2336 if (!sets_zero_overflow &&
is_s8(neg_src2w) && (src1 &
SLJIT_MEM) && (
dst == src1 && dstw == src1w)) {
2338 ins = (
op &
SLJIT_32) ? 0xeb000000006a : 0xeb000000007a ;
2340 ins = (
op &
SLJIT_32) ? 0xeb000000006e : 0xeb000000007e ;
2341 return emit_siy(compiler, ins,
dst, dstw, neg_src2w);
2346 ins = (
op &
SLJIT_32) ? 0xec00000000d8 : 0xec00000000d9 ;
2348 ins = (
op &
SLJIT_32) ? 0xec00000000da : 0xec00000000db ;
2349 FAIL_IF(emit_rie_d(compiler, ins,
dst, src1, src1w, neg_src2w));
2356 ins = (
op &
SLJIT_32) ? 0xc20500000000 : 0xc20400000000 ;
2361 FAIL_IF(emit_ri(compiler, 0xc20a00000000 ,
dst, src1, src1w, neg_src2w,
RIL_A));
2366 ins = (
op &
SLJIT_32) ? 0xc20900000000 : 0xc20800000000 ;
2372 forms = sets_signed ? &sub_forms : &logical_sub_forms;
2373 FAIL_IF(emit_non_commutative(compiler, forms,
dst, src1, src1w, src2, src2w));
2385 FAIL_IF(push_inst(compiler, brc(0xe, 2 + 2)));
2389 FAIL_IF(update_zero_overflow(compiler,
op, dst_r));
2398 static const struct ins_forms multiply_forms = {
2408 static const struct ins_forms multiply_overflow_forms = {
2425 if (HAS_FLAGS(
op)) {
2437 return emit_commutative(compiler, &multiply_overflow_forms,
dst, src1, src1w, src2, src2w);
2442 ins = (
op &
SLJIT_32) ? 0xa70c0000 : 0xa70d0000 ;
2443 return emit_ri(compiler, ins,
dst, src1, src1w, src2w,
RI_A);
2447 ins = (
op &
SLJIT_32) ? 0xc20100000000 : 0xc20000000000 ;
2448 return emit_ri(compiler, ins,
dst, src1, src1w, src2w,
RIL_A);
2452 return emit_commutative(compiler, &multiply_forms,
dst, src1, src1w, src2, src2w);
2465 dst_r = gpr(
dst & REG_MASK);
2471 FAIL_IF(emit_move(compiler, dst_r, src1, src1w));
2475 FAIL_IF(push_inst(compiler, 0xc00a00000000 |
R36A(dst_r) | (imm >> 32)));
2476 return push_inst(compiler, 0xc00b00000000 |
R36A(dst_r) | (imm & 0xffffffff));
2480 FAIL_IF(push_inst(compiler, 0xc00c00000000 |
R36A(dst_r) | (imm >> 32)));
2481 return push_inst(compiler, 0xc00d00000000 |
R36A(dst_r) | (imm & 0xffffffff));
2485 if ((imm & 0x00000000ffffffffull) == 0)
2486 return push_inst(compiler, 0xc00c00000000 |
R36A(dst_r) | (imm >> 32));
2487 if ((imm & 0xffffffff00000000ull) == 0)
2488 return push_inst(compiler, 0xc00d00000000 |
R36A(dst_r) | (imm & 0xffffffff));
2491 if ((imm & 0xffff000000000000ull) != 0)
2492 FAIL_IF(push_inst(compiler, 0xa5080000 |
R20A(dst_r) | (imm >> 48)));
2493 if ((imm & 0x0000ffff00000000ull) != 0)
2494 FAIL_IF(push_inst(compiler, 0xa5090000 |
R20A(dst_r) | ((imm >> 32) & 0xffff)));
2495 if ((imm & 0x00000000ffff0000ull) != 0)
2496 FAIL_IF(push_inst(compiler, 0xa50a0000 |
R20A(dst_r) | ((imm >> 16) & 0xffff)));
2497 if ((imm & 0x000000000000ffffull) != 0 || imm == 0)
2498 return push_inst(compiler, 0xa50b0000 |
R20A(dst_r) | (imm & 0xffff));
2502 if ((imm & 0xffffffff00000000ull) != 0)
2503 FAIL_IF(push_inst(compiler, 0xc00600000000 |
R36A(dst_r) | (imm >> 32)));
2504 if ((imm & 0x00000000ffffffffull) != 0 || imm == 0)
2505 return push_inst(compiler, 0xc00700000000 |
R36A(dst_r) | (imm & 0xffffffff));
2509 static const struct ins_forms bitwise_and_forms = {
2519 static const struct ins_forms bitwise_or_forms = {
2529 static const struct ins_forms bitwise_xor_forms = {
2552 imm &= 0xffffffffull;
2554 if ((imm & 0x000000000000ffffull) != 0 || imm == 0)
2556 if ((imm & 0x00000000ffff0000ull) != 0)
2558 if ((imm & 0x0000ffff00000000ull) != 0)
2560 if ((imm & 0xffff000000000000ull) != 0)
2566 if (FAST_IS_REG(src1))
2567 src_r = gpr(src1 & REG_MASK);
2571 if ((imm & 0x000000000000ffffull) != 0 || imm == 0)
2572 return push_inst(compiler, 0xa7010000 |
R20A(src_r) | imm);
2573 if ((imm & 0x00000000ffff0000ull) != 0)
2574 return push_inst(compiler, 0xa7000000 |
R20A(src_r) | (imm >> 16));
2575 if ((imm & 0x0000ffff00000000ull) != 0)
2576 return push_inst(compiler, 0xa7030000 |
R20A(src_r) | (imm >> 32));
2577 return push_inst(compiler, 0xa7020000 |
R20A(src_r) | (imm >> 48));
2581 return sljit_emit_bitwise_imm(compiler,
type,
dst, src1, src1w, imm, count16);
2585 forms = &bitwise_and_forms;
2587 forms = &bitwise_or_forms;
2589 forms = &bitwise_xor_forms;
2591 return emit_commutative(compiler, forms,
dst, src1, src1w, src2, src2w);
2606 if (FAST_IS_REG(src1))
2607 src_r = gpr(src1 & REG_MASK);
2613 else if (FAST_IS_REG(src2))
2614 base_r = gpr(src2 & REG_MASK);
2632 ins = (
op &
SLJIT_32) ? 0xeb00000000df : 0xeb000000000d ;
2634 ins = (
op &
SLJIT_32) ? 0xeb00000000de : 0xeb000000000c ;
2636 ins = (
op &
SLJIT_32) ? 0xeb00000000dc : 0xeb000000000a ;
2638 FAIL_IF(push_inst(compiler, ins |
R36A(dst_r) |
R32A(src_r) |
R28A(base_r) | (imm << 16)));
2642 return push_inst(compiler, (
op &
SLJIT_32) ? or(dst_r, dst_r) : ogr(dst_r, dst_r));
2647 static const struct ins_forms addc_forms = {
2657 static const struct ins_forms subc_forms = {
2673 CHECK(check_sljit_emit_op2(compiler,
op, 0,
dst, dstw, src1, src1w, src2, src2w));
2674 ADJUST_LOCAL_OFFSET(
dst, dstw);
2675 ADJUST_LOCAL_OFFSET(src1, src1w);
2676 ADJUST_LOCAL_OFFSET(src2, src2w);
2679 compiler->status_flags_state =
op & (VARIABLE_FLAG_MASK |
SLJIT_SET_Z);
2691 switch (GET_OPCODE(
op)) {
2694 return sljit_emit_add(compiler,
op,
dst, dstw, src1, src1w, src2, src2w);
2697 FAIL_IF(emit_commutative(compiler, &addc_forms,
dst, src1, src1w, src2, src2w));
2703 return sljit_emit_sub(compiler,
op,
dst, dstw, src1, src1w, src2, src2w);
2706 FAIL_IF(emit_non_commutative(compiler, &subc_forms,
dst, src1, src1w, src2, src2w));
2711 FAIL_IF(sljit_emit_multiply(compiler,
op,
dst, src1, src1w, src2, src2w));
2716 FAIL_IF(sljit_emit_bitwise(compiler,
op,
dst, src1, src1w, src2, src2w));
2721 FAIL_IF(sljit_emit_shift(compiler,
op,
dst, src1, src1w, src2, src2w));
2735 CHECK(check_sljit_emit_op2(compiler,
op, 1, 0, 0, src1, src1w, src2, src2w));
2737 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) \
2738 || (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
2751 CHECK(check_sljit_emit_op_src(compiler,
op,
src, srcw));
2752 ADJUST_LOCAL_OFFSET(
src, srcw);
2760 return push_inst(compiler, br(src_r));
2780 CHECK_REG_INDEX(check_sljit_get_register_index(reg));
2786 CHECK_REG_INDEX(check_sljit_get_float_register_index(reg));
2796 CHECK(check_sljit_emit_op_custom(compiler, instruction,
size));
2799 return push_inst(compiler, ins);
2806 #define FLOAT_LOAD 0
2807 #define FLOAT_STORE 1
2818 if ((mem & OFFS_REG_MASK) ||
is_u12(memw) || !
is_s20(memw)) {
2822 ins = (
op &
SLJIT_32) ? 0x70000000 : 0x60000000 ;
2824 ins = (
op &
SLJIT_32) ? 0x78000000 : 0x68000000 ;
2832 ins = (
op &
SLJIT_32) ? 0xed0000000066 : 0xed0000000067 ;
2834 ins = (
op &
SLJIT_32) ? 0xed0000000064 : 0xed0000000065 ;
2846 return push_inst(compiler, ins_r |
F4(reg) |
F0(
src));
2866 ins = (
op &
SLJIT_32) ? 0xb3a85000 : 0xb3a95000 ;
2868 ins = (
op &
SLJIT_32) ? 0xb3985000 : 0xb3995000 ;
2886 FAIL_IF(push_load_imm_inst(compiler,
tmp0, srcw));
2895 ins = (
op &
SLJIT_32) ? 0xb3a40000 : 0xb3a50000 ;
2897 ins = (
op &
SLJIT_32) ? 0xb3940000 : 0xb3950000 ;
2919 ins_r = 0xb3090000 ;
2920 ins = 0xed0000000009 ;
2922 ins_r = 0xb3190000 ;
2923 ins = 0xed0000000019 ;
2926 return emit_float(compiler, ins_r, ins, src1, src2, src2w);
2938 SELECT_FOP1_OPERATION_WITH_CHECKS(compiler,
op,
dst, dstw,
src, srcw);
2943 FAIL_IF(emit_float(compiler, 0xb3040000 , 0xed0000000004 , dst_r,
src, srcw));
2950 switch (GET_OPCODE(
op)) {
2952 if (FAST_IS_REG(
dst)) {
2965 ins = (
op &
SLJIT_32) ? 0xb3030000 : 0xb3130000 ;
2969 ins = (
op &
SLJIT_32) ? 0xb3000000 : 0xb3100000 ;
2984 #define FLOAT_MOV(op, dst_r, src_r) \
2985 (((op & SLJIT_32) ? 0x3800 : 0x2800 ) | F4(dst_r) | F0(src_r))
2996 CHECK(check_sljit_emit_fop2(compiler,
op,
dst, dstw, src1, src1w, src2, src2w));
2997 ADJUST_LOCAL_OFFSET(
dst, dstw);
2998 ADJUST_LOCAL_OFFSET(src1, src1w);
2999 ADJUST_LOCAL_OFFSET(src2, src2w);
3002 if (FAST_IS_REG(
dst)) {
3027 switch (GET_OPCODE(
op)) {
3029 ins_r = (
op &
SLJIT_32) ? 0xb30a0000 : 0xb31a0000 ;
3030 ins = (
op &
SLJIT_32) ? 0xed000000000a : 0xed000000001a ;
3033 ins_r = (
op &
SLJIT_32) ? 0xb30b0000 : 0xb31b0000 ;
3034 ins = (
op &
SLJIT_32) ? 0xed000000000b : 0xed000000001b ;
3037 ins_r = (
op &
SLJIT_32) ? 0xb3170000 : 0xb31c0000 ;
3038 ins = (
op &
SLJIT_32) ? 0xed0000000017 : 0xed000000001c ;
3042 ins_r = (
op &
SLJIT_32) ? 0xb30d0000 : 0xb31d0000 ;
3043 ins = (
op &
SLJIT_32) ? 0xed000000000d : 0xed000000001d ;
3047 FAIL_IF(emit_float(compiler, ins_r, ins, dst_r, src2, src2w));
3063 CHECK(check_sljit_emit_fast_enter(compiler,
dst, dstw));
3064 ADJUST_LOCAL_OFFSET(
dst, dstw);
3066 if (FAST_IS_REG(
dst))
3067 return push_inst(compiler, lgr(gpr(
dst), fast_link_r));
3070 return store_word(compiler, fast_link_r,
dst, dstw, 0);
3082 CHECK_PTR(check_sljit_emit_label(compiler));
3089 set_label(
label, compiler);
3098 CHECK_PTR(check_sljit_emit_jump(compiler,
type));
3102 ensure_abuf(compiler,
sizeof(
struct sljit_jump));
3121 CHECK_PTR(check_sljit_emit_call(compiler,
type, arg_types));
3128 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) \
3129 || (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
3141 CHECK(check_sljit_emit_ijump(compiler,
type,
src, srcw));
3145 FAIL_IF(push_load_imm_inst(compiler, src_r, srcw));
3148 ADJUST_LOCAL_OFFSET(
src, srcw);
3149 FAIL_IF(load_word(compiler, src_r,
src, srcw, 0 ));
3156 return push_inst(compiler, br(src_r));
3164 CHECK(check_sljit_emit_icall(compiler,
type, arg_types,
src, srcw));
3169 ADJUST_LOCAL_OFFSET(
src, srcw);
3180 FAIL_IF(emit_stack_frame_release(compiler));
3184 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) \
3185 || (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
3203 switch (GET_OPCODE(
op)) {
3226 #define LEVAL(i) i(loc_r, 1, mask)
3227 if (have_lscond2()) {
3228 FAIL_IF(push_load_imm_inst(compiler, loc_r, 0));
3238 switch (GET_OPCODE(
op)) {
3239 #define LEVAL(i) i(dst_r, loc_r)
3257 return store_word(compiler, dst_r,
dst, dstw, (
op &
SLJIT_32));
3271 CHECK(check_sljit_emit_cmov(compiler,
type, dst_reg,
src, srcw));
3275 FAIL_IF(push_load_imm_inst(compiler, src_r, srcw));
3278 #define LEVAL(i) i(dst_r, src_r, mask)
3280 return push_inst(compiler,
3309 CHECK_PTR(check_sljit_emit_const(compiler,
dst, dstw,
init_value));
3317 dst_r = FAST_IS_REG(
dst) ? gpr(
dst & REG_MASK) :
tmp0;
3319 PTR_FAIL_IF(push_inst(compiler, sljit_ins_const | lgrl(dst_r, 0)));
3356 CHECK_PTR(check_sljit_emit_put_label(compiler,
dst, dstw));
3357 ADJUST_LOCAL_OFFSET(
dst, dstw);
3361 set_put_label(put_label, compiler, 0);
3363 dst_r = FAST_IS_REG(
dst) ? gpr(
dst & REG_MASK) :
tmp0;
small capitals from c petite p scientific i
[1]
for(n=0;n< outline->n_points;n++)
std::chrono::milliseconds ms
set set set set set set set macro pixldst1 abits if abits op else op endif endm macro pixldst2 abits if abits op else op endif endm macro pixldst4 abits if abits op else op endif endm macro pixldst0 abits op endm macro pixldst3 mem_operand op endm macro pixldst30 mem_operand op endm macro pixldst abits if abits elseif abits elseif abits elseif abits elseif abits pixldst0 abits else pixldst0 abits pixldst0 abits pixldst0 abits pixldst0 abits endif elseif abits else pixldst0 abits pixldst0 abits endif elseif abits else error unsupported bpp *numpix else pixst endif endm macro vuzp8 reg2 vuzp d d ®2 endm macro vzip8 reg2 vzip d d ®2 endm macro pixdeinterleave basereg basereg basereg basereg basereg endif endm macro pixinterleave basereg basereg basereg basereg basereg endif endm macro PF boost_increment endif if endif PF tst PF addne PF subne PF cmp ORIG_W if endif if endif if endif PF subge ORIG_W PF subges if endif if endif if endif endif endm macro cache_preload_simple endif if dst_r_bpp pld[DST_R, #(PREFETCH_DISTANCE_SIMPLE *dst_r_bpp/8)] endif if mask_bpp pld if[MASK, #(PREFETCH_DISTANCE_SIMPLE *mask_bpp/8)] endif endif endm macro ensure_destination_ptr_alignment process_pixblock_tail_head if beq irp skip1(dst_w_bpp<=(lowbit *8)) &&((lowbit *8)<(pixblock_size *dst_w_bpp)) .if lowbit< 16 tst DST_R
[3]
set set set set set set set macro pixldst1 op
QT_BEGIN_NAMESPACE bool done
GLsizei const GLfloat * v
[13]
GLint GLint GLint GLint GLint x
[0]
GLenum GLuint GLintptr GLsizeiptr size
[1]
GLuint GLsizei const GLchar * label
[43]
GLenum GLuint GLenum GLsizei const GLchar * buf
GLenum GLuint GLintptr offset
GLint GLint GLint GLint GLint GLint GLint GLbitfield mask
GLsizei GLsizei GLchar * source
GLuint GLuint GLuint GLuint arg1
GLenum GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const void * bits
#define SLJIT_UNREACHABLE()
unsigned short int sljit_u16
signed short int sljit_s16
#define SLJIT_UNLIKELY(x)
#define SLJIT_API_FUNC_ATTRIBUTE
#define SLJIT_NUMBER_OF_FLOAT_REGISTERS
#define SLJIT_NUMBER_OF_REGISTERS
#define SLJIT_UNUSED_ARG(arg)
unsigned long int sljit_uw
#define SLJIT_CACHE_FLUSH(from, to)
#define SLJIT_UPDATE_WX_FLAGS(from, to, enable_exec)
#define PTR_FAIL_IF(expr)
#define PTR_FAIL_WITH_EXEC_IF(ptr)
#define CHECK_ERROR_PTR()
#define SLJIT_SKIP_FRAMES_BEFORE_FAST_RETURN
#define SLJIT_ARG_TYPE_SCRATCH_REG
#define SLJIT_LESS_EQUAL_F64
#define SLJIT_CONV_F64_FROM_S32
#define SLJIT_CONV_S32_FROM_F64
#define SLJIT_FAST_RETURN
#define SLJIT_NOT_EQUAL_F64
#define SLJIT_GREATER_EQUAL_F64
#define SLJIT_SET_OVERFLOW
#define SLJIT_FIRST_SAVED_REG
#define SLJIT_UNORDERED_F64
#define SLJIT_GREATER_F64
#define SLJIT_PREFETCH_L3
#define SLJIT_SIG_GREATER_EQUAL
#define SLJIT_CURRENT_FLAGS_COMPARE
#define SLJIT_ARG_TYPE_F64
#define SLJIT_PREFETCH_L1
#define SLJIT_ERR_UNSUPPORTED
#define SLJIT_SIG_LESS_EQUAL
#define SLJIT_ORDERED_F64
#define SLJIT_CALL_RETURN
#define SLJIT_REWRITABLE_JUMP
#define SLJIT_NOT_OVERFLOW
#define SLJIT_CONV_SW_FROM_F64
#define SLJIT_CURRENT_FLAGS_ADD
#define SLJIT_SIG_GREATER
#define SLJIT_FIRST_SAVED_FLOAT_REG
#define SLJIT_CONV_F64_FROM_SW
#define SLJIT_GREATER_EQUAL
#define SLJIT_SKIP_FRAMES_BEFORE_RETURN
#define SLJIT_ERR_COMPILED
#define SLJIT_CONV_F32_FROM_F64
#define SLJIT_CONV_F64_FROM_F32
#define SLJIT_PREFETCH_L2
#define SLJIT_CURRENT_FLAGS_SUB
#define SLJIT_PREFETCH_ONCE
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 sljit_s32 sljit_emit_fast_enter(struct sljit_compiler *compiler, sljit_s32 dst, sljit_sw dstw)
SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_cmov(struct sljit_compiler *compiler, sljit_s32 type, sljit_s32 dst_reg, sljit_s32 src, sljit_sw srcw)
#define LOAD_STORE_ON_CONDITION_2_FACILITY
SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump * sljit_emit_jump(struct sljit_compiler *compiler, sljit_s32 type)
#define STORE_FACILITY_LIST_EXTENDED_FACILITY
#define SLJIT_S390X_RXA(name, pattern)
#define SLJIT_S390X_RSYA(name, pattern, cond)
#define EXTENDED_IMMEDIATE_FACILITY
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)
#define SLJIT_S390X_INSTRUCTION(op,...)
#define MISCELLANEOUS_INSTRUCTION_EXTENSIONS_1_FACILITY
#define SLJIT_S390X_RRFC(name, pattern)
SLJIT_API_FUNC_ATTRIBUTE struct sljit_label * sljit_emit_label(struct sljit_compiler *compiler)
#define DISTINCT_OPERAND_FACILITY
SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_get_float_register_index(sljit_s32 reg)
#define MISCELLANEOUS_INSTRUCTION_EXTENSIONS_2_FACILITY
SLJIT_API_FUNC_ATTRIBUTE void sljit_set_const(sljit_uw addr, sljit_sw new_constant, sljit_sw executable_offset)
#define SLJIT_ADD_SUB_NO_COMPARE(status_flags_state)
SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_ijump(struct sljit_compiler *compiler, sljit_s32 type, sljit_s32 src, sljit_sw srcw)
#define LOAD_STORE_ON_CONDITION_1_FACILITY
#define GENERAL_INSTRUCTION_EXTENSION_FACILITY
SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_return_void(struct sljit_compiler *compiler)
#define SLJIT_S390X_RILA(name, pattern, imm_type)
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_op0(struct sljit_compiler *compiler, sljit_s32 op)
#define SLJIT_S390X_RIA(name, pattern, imm_type)
#define HAVE_FACILITY(name, bit)
SLJIT_API_FUNC_ATTRIBUTE struct sljit_put_label * sljit_emit_put_label(struct sljit_compiler *compiler, sljit_s32 dst, sljit_sw dstw)
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)
#define FLOAT_MOV(op, dst_r, src_r)
#define SLJIT_S390X_RILB(name, pattern, cond)
#define SLJIT_S390X_RIEG(name, pattern)
#define WHEN(cond, r, i1, i2, addr)
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 EVAL(op, r, addr)
SLJIT_API_FUNC_ATTRIBUTE void * sljit_generate_code(struct sljit_compiler *compiler)
#define SLJIT_S390X_RRE(name, pattern)
#define WHEN2(cond, i1, i2)
SLJIT_API_FUNC_ATTRIBUTE void sljit_set_jump_addr(sljit_uw addr, sljit_uw new_target, sljit_sw executable_offset)
#define SLJIT_S390X_RR(name, pattern)
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)
#define VECTOR_ENHANCEMENTS_1_FACILITY
#define FAST_LONG_DISPLACEMENT_FACILITY
#define SLJIT_S390X_RXYA(name, pattern, cond)
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)
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)
SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_op_custom(struct sljit_compiler *compiler, void *instruction, sljit_u32 size)
#define SLJIT_S390X_RIEF(name, pattern)
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_get_register_index(sljit_s32 reg)
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)
struct sljit_const * consts
void * exec_allocator_data
sljit_sw executable_offset
struct sljit_jump * jumps
struct sljit_label * last_label
struct sljit_memory_fragment * buf
struct sljit_put_label * put_labels
struct sljit_label * labels
struct sljit_label * label
struct sljit_label * label
struct sljit_put_label * next
const T & const_(const T &t)