2 * Stack-less Just-In-Time compiler
4 * Copyright 2013-2013 Tilera Corporation(jiwang@tilera.com). All rights reserved.
5 * Copyright 2009-2012 Zoltan Herczeg (hzmester@freemail.hu). All rights reserved.
7 * Redistribution and use in source and binary forms, with or without modification, are
8 * permitted provided that the following conditions are met:
10 * 1. Redistributions of source code must retain the above copyright notice, this list of
11 * conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright notice, this list
14 * of conditions and the following disclaimer in the documentation and/or other materials
15 * provided with the distribution.
17 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) AND CONTRIBUTORS ``AS IS'' AND ANY
18 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
20 * SHALL THE COPYRIGHT HOLDER(S) OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
22 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
23 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
25 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 /* TileGX architecture. */
29 /* Contributed by Tilera Corporation. */
30 #include "sljitNativeTILEGX-encoder.c"
32 #define SIMM_8BIT_MAX (0x7f)
33 #define SIMM_8BIT_MIN (-0x80)
34 #define SIMM_16BIT_MAX (0x7fff)
35 #define SIMM_16BIT_MIN (-0x8000)
36 #define SIMM_17BIT_MAX (0xffff)
37 #define SIMM_17BIT_MIN (-0x10000)
38 #define SIMM_32BIT_MIN (-0x80000000)
39 #define SIMM_32BIT_MAX (0x7fffffff)
40 #define SIMM_48BIT_MIN (0x800000000000L)
41 #define SIMM_48BIT_MAX (0x7fffffff0000L)
42 #define IMM16(imm) ((imm) & 0xffff)
44 #define UIMM_16BIT_MAX (0xffff)
46 #define TMP_REG1 (SLJIT_NO_REGISTERS + 1)
47 #define TMP_REG2 (SLJIT_NO_REGISTERS + 2)
48 #define TMP_REG3 (SLJIT_NO_REGISTERS + 3)
49 #define ADDR_TMP (SLJIT_NO_REGISTERS + 4)
50 #define PIC_ADDR_REG TMP_REG2
52 static SLJIT_CONST sljit_ub reg_map[SLJIT_NO_REGISTERS + 5] = {
53 63, 0, 1, 2, 3, 4, 30, 31, 32, 33, 34, 54, 5, 16, 6, 7
56 #define SLJIT_LOCALS_REG_mapped 54
57 #define TMP_REG1_mapped 5
58 #define TMP_REG2_mapped 16
59 #define TMP_REG3_mapped 6
60 #define ADDR_TMP_mapped 7
61 #define SLJIT_SAVED_REG1_mapped 30
62 #define SLJIT_SAVED_REG2_mapped 31
63 #define SLJIT_SAVED_REG3_mapped 32
64 #define SLJIT_SAVED_EREG1_mapped 33
65 #define SLJIT_SAVED_EREG2_mapped 34
67 /* Flags are keept in volatile registers. */
69 /* And carry flag as well. */
71 #define UGREATER_FLAG 10
73 #define GREATER_FLAG 12
74 #define OVERFLOW_FLAG 13
81 #define LOAD_DATA 0x01
82 #define WORD_DATA 0x00
83 #define BYTE_DATA 0x02
84 #define HALF_DATA 0x04
86 #define SIGNED_DATA 0x08
87 #define DOUBLE_DATA 0x10
89 /* Separates integer and floating point registers */
94 #define WRITE_BACK 0x00020
95 #define ARG_TEST 0x00040
96 #define ALT_KEEP_CACHE 0x00080
97 #define CUMULATIVE_OP 0x00100
98 #define LOGICAL_OP 0x00200
99 #define IMM_OP 0x00400
100 #define SRC2_IMM 0x00800
102 #define UNUSED_DEST 0x01000
103 #define REG_DEST 0x02000
104 #define REG1_SOURCE 0x04000
105 #define REG2_SOURCE 0x08000
106 #define SLOW_SRC1 0x10000
107 #define SLOW_SRC2 0x20000
108 #define SLOW_DEST 0x40000
110 /* Only these flags are set. UNUSED_DEST is not set when no flags should be set.
112 #define CHECK_FLAGS(list) (!(flags & UNUSED_DEST) || (op & GET_FLAGS(~(list))))
114 SLJIT_API_FUNC_ATTRIBUTE SLJIT_CONST char *sljit_get_platform_name(void)
116 return "TileGX" SLJIT_CPUINFO;
119 /* Length of an instruction word */
120 typedef sljit_uw sljit_ins;
123 const struct tilegx_opcode* opcode;
124 tilegx_pipeline pipe;
125 unsigned long input_registers;
126 unsigned long output_registers;
127 int operand_value[4];
131 /* Opcode Helper Macros */
132 #define TILEGX_X_MODE 0
134 #define X_MODE create_Mode(TILEGX_X_MODE)
137 create_Opcode_X0(RRR_0_OPCODE_X0) | \
138 create_RRROpcodeExtension_X0(UNARY_RRR_0_OPCODE_X0) | \
139 create_UnaryOpcodeExtension_X0(FNOP_UNARY_OPCODE_X0)
142 create_Opcode_X1(RRR_0_OPCODE_X1) | \
143 create_RRROpcodeExtension_X1(UNARY_RRR_0_OPCODE_X1) | \
144 create_UnaryOpcodeExtension_X1(FNOP_UNARY_OPCODE_X1)
147 create_Mode(TILEGX_X_MODE) | FNOP_X0 | FNOP_X1
150 create_Opcode_X0(RRR_0_OPCODE_X0) | \
151 create_RRROpcodeExtension_X0(UNARY_RRR_0_OPCODE_X0) | \
152 create_UnaryOpcodeExtension_X0(NOP_UNARY_OPCODE_X0)
154 #define BPT create_Mode(TILEGX_X_MODE) | create_Opcode_X1(RRR_0_OPCODE_X1) | \
155 create_RRROpcodeExtension_X1(UNARY_RRR_0_OPCODE_X1) | \
156 create_UnaryOpcodeExtension_X1(ILL_UNARY_OPCODE_X1) | \
157 create_Dest_X1(0x1C) | create_SrcA_X1(0x25) | ANOP_X0
160 create_Mode(TILEGX_X_MODE) | create_Opcode_X1(RRR_0_OPCODE_X1) | \
161 create_RRROpcodeExtension_X1(ADD_RRR_0_OPCODE_X1) | FNOP_X0
164 create_Mode(TILEGX_X_MODE) | create_Opcode_X1(IMM8_OPCODE_X1) | \
165 create_Imm8OpcodeExtension_X1(ADDI_IMM8_OPCODE_X1) | FNOP_X0
168 create_Mode(TILEGX_X_MODE) | create_Opcode_X1(RRR_0_OPCODE_X1) | \
169 create_RRROpcodeExtension_X1(SUB_RRR_0_OPCODE_X1) | FNOP_X0
172 create_Mode(TILEGX_X_MODE) | create_Opcode_X1(RRR_0_OPCODE_X1) | \
173 create_RRROpcodeExtension_X1(NOR_RRR_0_OPCODE_X1) | FNOP_X0
176 create_Mode(TILEGX_X_MODE) | create_Opcode_X1(RRR_0_OPCODE_X1) | \
177 create_RRROpcodeExtension_X1(OR_RRR_0_OPCODE_X1) | FNOP_X0
180 create_Mode(TILEGX_X_MODE) | create_Opcode_X1(RRR_0_OPCODE_X1) | \
181 create_RRROpcodeExtension_X1(AND_RRR_0_OPCODE_X1) | FNOP_X0
184 create_Mode(TILEGX_X_MODE) | create_Opcode_X1(RRR_0_OPCODE_X1) | \
185 create_RRROpcodeExtension_X1(XOR_RRR_0_OPCODE_X1) | FNOP_X0
188 create_Mode(TILEGX_X_MODE) | create_Opcode_X0(RRR_0_OPCODE_X0) | \
189 create_RRROpcodeExtension_X0(CMOVNEZ_RRR_0_OPCODE_X0) | FNOP_X1
192 create_Mode(TILEGX_X_MODE) | create_Opcode_X0(RRR_0_OPCODE_X0) | \
193 create_RRROpcodeExtension_X0(CMOVEQZ_RRR_0_OPCODE_X0) | FNOP_X1
196 create_Mode(TILEGX_X_MODE) | create_Opcode_X1(ADDLI_OPCODE_X1) | FNOP_X0
199 create_Mode(TILEGX_X_MODE) | create_Opcode_X1(RRR_0_OPCODE_X1) | \
200 create_RRROpcodeExtension_X1(V4INT_L_RRR_0_OPCODE_X1) | FNOP_X0
203 create_Mode(TILEGX_X_MODE) | create_Opcode_X0(BF_OPCODE_X0) | \
204 create_BFOpcodeExtension_X0(BFEXTU_BF_OPCODE_X0) | FNOP_X1
207 create_Mode(TILEGX_X_MODE) | create_Opcode_X0(BF_OPCODE_X0) | \
208 create_BFOpcodeExtension_X0(BFEXTS_BF_OPCODE_X0) | FNOP_X1
210 #define SHL16INSLI_X1 \
211 create_Mode(TILEGX_X_MODE) | create_Opcode_X1(SHL16INSLI_OPCODE_X1) | FNOP_X0
214 create_Mode(TILEGX_X_MODE) | create_Opcode_X1(RRR_0_OPCODE_X1) | \
215 create_RRROpcodeExtension_X1(ST_RRR_0_OPCODE_X1) | create_Dest_X1(0x0) | FNOP_X0
218 create_Mode(TILEGX_X_MODE) | create_Opcode_X1(RRR_0_OPCODE_X1) | \
219 create_RRROpcodeExtension_X1(UNARY_RRR_0_OPCODE_X1) | \
220 create_UnaryOpcodeExtension_X1(LD_UNARY_OPCODE_X1) | FNOP_X0
223 create_Mode(TILEGX_X_MODE) | create_Opcode_X1(RRR_0_OPCODE_X1) | \
224 create_RRROpcodeExtension_X1(UNARY_RRR_0_OPCODE_X1) | \
225 create_UnaryOpcodeExtension_X1(JR_UNARY_OPCODE_X1) | FNOP_X0
228 create_Mode(TILEGX_X_MODE) | create_Opcode_X1(RRR_0_OPCODE_X1) | \
229 create_RRROpcodeExtension_X1(UNARY_RRR_0_OPCODE_X1) | \
230 create_UnaryOpcodeExtension_X1(JALR_UNARY_OPCODE_X1) | FNOP_X0
233 create_Mode(TILEGX_X_MODE) | create_Opcode_X0(RRR_0_OPCODE_X0) | \
234 create_RRROpcodeExtension_X0(UNARY_RRR_0_OPCODE_X0) | \
235 create_UnaryOpcodeExtension_X0(CNTLZ_UNARY_OPCODE_X0) | FNOP_X1
238 create_Mode(TILEGX_X_MODE) | create_Opcode_X1(IMM8_OPCODE_X1) | \
239 create_Imm8OpcodeExtension_X1(CMPLTUI_IMM8_OPCODE_X1) | FNOP_X0
242 create_Mode(TILEGX_X_MODE) | create_Opcode_X1(RRR_0_OPCODE_X1) | \
243 create_RRROpcodeExtension_X1(CMPLTU_RRR_0_OPCODE_X1) | FNOP_X0
246 create_Mode(TILEGX_X_MODE) | create_Opcode_X1(RRR_0_OPCODE_X1) | \
247 create_RRROpcodeExtension_X1(CMPLTS_RRR_0_OPCODE_X1) | FNOP_X0
250 create_Mode(TILEGX_X_MODE) | create_Opcode_X1(IMM8_OPCODE_X1) | \
251 create_Imm8OpcodeExtension_X1(XORI_IMM8_OPCODE_X1) | FNOP_X0
254 create_Mode(TILEGX_X_MODE) | create_Opcode_X1(IMM8_OPCODE_X1) | \
255 create_Imm8OpcodeExtension_X1(ORI_IMM8_OPCODE_X1) | FNOP_X0
258 create_Mode(TILEGX_X_MODE) | create_Opcode_X1(IMM8_OPCODE_X1) | \
259 create_Imm8OpcodeExtension_X1(ANDI_IMM8_OPCODE_X1) | FNOP_X0
262 create_Mode(TILEGX_X_MODE) | create_Opcode_X1(SHIFT_OPCODE_X1) | \
263 create_ShiftOpcodeExtension_X1(SHLI_SHIFT_OPCODE_X1) | FNOP_X0
266 create_Mode(TILEGX_X_MODE) | create_Opcode_X1(RRR_0_OPCODE_X1) | \
267 create_RRROpcodeExtension_X1(SHL_RRR_0_OPCODE_X1) | FNOP_X0
270 create_Mode(TILEGX_X_MODE) | create_Opcode_X1(SHIFT_OPCODE_X1) | \
271 create_ShiftOpcodeExtension_X1(SHRSI_SHIFT_OPCODE_X1) | FNOP_X0
274 create_Mode(TILEGX_X_MODE) | create_Opcode_X1(RRR_0_OPCODE_X1) | \
275 create_RRROpcodeExtension_X1(SHRS_RRR_0_OPCODE_X1) | FNOP_X0
278 create_Mode(TILEGX_X_MODE) | create_Opcode_X1(SHIFT_OPCODE_X1) | \
279 create_ShiftOpcodeExtension_X1(SHRUI_SHIFT_OPCODE_X1) | FNOP_X0
282 create_Mode(TILEGX_X_MODE) | create_Opcode_X1(RRR_0_OPCODE_X1) | \
283 create_RRROpcodeExtension_X1(SHRU_RRR_0_OPCODE_X1) | FNOP_X0
286 create_Mode(TILEGX_X_MODE) | create_Opcode_X1(BRANCH_OPCODE_X1) | \
287 create_BrType_X1(BEQZ_BRANCH_OPCODE_X1) | FNOP_X0
290 create_Mode(TILEGX_X_MODE) | create_Opcode_X1(BRANCH_OPCODE_X1) | \
291 create_BrType_X1(BNEZ_BRANCH_OPCODE_X1) | FNOP_X0
294 create_Mode(TILEGX_X_MODE) | create_Opcode_X1(JUMP_OPCODE_X1) | \
295 create_JumpOpcodeExtension_X1(J_JUMP_OPCODE_X1) | FNOP_X0
298 create_Mode(TILEGX_X_MODE) | create_Opcode_X1(JUMP_OPCODE_X1) | \
299 create_JumpOpcodeExtension_X1(JAL_JUMP_OPCODE_X1) | FNOP_X0
301 #define DEST_X0(x) create_Dest_X0(x)
302 #define SRCA_X0(x) create_SrcA_X0(x)
303 #define SRCB_X0(x) create_SrcB_X0(x)
304 #define DEST_X1(x) create_Dest_X1(x)
305 #define SRCA_X1(x) create_SrcA_X1(x)
306 #define SRCB_X1(x) create_SrcB_X1(x)
307 #define IMM16_X1(x) create_Imm16_X1(x)
308 #define IMM8_X1(x) create_Imm8_X1(x)
309 #define BFSTART_X0(x) create_BFStart_X0(x)
310 #define BFEND_X0(x) create_BFEnd_X0(x)
311 #define SHIFTIMM_X1(x) create_ShAmt_X1(x)
312 #define JOFF_X1(x) create_JumpOff_X1(x)
313 #define BOFF_X1(x) create_BrOff_X1(x)
315 static SLJIT_CONST tilegx_mnemonic data_transfer_insts[16] = {
316 /* u w s */ TILEGX_OPC_ST /* st */,
317 /* u w l */ TILEGX_OPC_LD /* ld */,
318 /* u b s */ TILEGX_OPC_ST1 /* st1 */,
319 /* u b l */ TILEGX_OPC_LD1U /* ld1u */,
320 /* u h s */ TILEGX_OPC_ST2 /* st2 */,
321 /* u h l */ TILEGX_OPC_LD2U /* ld2u */,
322 /* u i s */ TILEGX_OPC_ST4 /* st4 */,
323 /* u i l */ TILEGX_OPC_LD4U /* ld4u */,
324 /* s w s */ TILEGX_OPC_ST /* st */,
325 /* s w l */ TILEGX_OPC_LD /* ld */,
326 /* s b s */ TILEGX_OPC_ST1 /* st1 */,
327 /* s b l */ TILEGX_OPC_LD1S /* ld1s */,
328 /* s h s */ TILEGX_OPC_ST2 /* st2 */,
329 /* s h l */ TILEGX_OPC_LD2S /* ld2s */,
330 /* s i s */ TILEGX_OPC_ST4 /* st4 */,
331 /* s i l */ TILEGX_OPC_LD4S /* ld4s */,
334 #ifdef TILEGX_JIT_DEBUG
335 static sljit_si push_inst_debug(struct sljit_compiler *compiler, sljit_ins ins, int line)
337 sljit_ins *ptr = (sljit_ins *)ensure_buf(compiler, sizeof(sljit_ins));
341 printf("|%04d|S0|:\t\t", line);
342 print_insn_tilegx(ptr);
343 return SLJIT_SUCCESS;
346 static sljit_si push_inst_nodebug(struct sljit_compiler *compiler, sljit_ins ins)
348 sljit_ins *ptr = (sljit_ins *)ensure_buf(compiler, sizeof(sljit_ins));
352 return SLJIT_SUCCESS;
355 #define push_inst(a, b) push_inst_debug(a, b, __LINE__)
357 static sljit_si push_inst(struct sljit_compiler *compiler, sljit_ins ins)
359 sljit_ins *ptr = (sljit_ins *)ensure_buf(compiler, sizeof(sljit_ins));
363 return SLJIT_SUCCESS;
367 #define BUNDLE_FORMAT_MASK(p0, p1, p2) \
368 ((p0) | ((p1) << 8) | ((p2) << 16))
370 #define BUNDLE_FORMAT(p0, p1, p2) \
373 (tilegx_pipeline)(p0), \
374 (tilegx_pipeline)(p1), \
375 (tilegx_pipeline)(p2) \
377 BUNDLE_FORMAT_MASK(1 << (p0), 1 << (p1), (1 << (p2))) \
380 #define NO_PIPELINE TILEGX_NUM_PIPELINE_ENCODINGS
382 #define tilegx_is_x_pipeline(p) ((int)(p) <= (int)TILEGX_PIPELINE_X1)
384 #define PI(encoding) \
385 push_inst(compiler, encoding)
387 #define PB3(opcode, dst, srca, srcb) \
388 push_3_buffer(compiler, opcode, dst, srca, srcb, __LINE__)
390 #define PB2(opcode, dst, src) \
391 push_2_buffer(compiler, opcode, dst, src, __LINE__)
394 push_jr_buffer(compiler, TILEGX_OPC_JR, reg, __LINE__)
396 #define ADD(dst, srca, srcb) \
397 push_3_buffer(compiler, TILEGX_OPC_ADD, dst, srca, srcb, __LINE__)
399 #define SUB(dst, srca, srcb) \
400 push_3_buffer(compiler, TILEGX_OPC_SUB, dst, srca, srcb, __LINE__)
402 #define NOR(dst, srca, srcb) \
403 push_3_buffer(compiler, TILEGX_OPC_NOR, dst, srca, srcb, __LINE__)
405 #define OR(dst, srca, srcb) \
406 push_3_buffer(compiler, TILEGX_OPC_OR, dst, srca, srcb, __LINE__)
408 #define XOR(dst, srca, srcb) \
409 push_3_buffer(compiler, TILEGX_OPC_XOR, dst, srca, srcb, __LINE__)
411 #define AND(dst, srca, srcb) \
412 push_3_buffer(compiler, TILEGX_OPC_AND, dst, srca, srcb, __LINE__)
414 #define CLZ(dst, src) \
415 push_2_buffer(compiler, TILEGX_OPC_CLZ, dst, src, __LINE__)
417 #define SHLI(dst, srca, srcb) \
418 push_3_buffer(compiler, TILEGX_OPC_SHLI, dst, srca, srcb, __LINE__)
420 #define SHRUI(dst, srca, imm) \
421 push_3_buffer(compiler, TILEGX_OPC_SHRUI, dst, srca, imm, __LINE__)
423 #define XORI(dst, srca, imm) \
424 push_3_buffer(compiler, TILEGX_OPC_XORI, dst, srca, imm, __LINE__)
426 #define ORI(dst, srca, imm) \
427 push_3_buffer(compiler, TILEGX_OPC_ORI, dst, srca, imm, __LINE__)
429 #define CMPLTU(dst, srca, srcb) \
430 push_3_buffer(compiler, TILEGX_OPC_CMPLTU, dst, srca, srcb, __LINE__)
432 #define CMPLTS(dst, srca, srcb) \
433 push_3_buffer(compiler, TILEGX_OPC_CMPLTS, dst, srca, srcb, __LINE__)
435 #define CMPLTUI(dst, srca, imm) \
436 push_3_buffer(compiler, TILEGX_OPC_CMPLTUI, dst, srca, imm, __LINE__)
438 #define CMOVNEZ(dst, srca, srcb) \
439 push_3_buffer(compiler, TILEGX_OPC_CMOVNEZ, dst, srca, srcb, __LINE__)
441 #define CMOVEQZ(dst, srca, srcb) \
442 push_3_buffer(compiler, TILEGX_OPC_CMOVEQZ, dst, srca, srcb, __LINE__)
444 #define ADDLI(dst, srca, srcb) \
445 push_3_buffer(compiler, TILEGX_OPC_ADDLI, dst, srca, srcb, __LINE__)
447 #define SHL16INSLI(dst, srca, srcb) \
448 push_3_buffer(compiler, TILEGX_OPC_SHL16INSLI, dst, srca, srcb, __LINE__)
450 #define LD_ADD(dst, addr, adjust) \
451 push_3_buffer(compiler, TILEGX_OPC_LD_ADD, dst, addr, adjust, __LINE__)
453 #define ST_ADD(src, addr, adjust) \
454 push_3_buffer(compiler, TILEGX_OPC_ST_ADD, src, addr, adjust, __LINE__)
456 #define LD(dst, addr) \
457 push_2_buffer(compiler, TILEGX_OPC_LD, dst, addr, __LINE__)
459 #define BFEXTU(dst, src, start, end) \
460 push_4_buffer(compiler, TILEGX_OPC_BFEXTU, dst, src, start, end, __LINE__)
462 #define BFEXTS(dst, src, start, end) \
463 push_4_buffer(compiler, TILEGX_OPC_BFEXTS, dst, src, start, end, __LINE__)
465 #define ADD_SOLO(dest, srca, srcb) \
466 push_inst(compiler, ADD_X1 | DEST_X1(dest) | SRCA_X1(srca) | SRCB_X1(srcb))
468 #define ADDI_SOLO(dest, srca, imm) \
469 push_inst(compiler, ADDI_X1 | DEST_X1(dest) | SRCA_X1(srca) | IMM8_X1(imm))
471 #define ADDLI_SOLO(dest, srca, imm) \
472 push_inst(compiler, ADDLI_X1 | DEST_X1(dest) | SRCA_X1(srca) | IMM16_X1(imm))
474 #define SHL16INSLI_SOLO(dest, srca, imm) \
475 push_inst(compiler, SHL16INSLI_X1 | DEST_X1(dest) | SRCA_X1(srca) | IMM16_X1(imm))
477 #define JALR_SOLO(reg) \
478 push_inst(compiler, JALR_X1 | SRCA_X1(reg))
480 #define JR_SOLO(reg) \
481 push_inst(compiler, JR_X1 | SRCA_X1(reg))
484 /* Mapping of bundle issue slot to assigned pipe. */
485 tilegx_pipeline pipe[TILEGX_MAX_INSTRUCTIONS_PER_BUNDLE];
487 /* Mask of pipes used by this bundle. */
488 unsigned int pipe_mask;
491 const struct Format formats[] =
493 /* In Y format we must always have something in Y2, since it has
494 * no fnop, so this conveys that Y2 must always be used. */
495 BUNDLE_FORMAT(TILEGX_PIPELINE_Y0, TILEGX_PIPELINE_Y2, NO_PIPELINE),
496 BUNDLE_FORMAT(TILEGX_PIPELINE_Y1, TILEGX_PIPELINE_Y2, NO_PIPELINE),
497 BUNDLE_FORMAT(TILEGX_PIPELINE_Y2, TILEGX_PIPELINE_Y0, NO_PIPELINE),
498 BUNDLE_FORMAT(TILEGX_PIPELINE_Y2, TILEGX_PIPELINE_Y1, NO_PIPELINE),
500 /* Y format has three instructions. */
501 BUNDLE_FORMAT(TILEGX_PIPELINE_Y0, TILEGX_PIPELINE_Y1, TILEGX_PIPELINE_Y2),
502 BUNDLE_FORMAT(TILEGX_PIPELINE_Y0, TILEGX_PIPELINE_Y2, TILEGX_PIPELINE_Y1),
503 BUNDLE_FORMAT(TILEGX_PIPELINE_Y1, TILEGX_PIPELINE_Y0, TILEGX_PIPELINE_Y2),
504 BUNDLE_FORMAT(TILEGX_PIPELINE_Y1, TILEGX_PIPELINE_Y2, TILEGX_PIPELINE_Y0),
505 BUNDLE_FORMAT(TILEGX_PIPELINE_Y2, TILEGX_PIPELINE_Y0, TILEGX_PIPELINE_Y1),
506 BUNDLE_FORMAT(TILEGX_PIPELINE_Y2, TILEGX_PIPELINE_Y1, TILEGX_PIPELINE_Y0),
508 /* X format has only two instructions. */
509 BUNDLE_FORMAT(TILEGX_PIPELINE_X0, TILEGX_PIPELINE_X1, NO_PIPELINE),
510 BUNDLE_FORMAT(TILEGX_PIPELINE_X1, TILEGX_PIPELINE_X0, NO_PIPELINE)
514 struct jit_instr inst_buf[TILEGX_MAX_INSTRUCTIONS_PER_BUNDLE];
515 unsigned long inst_buf_index;
517 tilegx_pipeline get_any_valid_pipe(const struct tilegx_opcode* opcode)
519 /* FIXME: tile: we could pregenerate this. */
521 for (pipe = 0; ((opcode->pipes & (1 << pipe)) == 0 && pipe < TILEGX_NUM_PIPELINE_ENCODINGS); pipe++)
523 return (tilegx_pipeline)(pipe);
526 void insert_nop(tilegx_mnemonic opc, int line)
528 const struct tilegx_opcode* opcode = NULL;
530 memmove(&inst_buf[1], &inst_buf[0], inst_buf_index * sizeof inst_buf[0]);
532 opcode = &tilegx_opcodes[opc];
533 inst_buf[0].opcode = opcode;
534 inst_buf[0].pipe = get_any_valid_pipe(opcode);
535 inst_buf[0].input_registers = 0;
536 inst_buf[0].output_registers = 0;
537 inst_buf[0].line = line;
541 const struct Format* compute_format()
543 unsigned int compatible_pipes = BUNDLE_FORMAT_MASK(
544 inst_buf[0].opcode->pipes,
545 inst_buf[1].opcode->pipes,
546 (inst_buf_index == 3 ? inst_buf[2].opcode->pipes : (1 << NO_PIPELINE)));
548 const struct Format* match = NULL;
549 const struct Format *b = NULL;
551 for (i; i < sizeof formats / sizeof formats[0]; i++) {
553 if ((b->pipe_mask & compatible_pipes) == b->pipe_mask) {
562 sljit_si assign_pipes()
564 unsigned long output_registers = 0;
567 if (inst_buf_index == 1) {
568 tilegx_mnemonic opc = inst_buf[0].opcode->can_bundle
569 ? TILEGX_OPC_FNOP : TILEGX_OPC_NOP;
570 insert_nop(opc, __LINE__);
573 const struct Format* match = compute_format();
578 for (i = 0; i < inst_buf_index; i++) {
580 if ((i > 0) && ((inst_buf[i].input_registers & output_registers) != 0))
583 if ((i > 0) && ((inst_buf[i].output_registers & output_registers) != 0))
586 /* Don't include Rzero in the match set, to avoid triggering
587 needlessly on 'prefetch' instrs. */
589 output_registers |= inst_buf[i].output_registers & 0xFFFFFFFFFFFFFFL;
591 inst_buf[i].pipe = match->pipe[i];
594 /* If only 2 instrs, and in Y-mode, insert a nop. */
595 if (inst_buf_index == 2 && !tilegx_is_x_pipeline(match->pipe[0])) {
596 insert_nop(TILEGX_OPC_FNOP, __LINE__);
598 /* Select the yet unassigned pipe. */
599 tilegx_pipeline pipe = (tilegx_pipeline)(((TILEGX_PIPELINE_Y0
600 + TILEGX_PIPELINE_Y1 + TILEGX_PIPELINE_Y2)
601 - (inst_buf[1].pipe + inst_buf[2].pipe)));
603 inst_buf[0].pipe = pipe;
609 tilegx_bundle_bits get_bundle_bit(struct jit_instr *inst)
612 const struct tilegx_opcode* opcode = inst->opcode;
613 tilegx_bundle_bits bits = opcode->fixed_bit_values[inst->pipe];
615 const struct tilegx_operand* operand = NULL;
616 for (i = 0; i < opcode->num_operands; i++) {
617 operand = &tilegx_operands[opcode->operands[inst->pipe][i]];
618 val = inst->operand_value[i];
620 bits |= operand->insert(val);
626 static sljit_si update_buffer(struct sljit_compiler *compiler)
630 int orig_index = inst_buf_index;
631 struct jit_instr inst0 = inst_buf[0];
632 struct jit_instr inst1 = inst_buf[1];
633 struct jit_instr inst2 = inst_buf[2];
634 tilegx_bundle_bits bits = 0;
636 /* If the bundle is valid as is, perform the encoding and return 1. */
637 if (assign_pipes() == 0) {
638 for (i = 0; i < inst_buf_index; i++) {
639 bits |= get_bundle_bit(inst_buf + i);
640 #ifdef TILEGX_JIT_DEBUG
641 printf("|%04d", inst_buf[i].line);
644 #ifdef TILEGX_JIT_DEBUG
645 if (inst_buf_index == 3)
649 print_insn_tilegx(&bits);
654 #ifdef TILEGX_JIT_DEBUG
655 return push_inst_nodebug(compiler, bits);
657 return push_inst(compiler, bits);
661 /* If the bundle is invalid, split it in two. First encode the first two
662 (or possibly 1) instructions, and then the last, separately. Note that
663 assign_pipes may have re-ordered the instrs (by inserting no-ops in
664 lower slots) so we need to reset them. */
666 inst_buf_index = orig_index - 1;
670 if (assign_pipes() == 0) {
671 for (i = 0; i < inst_buf_index; i++) {
672 bits |= get_bundle_bit(inst_buf + i);
673 #ifdef TILEGX_JIT_DEBUG
674 printf("|%04d", inst_buf[i].line);
678 #ifdef TILEGX_JIT_DEBUG
679 if (inst_buf_index == 3)
683 print_insn_tilegx(&bits);
686 if ((orig_index - 1) == 2) {
689 } else if ((orig_index - 1) == 1) {
695 #ifdef TILEGX_JIT_DEBUG
696 return push_inst_nodebug(compiler, bits);
698 return push_inst(compiler, bits);
701 /* We had 3 instrs of which the first 2 can't live in the same bundle.
702 Split those two. Note that we don't try to then combine the second
703 and third instr into a single bundle. First instruction: */
708 if (assign_pipes() == 0) {
709 for (i = 0; i < inst_buf_index; i++) {
710 bits |= get_bundle_bit(inst_buf + i);
711 #ifdef TILEGX_JIT_DEBUG
712 printf("|%04d", inst_buf[i].line);
716 #ifdef TILEGX_JIT_DEBUG
717 if (inst_buf_index == 3)
721 print_insn_tilegx(&bits);
726 inst_buf_index = orig_index - 1;
727 #ifdef TILEGX_JIT_DEBUG
728 return push_inst_nodebug(compiler, bits);
730 return push_inst(compiler, bits);
739 static sljit_si flush_buffer(struct sljit_compiler *compiler)
741 while (inst_buf_index != 0)
742 update_buffer(compiler);
745 static sljit_si push_4_buffer(struct sljit_compiler *compiler, tilegx_mnemonic opc, int op0, int op1, int op2, int op3, int line)
747 if (inst_buf_index == TILEGX_MAX_INSTRUCTIONS_PER_BUNDLE)
748 FAIL_IF(update_buffer(compiler));
750 const struct tilegx_opcode* opcode = &tilegx_opcodes[opc];
751 inst_buf[inst_buf_index].opcode = opcode;
752 inst_buf[inst_buf_index].pipe = get_any_valid_pipe(opcode);
753 inst_buf[inst_buf_index].operand_value[0] = op0;
754 inst_buf[inst_buf_index].operand_value[1] = op1;
755 inst_buf[inst_buf_index].operand_value[2] = op2;
756 inst_buf[inst_buf_index].operand_value[3] = op3;
757 inst_buf[inst_buf_index].input_registers = 1L << op1;
758 inst_buf[inst_buf_index].output_registers = 1L << op0;
759 inst_buf[inst_buf_index].line = line;
762 return SLJIT_SUCCESS;
765 static sljit_si push_3_buffer(struct sljit_compiler *compiler, tilegx_mnemonic opc, int op0, int op1, int op2, int line)
767 if (inst_buf_index == TILEGX_MAX_INSTRUCTIONS_PER_BUNDLE)
768 FAIL_IF(update_buffer(compiler));
770 const struct tilegx_opcode* opcode = &tilegx_opcodes[opc];
771 inst_buf[inst_buf_index].opcode = opcode;
772 inst_buf[inst_buf_index].pipe = get_any_valid_pipe(opcode);
773 inst_buf[inst_buf_index].operand_value[0] = op0;
774 inst_buf[inst_buf_index].operand_value[1] = op1;
775 inst_buf[inst_buf_index].operand_value[2] = op2;
776 inst_buf[inst_buf_index].line = line;
779 case TILEGX_OPC_ST_ADD:
780 inst_buf[inst_buf_index].input_registers = (1L << op0) | (1L << op1);
781 inst_buf[inst_buf_index].output_registers = 1L << op0;
783 case TILEGX_OPC_LD_ADD:
784 inst_buf[inst_buf_index].input_registers = 1L << op1;
785 inst_buf[inst_buf_index].output_registers = (1L << op0) | (1L << op1);
794 case TILEGX_OPC_SHRU:
795 case TILEGX_OPC_SHRS:
796 case TILEGX_OPC_CMPLTU:
797 case TILEGX_OPC_CMPLTS:
798 case TILEGX_OPC_CMOVEQZ:
799 case TILEGX_OPC_CMOVNEZ:
800 inst_buf[inst_buf_index].input_registers = (1L << op1) | (1L << op2);
801 inst_buf[inst_buf_index].output_registers = 1L << op0;
803 case TILEGX_OPC_ADDLI:
804 case TILEGX_OPC_XORI:
806 case TILEGX_OPC_SHLI:
807 case TILEGX_OPC_SHRUI:
808 case TILEGX_OPC_SHRSI:
809 case TILEGX_OPC_SHL16INSLI:
810 case TILEGX_OPC_CMPLTUI:
811 case TILEGX_OPC_CMPLTSI:
812 inst_buf[inst_buf_index].input_registers = 1L << op1;
813 inst_buf[inst_buf_index].output_registers = 1L << op0;
816 printf("unrecoginzed opc: %s\n", opcode->name);
822 return SLJIT_SUCCESS;
825 static sljit_si push_2_buffer(struct sljit_compiler *compiler, tilegx_mnemonic opc, int op0, int op1, int line)
827 if (inst_buf_index == TILEGX_MAX_INSTRUCTIONS_PER_BUNDLE)
828 FAIL_IF(update_buffer(compiler));
830 const struct tilegx_opcode* opcode = &tilegx_opcodes[opc];
831 inst_buf[inst_buf_index].opcode = opcode;
832 inst_buf[inst_buf_index].pipe = get_any_valid_pipe(opcode);
833 inst_buf[inst_buf_index].operand_value[0] = op0;
834 inst_buf[inst_buf_index].operand_value[1] = op1;
835 inst_buf[inst_buf_index].line = line;
838 case TILEGX_OPC_BEQZ:
839 case TILEGX_OPC_BNEZ:
840 inst_buf[inst_buf_index].input_registers = 1L << op0;
846 inst_buf[inst_buf_index].input_registers = (1L << op0) | (1L << op1);
847 inst_buf[inst_buf_index].output_registers = 0;
851 case TILEGX_OPC_LD1U:
852 case TILEGX_OPC_LD1S:
853 case TILEGX_OPC_LD2U:
854 case TILEGX_OPC_LD2S:
855 case TILEGX_OPC_LD4U:
856 case TILEGX_OPC_LD4S:
857 inst_buf[inst_buf_index].input_registers = 1L << op1;
858 inst_buf[inst_buf_index].output_registers = 1L << op0;
861 printf("unrecoginzed opc: %s\n", opcode->name);
867 return SLJIT_SUCCESS;
870 static sljit_si push_0_buffer(struct sljit_compiler *compiler, tilegx_mnemonic opc, int line)
872 if (inst_buf_index == TILEGX_MAX_INSTRUCTIONS_PER_BUNDLE)
873 FAIL_IF(update_buffer(compiler));
875 const struct tilegx_opcode* opcode = &tilegx_opcodes[opc];
876 inst_buf[inst_buf_index].opcode = opcode;
877 inst_buf[inst_buf_index].pipe = get_any_valid_pipe(opcode);
878 inst_buf[inst_buf_index].input_registers = 0;
879 inst_buf[inst_buf_index].output_registers = 0;
880 inst_buf[inst_buf_index].line = line;
883 return SLJIT_SUCCESS;
886 static sljit_si push_jr_buffer(struct sljit_compiler *compiler, tilegx_mnemonic opc, int op0, int line)
888 if (inst_buf_index == TILEGX_MAX_INSTRUCTIONS_PER_BUNDLE)
889 FAIL_IF(update_buffer(compiler));
891 const struct tilegx_opcode* opcode = &tilegx_opcodes[opc];
892 inst_buf[inst_buf_index].opcode = opcode;
893 inst_buf[inst_buf_index].pipe = get_any_valid_pipe(opcode);
894 inst_buf[inst_buf_index].operand_value[0] = op0;
895 inst_buf[inst_buf_index].input_registers = 1L << op0;
896 inst_buf[inst_buf_index].output_registers = 0;
897 inst_buf[inst_buf_index].line = line;
900 return flush_buffer(compiler);
903 static SLJIT_INLINE sljit_ins * detect_jump_type(struct sljit_jump *jump, sljit_ins *code_ptr, sljit_ins *code)
906 sljit_uw target_addr;
908 sljit_ins saved_inst;
910 if (jump->flags & SLJIT_REWRITABLE_JUMP)
913 if (jump->flags & JUMP_ADDR)
914 target_addr = jump->u.target;
916 SLJIT_ASSERT(jump->flags & JUMP_LABEL);
917 target_addr = (sljit_uw)(code + jump->u.label->size);
920 inst = (sljit_ins *)jump->addr;
921 if (jump->flags & IS_COND)
924 diff = ((sljit_sw) target_addr - (sljit_sw) inst) >> 3;
925 if (diff <= SIMM_17BIT_MAX && diff >= SIMM_17BIT_MIN) {
926 jump->flags |= PATCH_B;
928 if (!(jump->flags & IS_COND)) {
929 if (jump->flags & IS_JAL) {
930 jump->flags &= ~(PATCH_B);
931 jump->flags |= PATCH_J;
934 #ifdef TILEGX_JIT_DEBUG
935 printf("[runtime relocate]%04d:\t", __LINE__);
936 print_insn_tilegx(inst);
939 inst[0] = BEQZ_X1 | SRCA_X1(ZERO);
941 #ifdef TILEGX_JIT_DEBUG
942 printf("[runtime relocate]%04d:\t", __LINE__);
943 print_insn_tilegx(inst);
950 inst[0] = inst[0] ^ (0x7L << 55);
952 #ifdef TILEGX_JIT_DEBUG
953 printf("[runtime relocate]%04d:\t", __LINE__);
954 print_insn_tilegx(inst);
956 jump->addr -= sizeof(sljit_ins);
960 if (jump->flags & IS_COND) {
961 if ((target_addr & ~0x3FFFFFFFL) == ((jump->addr + sizeof(sljit_ins)) & ~0x3FFFFFFFL)) {
962 jump->flags |= PATCH_J;
963 inst[0] = (inst[0] & ~(BOFF_X1(-1))) | BOFF_X1(2);
971 if ((target_addr & ~0x3FFFFFFFL) == ((jump->addr + sizeof(sljit_ins)) & ~0x3FFFFFFFL)) {
972 jump->flags |= PATCH_J;
974 if (jump->flags & IS_JAL) {
977 #ifdef TILEGX_JIT_DEBUG
978 printf("[runtime relocate]%04d:\t", __LINE__);
979 print_insn_tilegx(inst);
985 #ifdef TILEGX_JIT_DEBUG
986 printf("[runtime relocate]%04d:\t", __LINE__);
987 print_insn_tilegx(inst);
997 SLJIT_API_FUNC_ATTRIBUTE void * sljit_generate_code(struct sljit_compiler *compiler)
999 struct sljit_memory_fragment *buf;
1001 sljit_ins *code_ptr;
1004 sljit_uw word_count;
1007 struct sljit_label *label;
1008 struct sljit_jump *jump;
1009 struct sljit_const *const_;
1012 check_sljit_generate_code(compiler);
1013 reverse_buf(compiler);
1015 code = (sljit_ins *)SLJIT_MALLOC_EXEC(compiler->size * sizeof(sljit_ins));
1016 PTR_FAIL_WITH_EXEC_IF(code);
1017 buf = compiler->buf;
1021 label = compiler->labels;
1022 jump = compiler->jumps;
1023 const_ = compiler->consts;
1025 buf_ptr = (sljit_ins *)buf->memory;
1026 buf_end = buf_ptr + (buf->used_size >> 3);
1028 *code_ptr = *buf_ptr++;
1029 SLJIT_ASSERT(!label || label->size >= word_count);
1030 SLJIT_ASSERT(!jump || jump->addr >= word_count);
1031 SLJIT_ASSERT(!const_ || const_->addr >= word_count);
1032 /* These structures are ordered by their address. */
1033 if (label && label->size == word_count) {
1034 /* Just recording the address. */
1035 label->addr = (sljit_uw) code_ptr;
1036 label->size = code_ptr - code;
1037 label = label->next;
1040 if (jump && jump->addr == word_count) {
1041 if (jump->flags & IS_JAL)
1042 jump->addr = (sljit_uw)(code_ptr - 4);
1044 jump->addr = (sljit_uw)(code_ptr - 3);
1046 code_ptr = detect_jump_type(jump, code_ptr, code);
1050 if (const_ && const_->addr == word_count) {
1051 /* Just recording the address. */
1052 const_->addr = (sljit_uw) code_ptr;
1053 const_ = const_->next;
1058 } while (buf_ptr < buf_end);
1063 if (label && label->size == word_count) {
1064 label->addr = (sljit_uw) code_ptr;
1065 label->size = code_ptr - code;
1066 label = label->next;
1069 SLJIT_ASSERT(!label);
1070 SLJIT_ASSERT(!jump);
1071 SLJIT_ASSERT(!const_);
1072 SLJIT_ASSERT(code_ptr - code <= (sljit_sw)compiler->size);
1074 jump = compiler->jumps;
1077 addr = (jump->flags & JUMP_LABEL) ? jump->u.label->addr : jump->u.target;
1078 buf_ptr = (sljit_ins *)jump->addr;
1080 if (jump->flags & PATCH_B) {
1081 addr = (sljit_sw)(addr - (jump->addr)) >> 3;
1082 SLJIT_ASSERT((sljit_sw) addr <= SIMM_17BIT_MAX && (sljit_sw) addr >= SIMM_17BIT_MIN);
1083 buf_ptr[0] = (buf_ptr[0] & ~(BOFF_X1(-1))) | BOFF_X1(addr);
1085 #ifdef TILEGX_JIT_DEBUG
1086 printf("[runtime relocate]%04d:\t", __LINE__);
1087 print_insn_tilegx(buf_ptr);
1092 if (jump->flags & PATCH_J) {
1093 SLJIT_ASSERT((addr & ~0x3FFFFFFFL) == ((jump->addr + sizeof(sljit_ins)) & ~0x3FFFFFFFL));
1094 addr = (sljit_sw)(addr - (jump->addr)) >> 3;
1095 buf_ptr[0] = (buf_ptr[0] & ~(JOFF_X1(-1))) | JOFF_X1(addr);
1097 #ifdef TILEGX_JIT_DEBUG
1098 printf("[runtime relocate]%04d:\t", __LINE__);
1099 print_insn_tilegx(buf_ptr);
1104 SLJIT_ASSERT(!(jump->flags & IS_JAL));
1106 /* Set the fields of immediate loads. */
1107 buf_ptr[0] = (buf_ptr[0] & ~(0xFFFFL << 43)) | (((addr >> 32) & 0xFFFFL) << 43);
1108 buf_ptr[1] = (buf_ptr[1] & ~(0xFFFFL << 43)) | (((addr >> 16) & 0xFFFFL) << 43);
1109 buf_ptr[2] = (buf_ptr[2] & ~(0xFFFFL << 43)) | ((addr & 0xFFFFL) << 43);
1115 compiler->error = SLJIT_ERR_COMPILED;
1116 compiler->executable_size = (code_ptr - code) * sizeof(sljit_ins);
1117 SLJIT_CACHE_FLUSH(code, code_ptr);
1121 static sljit_si load_immediate(struct sljit_compiler *compiler, sljit_si dst_ar, sljit_sw imm)
1124 if (imm <= SIMM_16BIT_MAX && imm >= SIMM_16BIT_MIN)
1125 return ADDLI(dst_ar, ZERO, imm);
1127 if (imm <= SIMM_32BIT_MAX && imm >= SIMM_32BIT_MIN) {
1128 FAIL_IF(ADDLI(dst_ar, ZERO, imm >> 16));
1129 return SHL16INSLI(dst_ar, dst_ar, imm);
1132 if (imm <= SIMM_48BIT_MAX && imm >= SIMM_48BIT_MIN) {
1133 FAIL_IF(ADDLI(dst_ar, ZERO, imm >> 32));
1134 FAIL_IF(SHL16INSLI(dst_ar, dst_ar, imm >> 16));
1135 return SHL16INSLI(dst_ar, dst_ar, imm);
1138 FAIL_IF(ADDLI(dst_ar, ZERO, imm >> 48));
1139 FAIL_IF(SHL16INSLI(dst_ar, dst_ar, imm >> 32));
1140 FAIL_IF(SHL16INSLI(dst_ar, dst_ar, imm >> 16));
1141 return SHL16INSLI(dst_ar, dst_ar, imm);
1144 static sljit_si emit_const(struct sljit_compiler *compiler, sljit_si dst_ar, sljit_sw imm, int flush)
1146 /* Should *not* be optimized as load_immediate, as pcre relocation
1147 mechanism will match this fixed 4-instruction pattern. */
1149 FAIL_IF(ADDLI_SOLO(dst_ar, ZERO, imm >> 32));
1150 FAIL_IF(SHL16INSLI_SOLO(dst_ar, dst_ar, imm >> 16));
1151 return SHL16INSLI_SOLO(dst_ar, dst_ar, imm);
1154 FAIL_IF(ADDLI(dst_ar, ZERO, imm >> 32));
1155 FAIL_IF(SHL16INSLI(dst_ar, dst_ar, imm >> 16));
1156 return SHL16INSLI(dst_ar, dst_ar, imm);
1159 static sljit_si emit_const_64(struct sljit_compiler *compiler, sljit_si dst_ar, sljit_sw imm, int flush)
1161 /* Should *not* be optimized as load_immediate, as pcre relocation
1162 mechanism will match this fixed 4-instruction pattern. */
1164 FAIL_IF(ADDLI_SOLO(reg_map[dst_ar], ZERO, imm >> 48));
1165 FAIL_IF(SHL16INSLI_SOLO(reg_map[dst_ar], reg_map[dst_ar], imm >> 32));
1166 FAIL_IF(SHL16INSLI_SOLO(reg_map[dst_ar], reg_map[dst_ar], imm >> 16));
1167 return SHL16INSLI_SOLO(reg_map[dst_ar], reg_map[dst_ar], imm);
1170 FAIL_IF(ADDLI(reg_map[dst_ar], ZERO, imm >> 48));
1171 FAIL_IF(SHL16INSLI(reg_map[dst_ar], reg_map[dst_ar], imm >> 32));
1172 FAIL_IF(SHL16INSLI(reg_map[dst_ar], reg_map[dst_ar], imm >> 16));
1173 return SHL16INSLI(reg_map[dst_ar], reg_map[dst_ar], imm);
1176 SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_enter(struct sljit_compiler *compiler, sljit_si args, sljit_si scratches, sljit_si saveds, sljit_si local_size)
1179 sljit_ins bundle = 0;
1182 check_sljit_emit_enter(compiler, args, scratches, saveds, local_size);
1184 compiler->scratches = scratches;
1185 compiler->saveds = saveds;
1186 #if (defined SLJIT_DEBUG && SLJIT_DEBUG)
1187 compiler->logical_local_size = local_size;
1190 local_size += (saveds + 1) * sizeof(sljit_sw);
1191 local_size = (local_size + 7) & ~7;
1192 compiler->local_size = local_size;
1194 if (local_size <= SIMM_16BIT_MAX) {
1195 /* Frequent case. */
1196 FAIL_IF(ADDLI(SLJIT_LOCALS_REG_mapped, SLJIT_LOCALS_REG_mapped, -local_size));
1197 base = SLJIT_LOCALS_REG_mapped;
1199 FAIL_IF(load_immediate(compiler, TMP_REG1_mapped, local_size));
1200 FAIL_IF(ADD(TMP_REG2_mapped, SLJIT_LOCALS_REG_mapped, ZERO));
1201 FAIL_IF(SUB(SLJIT_LOCALS_REG_mapped, SLJIT_LOCALS_REG_mapped, TMP_REG1_mapped));
1202 base = TMP_REG2_mapped;
1206 FAIL_IF(ADDLI(ADDR_TMP_mapped, base, local_size - 8));
1207 FAIL_IF(ST_ADD(ADDR_TMP_mapped, RA, -8));
1210 FAIL_IF(ST_ADD(ADDR_TMP_mapped, SLJIT_SAVED_REG1_mapped, -8));
1213 FAIL_IF(ST_ADD(ADDR_TMP_mapped, SLJIT_SAVED_REG2_mapped, -8));
1216 FAIL_IF(ST_ADD(ADDR_TMP_mapped, SLJIT_SAVED_REG3_mapped, -8));
1219 FAIL_IF(ST_ADD(ADDR_TMP_mapped, SLJIT_SAVED_EREG1_mapped, -8));
1222 FAIL_IF(ST_ADD(ADDR_TMP_mapped, SLJIT_SAVED_EREG2_mapped, -8));
1225 FAIL_IF(ADD(SLJIT_SAVED_REG1_mapped, 0, ZERO));
1228 FAIL_IF(ADD(SLJIT_SAVED_REG2_mapped, 1, ZERO));
1231 FAIL_IF(ADD(SLJIT_SAVED_REG3_mapped, 2, ZERO));
1233 return SLJIT_SUCCESS;
1236 SLJIT_API_FUNC_ATTRIBUTE void sljit_set_context(struct sljit_compiler *compiler, sljit_si args, sljit_si scratches, sljit_si saveds, sljit_si local_size)
1239 check_sljit_set_context(compiler, args, scratches, saveds, local_size);
1241 compiler->scratches = scratches;
1242 compiler->saveds = saveds;
1243 #if (defined SLJIT_DEBUG && SLJIT_DEBUG)
1244 compiler->logical_local_size = local_size;
1247 local_size += (saveds + 1) * sizeof(sljit_sw);
1248 compiler->local_size = (local_size + 7) & ~7;
1251 SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_return(struct sljit_compiler *compiler, sljit_si op, sljit_si src, sljit_sw srcw)
1253 sljit_si local_size;
1255 int addr_initialized = 0;
1258 check_sljit_emit_return(compiler, op, src, srcw);
1260 FAIL_IF(emit_mov_before_return(compiler, op, src, srcw));
1262 local_size = compiler->local_size;
1263 if (local_size <= SIMM_16BIT_MAX)
1264 base = SLJIT_LOCALS_REG_mapped;
1266 FAIL_IF(load_immediate(compiler, TMP_REG1_mapped, local_size));
1267 FAIL_IF(ADD(TMP_REG1_mapped, SLJIT_LOCALS_REG_mapped, TMP_REG1_mapped));
1268 base = TMP_REG1_mapped;
1272 FAIL_IF(ADDLI(ADDR_TMP_mapped, base, local_size - 8));
1273 FAIL_IF(LD(RA, ADDR_TMP_mapped));
1275 if (compiler->saveds >= 5) {
1276 FAIL_IF(ADDLI(ADDR_TMP_mapped, base, local_size - 48));
1277 addr_initialized = 1;
1279 FAIL_IF(LD_ADD(SLJIT_SAVED_EREG2_mapped, ADDR_TMP_mapped, 8));
1282 if (compiler->saveds >= 4) {
1283 if (addr_initialized == 0) {
1284 FAIL_IF(ADDLI(ADDR_TMP_mapped, base, local_size - 40));
1285 addr_initialized = 1;
1288 FAIL_IF(LD_ADD(SLJIT_SAVED_EREG1_mapped, ADDR_TMP_mapped, 8));
1291 if (compiler->saveds >= 3) {
1292 if (addr_initialized == 0) {
1293 FAIL_IF(ADDLI(ADDR_TMP_mapped, base, local_size - 32));
1294 addr_initialized = 1;
1297 FAIL_IF(LD_ADD(SLJIT_SAVED_REG3_mapped, ADDR_TMP_mapped, 8));
1300 if (compiler->saveds >= 2) {
1301 if (addr_initialized == 0) {
1302 FAIL_IF(ADDLI(ADDR_TMP_mapped, base, local_size - 24));
1303 addr_initialized = 1;
1306 FAIL_IF(LD_ADD(SLJIT_SAVED_REG2_mapped, ADDR_TMP_mapped, 8));
1309 if (compiler->saveds >= 1) {
1310 if (addr_initialized == 0) {
1311 FAIL_IF(ADDLI(ADDR_TMP_mapped, base, local_size - 16));
1312 /* addr_initialized = 1; no need to initialize as it's the last one. */
1315 FAIL_IF(LD_ADD(SLJIT_SAVED_REG1_mapped, ADDR_TMP_mapped, 8));
1318 if (compiler->local_size <= SIMM_16BIT_MAX)
1319 FAIL_IF(ADDLI(SLJIT_LOCALS_REG_mapped, SLJIT_LOCALS_REG_mapped, compiler->local_size));
1321 FAIL_IF(ADD(SLJIT_LOCALS_REG_mapped, TMP_REG1_mapped, ZERO));
1326 /* reg_ar is an absoulute register! */
1328 /* Can perform an operation using at most 1 instruction. */
1329 static sljit_si getput_arg_fast(struct sljit_compiler *compiler, sljit_si flags, sljit_si reg_ar, sljit_si arg, sljit_sw argw)
1331 SLJIT_ASSERT(arg & SLJIT_MEM);
1333 if ((!(flags & WRITE_BACK) || !(arg & REG_MASK))
1334 && !(arg & OFFS_REG_MASK) && argw <= SIMM_16BIT_MAX && argw >= SIMM_16BIT_MIN) {
1335 /* Works for both absoulte and relative addresses. */
1336 if (SLJIT_UNLIKELY(flags & ARG_TEST))
1339 FAIL_IF(ADDLI(ADDR_TMP_mapped, reg_map[arg & REG_MASK], argw));
1341 if (flags & LOAD_DATA)
1342 FAIL_IF(PB2(data_transfer_insts[flags & MEM_MASK], reg_ar, ADDR_TMP_mapped));
1344 FAIL_IF(PB2(data_transfer_insts[flags & MEM_MASK], ADDR_TMP_mapped, reg_ar));
1352 /* See getput_arg below.
1353 Note: can_cache is called only for binary operators. Those
1354 operators always uses word arguments without write back. */
1355 static sljit_si can_cache(sljit_si arg, sljit_sw argw, sljit_si next_arg, sljit_sw next_argw)
1357 SLJIT_ASSERT((arg & SLJIT_MEM) && (next_arg & SLJIT_MEM));
1359 /* Simple operation except for updates. */
1360 if (arg & OFFS_REG_MASK) {
1363 if (argw && argw == next_argw
1364 && (arg == next_arg || (arg & OFFS_REG_MASK) == (next_arg & OFFS_REG_MASK)))
1369 if (arg == next_arg) {
1370 if (((next_argw - argw) <= SIMM_16BIT_MAX
1371 && (next_argw - argw) >= SIMM_16BIT_MIN))
1380 /* Emit the necessary instructions. See can_cache above. */
1381 static sljit_si getput_arg(struct sljit_compiler *compiler, sljit_si flags, sljit_si reg_ar, sljit_si arg, sljit_sw argw, sljit_si next_arg, sljit_sw next_argw)
1383 sljit_si tmp_ar, base;
1385 SLJIT_ASSERT(arg & SLJIT_MEM);
1386 if (!(next_arg & SLJIT_MEM)) {
1391 if ((flags & MEM_MASK) <= GPR_REG && (flags & LOAD_DATA))
1394 tmp_ar = TMP_REG1_mapped;
1396 base = arg & REG_MASK;
1398 if (SLJIT_UNLIKELY(arg & OFFS_REG_MASK)) {
1401 if ((flags & WRITE_BACK) && reg_ar == reg_map[base]) {
1402 SLJIT_ASSERT(!(flags & LOAD_DATA) && reg_map[TMP_REG1] != reg_ar);
1403 FAIL_IF(ADD(TMP_REG1_mapped, reg_ar, ZERO));
1404 reg_ar = TMP_REG1_mapped;
1407 /* Using the cache. */
1408 if (argw == compiler->cache_argw) {
1409 if (!(flags & WRITE_BACK)) {
1410 if (arg == compiler->cache_arg) {
1411 if (flags & LOAD_DATA)
1412 return PB2(data_transfer_insts[flags & MEM_MASK], reg_ar, TMP_REG3_mapped);
1414 return PB2(data_transfer_insts[flags & MEM_MASK], TMP_REG3_mapped, reg_ar);
1417 if ((SLJIT_MEM | (arg & OFFS_REG_MASK)) == compiler->cache_arg) {
1418 if (arg == next_arg && argw == (next_argw & 0x3)) {
1419 compiler->cache_arg = arg;
1420 compiler->cache_argw = argw;
1421 FAIL_IF(ADD(TMP_REG3_mapped, reg_map[base], TMP_REG3_mapped));
1422 if (flags & LOAD_DATA)
1423 return PB2(data_transfer_insts[flags & MEM_MASK], reg_ar, TMP_REG3_mapped);
1425 return PB2(data_transfer_insts[flags & MEM_MASK], TMP_REG3_mapped, reg_ar);
1428 FAIL_IF(ADD(tmp_ar, reg_map[base], TMP_REG3_mapped));
1429 if (flags & LOAD_DATA)
1430 return PB2(data_transfer_insts[flags & MEM_MASK], reg_ar, tmp_ar);
1432 return PB2(data_transfer_insts[flags & MEM_MASK], tmp_ar, reg_ar);
1435 if ((SLJIT_MEM | (arg & OFFS_REG_MASK)) == compiler->cache_arg) {
1436 FAIL_IF(ADD(reg_map[base], reg_map[base], TMP_REG3_mapped));
1437 if (flags & LOAD_DATA)
1438 return PB2(data_transfer_insts[flags & MEM_MASK], reg_ar, reg_map[base]);
1440 return PB2(data_transfer_insts[flags & MEM_MASK], reg_map[base], reg_ar);
1445 if (SLJIT_UNLIKELY(argw)) {
1446 compiler->cache_arg = SLJIT_MEM | (arg & OFFS_REG_MASK);
1447 compiler->cache_argw = argw;
1448 FAIL_IF(SHLI(TMP_REG3_mapped, reg_map[OFFS_REG(arg)], argw));
1451 if (!(flags & WRITE_BACK)) {
1452 if (arg == next_arg && argw == (next_argw & 0x3)) {
1453 compiler->cache_arg = arg;
1454 compiler->cache_argw = argw;
1455 FAIL_IF(ADD(TMP_REG3_mapped, reg_map[base], reg_map[!argw ? OFFS_REG(arg) : TMP_REG3]));
1456 tmp_ar = TMP_REG3_mapped;
1458 FAIL_IF(ADD(tmp_ar, reg_map[base], reg_map[!argw ? OFFS_REG(arg) : TMP_REG3]));
1460 if (flags & LOAD_DATA)
1461 return PB2(data_transfer_insts[flags & MEM_MASK], reg_ar, tmp_ar);
1463 return PB2(data_transfer_insts[flags & MEM_MASK], tmp_ar, reg_ar);
1466 FAIL_IF(ADD(reg_map[base], reg_map[base], reg_map[!argw ? OFFS_REG(arg) : TMP_REG3]));
1468 if (flags & LOAD_DATA)
1469 return PB2(data_transfer_insts[flags & MEM_MASK], reg_ar, reg_map[base]);
1471 return PB2(data_transfer_insts[flags & MEM_MASK], reg_map[base], reg_ar);
1474 if (SLJIT_UNLIKELY(flags & WRITE_BACK) && base) {
1475 /* Update only applies if a base register exists. */
1476 if (reg_ar == reg_map[base]) {
1477 SLJIT_ASSERT(!(flags & LOAD_DATA) && TMP_REG1_mapped != reg_ar);
1478 if (argw <= SIMM_16BIT_MAX && argw >= SIMM_16BIT_MIN) {
1479 FAIL_IF(ADDLI(ADDR_TMP_mapped, reg_map[base], argw));
1480 if (flags & LOAD_DATA)
1481 FAIL_IF(PB2(data_transfer_insts[flags & MEM_MASK], reg_ar, ADDR_TMP_mapped));
1483 FAIL_IF(PB2(data_transfer_insts[flags & MEM_MASK], ADDR_TMP_mapped, reg_ar));
1486 return ADDLI(reg_map[base], reg_map[base], argw);
1488 return SLJIT_SUCCESS;
1491 FAIL_IF(ADD(TMP_REG1_mapped, reg_ar, ZERO));
1492 reg_ar = TMP_REG1_mapped;
1495 if (argw <= SIMM_16BIT_MAX && argw >= SIMM_16BIT_MIN) {
1497 FAIL_IF(ADDLI(reg_map[base], reg_map[base], argw));
1499 if (compiler->cache_arg == SLJIT_MEM
1500 && argw - compiler->cache_argw <= SIMM_16BIT_MAX
1501 && argw - compiler->cache_argw >= SIMM_16BIT_MIN) {
1502 if (argw != compiler->cache_argw) {
1503 FAIL_IF(ADD(TMP_REG3_mapped, TMP_REG3_mapped, argw - compiler->cache_argw));
1504 compiler->cache_argw = argw;
1507 FAIL_IF(ADD(reg_map[base], reg_map[base], TMP_REG3_mapped));
1509 compiler->cache_arg = SLJIT_MEM;
1510 compiler->cache_argw = argw;
1511 FAIL_IF(load_immediate(compiler, TMP_REG3_mapped, argw));
1512 FAIL_IF(ADD(reg_map[base], reg_map[base], TMP_REG3_mapped));
1516 if (flags & LOAD_DATA)
1517 return PB2(data_transfer_insts[flags & MEM_MASK], reg_ar, reg_map[base]);
1519 return PB2(data_transfer_insts[flags & MEM_MASK], reg_map[base], reg_ar);
1522 if (compiler->cache_arg == arg
1523 && argw - compiler->cache_argw <= SIMM_16BIT_MAX
1524 && argw - compiler->cache_argw >= SIMM_16BIT_MIN) {
1525 if (argw != compiler->cache_argw) {
1526 FAIL_IF(ADDLI(TMP_REG3_mapped, TMP_REG3_mapped, argw - compiler->cache_argw));
1527 compiler->cache_argw = argw;
1530 if (flags & LOAD_DATA)
1531 return PB2(data_transfer_insts[flags & MEM_MASK], reg_ar, TMP_REG3_mapped);
1533 return PB2(data_transfer_insts[flags & MEM_MASK], TMP_REG3_mapped, reg_ar);
1536 if (compiler->cache_arg == SLJIT_MEM
1537 && argw - compiler->cache_argw <= SIMM_16BIT_MAX
1538 && argw - compiler->cache_argw >= SIMM_16BIT_MIN) {
1539 if (argw != compiler->cache_argw)
1540 FAIL_IF(ADDLI(TMP_REG3_mapped, TMP_REG3_mapped, argw - compiler->cache_argw));
1542 compiler->cache_arg = SLJIT_MEM;
1543 FAIL_IF(load_immediate(compiler, TMP_REG3_mapped, argw));
1546 compiler->cache_argw = argw;
1549 if (flags & LOAD_DATA)
1550 return PB2(data_transfer_insts[flags & MEM_MASK], reg_ar, TMP_REG3_mapped);
1552 return PB2(data_transfer_insts[flags & MEM_MASK], TMP_REG3_mapped, reg_ar);
1556 && next_argw - argw <= SIMM_16BIT_MAX
1557 && next_argw - argw >= SIMM_16BIT_MIN) {
1558 compiler->cache_arg = arg;
1559 FAIL_IF(ADD(TMP_REG3_mapped, TMP_REG3_mapped, reg_map[base]));
1560 if (flags & LOAD_DATA)
1561 return PB2(data_transfer_insts[flags & MEM_MASK], reg_ar, TMP_REG3_mapped);
1563 return PB2(data_transfer_insts[flags & MEM_MASK], TMP_REG3_mapped, reg_ar);
1566 FAIL_IF(ADD(tmp_ar, TMP_REG3_mapped, reg_map[base]));
1568 if (flags & LOAD_DATA)
1569 return PB2(data_transfer_insts[flags & MEM_MASK], reg_ar, tmp_ar);
1571 return PB2(data_transfer_insts[flags & MEM_MASK], tmp_ar, reg_ar);
1574 static SLJIT_INLINE sljit_si emit_op_mem(struct sljit_compiler *compiler, sljit_si flags, sljit_si reg_ar, sljit_si arg, sljit_sw argw)
1576 if (getput_arg_fast(compiler, flags, reg_ar, arg, argw))
1577 return compiler->error;
1579 compiler->cache_arg = 0;
1580 compiler->cache_argw = 0;
1581 return getput_arg(compiler, flags, reg_ar, arg, argw, 0, 0);
1584 static SLJIT_INLINE sljit_si emit_op_mem2(struct sljit_compiler *compiler, sljit_si flags, sljit_si reg, sljit_si arg1, sljit_sw arg1w, sljit_si arg2, sljit_sw arg2w)
1586 if (getput_arg_fast(compiler, flags, reg, arg1, arg1w))
1587 return compiler->error;
1588 return getput_arg(compiler, flags, reg, arg1, arg1w, arg2, arg2w);
1591 SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_fast_enter(struct sljit_compiler *compiler, sljit_si dst, sljit_sw dstw)
1594 check_sljit_emit_fast_enter(compiler, dst, dstw);
1595 ADJUST_LOCAL_OFFSET(dst, dstw);
1597 /* For UNUSED dst. Uncommon, but possible. */
1598 if (dst == SLJIT_UNUSED)
1599 return SLJIT_SUCCESS;
1601 if (FAST_IS_REG(dst))
1602 return ADD(reg_map[dst], RA, ZERO);
1605 return emit_op_mem(compiler, WORD_DATA, RA, dst, dstw);
1608 SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_fast_return(struct sljit_compiler *compiler, sljit_si src, sljit_sw srcw)
1611 check_sljit_emit_fast_return(compiler, src, srcw);
1612 ADJUST_LOCAL_OFFSET(src, srcw);
1614 if (FAST_IS_REG(src))
1615 FAIL_IF(ADD(RA, reg_map[src], ZERO));
1617 else if (src & SLJIT_MEM)
1618 FAIL_IF(emit_op_mem(compiler, WORD_DATA | LOAD_DATA, RA, src, srcw));
1620 else if (src & SLJIT_IMM)
1621 FAIL_IF(load_immediate(compiler, RA, srcw));
1626 static SLJIT_INLINE sljit_si emit_single_op(struct sljit_compiler *compiler, sljit_si op, sljit_si flags, sljit_si dst, sljit_si src1, sljit_sw src2)
1628 sljit_si overflow_ra = 0;
1630 switch (GET_OPCODE(op)) {
1633 SLJIT_ASSERT(src1 == TMP_REG1 && !(flags & SRC2_IMM));
1635 return ADD(reg_map[dst], reg_map[src2], ZERO);
1636 return SLJIT_SUCCESS;
1640 SLJIT_ASSERT(src1 == TMP_REG1 && !(flags & SRC2_IMM));
1641 if ((flags & (REG_DEST | REG2_SOURCE)) == (REG_DEST | REG2_SOURCE)) {
1642 if (op == SLJIT_MOV_SI)
1643 return BFEXTS(reg_map[dst], reg_map[src2], 0, 31);
1645 return BFEXTU(reg_map[dst], reg_map[src2], 0, 31);
1646 } else if (dst != src2)
1647 SLJIT_ASSERT_STOP();
1649 return SLJIT_SUCCESS;
1653 SLJIT_ASSERT(src1 == TMP_REG1 && !(flags & SRC2_IMM));
1654 if ((flags & (REG_DEST | REG2_SOURCE)) == (REG_DEST | REG2_SOURCE)) {
1655 if (op == SLJIT_MOV_SB)
1656 return BFEXTS(reg_map[dst], reg_map[src2], 0, 7);
1658 return BFEXTU(reg_map[dst], reg_map[src2], 0, 7);
1659 } else if (dst != src2)
1660 SLJIT_ASSERT_STOP();
1662 return SLJIT_SUCCESS;
1666 SLJIT_ASSERT(src1 == TMP_REG1 && !(flags & SRC2_IMM));
1667 if ((flags & (REG_DEST | REG2_SOURCE)) == (REG_DEST | REG2_SOURCE)) {
1668 if (op == SLJIT_MOV_SH)
1669 return BFEXTS(reg_map[dst], reg_map[src2], 0, 15);
1671 return BFEXTU(reg_map[dst], reg_map[src2], 0, 15);
1672 } else if (dst != src2)
1673 SLJIT_ASSERT_STOP();
1675 return SLJIT_SUCCESS;
1678 SLJIT_ASSERT(src1 == TMP_REG1 && !(flags & SRC2_IMM));
1679 if (op & SLJIT_SET_E)
1680 FAIL_IF(NOR(EQUAL_FLAG, reg_map[src2], reg_map[src2]));
1681 if (CHECK_FLAGS(SLJIT_SET_E))
1682 FAIL_IF(NOR(reg_map[dst], reg_map[src2], reg_map[src2]));
1684 return SLJIT_SUCCESS;
1687 SLJIT_ASSERT(src1 == TMP_REG1 && !(flags & SRC2_IMM));
1688 if (op & SLJIT_SET_E)
1689 FAIL_IF(CLZ(EQUAL_FLAG, reg_map[src2]));
1690 if (CHECK_FLAGS(SLJIT_SET_E))
1691 FAIL_IF(CLZ(reg_map[dst], reg_map[src2]));
1693 return SLJIT_SUCCESS;
1696 if (flags & SRC2_IMM) {
1697 if (op & SLJIT_SET_O) {
1698 FAIL_IF(SHRUI(TMP_EREG1, reg_map[src1], 63));
1700 FAIL_IF(XORI(TMP_EREG1, TMP_EREG1, 1));
1703 if (op & SLJIT_SET_E)
1704 FAIL_IF(ADDLI(EQUAL_FLAG, reg_map[src1], src2));
1706 if (op & SLJIT_SET_C) {
1708 FAIL_IF(ORI(ULESS_FLAG ,reg_map[src1], src2));
1710 FAIL_IF(ADDLI(ULESS_FLAG ,ZERO, src2));
1711 FAIL_IF(OR(ULESS_FLAG,reg_map[src1],ULESS_FLAG));
1715 /* dst may be the same as src1 or src2. */
1716 if (CHECK_FLAGS(SLJIT_SET_E))
1717 FAIL_IF(ADDLI(reg_map[dst], reg_map[src1], src2));
1719 if (op & SLJIT_SET_O) {
1720 FAIL_IF(SHRUI(OVERFLOW_FLAG, reg_map[dst], 63));
1723 FAIL_IF(XORI(OVERFLOW_FLAG, OVERFLOW_FLAG, 1));
1726 if (op & SLJIT_SET_O) {
1727 FAIL_IF(XOR(TMP_EREG1, reg_map[src1], reg_map[src2]));
1728 FAIL_IF(SHRUI(TMP_EREG1, TMP_EREG1, 63));
1731 overflow_ra = reg_map[src1];
1732 else if (src2 != dst)
1733 overflow_ra = reg_map[src2];
1736 FAIL_IF(ADD(TMP_EREG2, reg_map[src1], ZERO));
1737 overflow_ra = TMP_EREG2;
1741 if (op & SLJIT_SET_E)
1742 FAIL_IF(ADD(EQUAL_FLAG ,reg_map[src1], reg_map[src2]));
1744 if (op & SLJIT_SET_C)
1745 FAIL_IF(OR(ULESS_FLAG,reg_map[src1], reg_map[src2]));
1747 /* dst may be the same as src1 or src2. */
1748 if (CHECK_FLAGS(SLJIT_SET_E))
1749 FAIL_IF(ADD(reg_map[dst],reg_map[src1], reg_map[src2]));
1751 if (op & SLJIT_SET_O) {
1752 FAIL_IF(XOR(OVERFLOW_FLAG,reg_map[dst], overflow_ra));
1753 FAIL_IF(SHRUI(OVERFLOW_FLAG, OVERFLOW_FLAG, 63));
1757 /* a + b >= a | b (otherwise, the carry should be set to 1). */
1758 if (op & SLJIT_SET_C)
1759 FAIL_IF(CMPLTU(ULESS_FLAG ,reg_map[dst] ,ULESS_FLAG));
1761 if (op & SLJIT_SET_O)
1762 return CMOVNEZ(OVERFLOW_FLAG, TMP_EREG1, ZERO);
1764 return SLJIT_SUCCESS;
1767 if (flags & SRC2_IMM) {
1768 if (op & SLJIT_SET_C) {
1770 FAIL_IF(ORI(TMP_EREG1, reg_map[src1], src2));
1772 FAIL_IF(ADDLI(TMP_EREG1, ZERO, src2));
1773 FAIL_IF(OR(TMP_EREG1, reg_map[src1], TMP_EREG1));
1777 FAIL_IF(ADDLI(reg_map[dst], reg_map[src1], src2));
1780 if (op & SLJIT_SET_C)
1781 FAIL_IF(OR(TMP_EREG1, reg_map[src1], reg_map[src2]));
1783 /* dst may be the same as src1 or src2. */
1784 FAIL_IF(ADD(reg_map[dst], reg_map[src1], reg_map[src2]));
1787 if (op & SLJIT_SET_C)
1788 FAIL_IF(CMPLTU(TMP_EREG1, reg_map[dst], TMP_EREG1));
1790 FAIL_IF(ADD(reg_map[dst], reg_map[dst], ULESS_FLAG));
1792 if (!(op & SLJIT_SET_C))
1793 return SLJIT_SUCCESS;
1795 /* Set TMP_EREG2 (dst == 0) && (ULESS_FLAG == 1). */
1796 FAIL_IF(CMPLTUI(TMP_EREG2, reg_map[dst], 1));
1797 FAIL_IF(AND(TMP_EREG2, TMP_EREG2, ULESS_FLAG));
1798 /* Set carry flag. */
1799 return OR(ULESS_FLAG, TMP_EREG2, TMP_EREG1);
1802 if ((flags & SRC2_IMM) && ((op & (SLJIT_SET_U | SLJIT_SET_S)) || src2 == SIMM_16BIT_MIN)) {
1803 FAIL_IF(ADDLI(TMP_REG2_mapped, ZERO, src2));
1808 if (flags & SRC2_IMM) {
1809 if (op & SLJIT_SET_O) {
1810 FAIL_IF(SHRUI(TMP_EREG1,reg_map[src1], 63));
1813 FAIL_IF(XORI(TMP_EREG1, TMP_EREG1, 1));
1816 overflow_ra = reg_map[src1];
1819 FAIL_IF(ADD(TMP_EREG2, reg_map[src1], ZERO));
1821 overflow_ra = TMP_EREG2;
1825 if (op & SLJIT_SET_E)
1826 FAIL_IF(ADDLI(EQUAL_FLAG, reg_map[src1], -src2));
1828 if (op & SLJIT_SET_C) {
1829 FAIL_IF(load_immediate(compiler, ADDR_TMP_mapped, src2));
1830 FAIL_IF(CMPLTU(ULESS_FLAG, reg_map[src1], ADDR_TMP_mapped));
1833 /* dst may be the same as src1 or src2. */
1834 if (CHECK_FLAGS(SLJIT_SET_E))
1835 FAIL_IF(ADDLI(reg_map[dst], reg_map[src1], -src2));
1839 if (op & SLJIT_SET_O) {
1840 FAIL_IF(XOR(TMP_EREG1, reg_map[src1], reg_map[src2]));
1841 FAIL_IF(SHRUI(TMP_EREG1, TMP_EREG1, 63));
1844 overflow_ra = reg_map[src1];
1847 FAIL_IF(ADD(TMP_EREG2, reg_map[src1], ZERO));
1848 overflow_ra = TMP_EREG2;
1852 if (op & SLJIT_SET_E)
1853 FAIL_IF(SUB(EQUAL_FLAG, reg_map[src1], reg_map[src2]));
1855 if (op & (SLJIT_SET_U | SLJIT_SET_C))
1856 FAIL_IF(CMPLTU(ULESS_FLAG, reg_map[src1], reg_map[src2]));
1858 if (op & SLJIT_SET_U)
1859 FAIL_IF(CMPLTU(UGREATER_FLAG, reg_map[src2], reg_map[src1]));
1861 if (op & SLJIT_SET_S) {
1862 FAIL_IF(CMPLTS(LESS_FLAG ,reg_map[src1] ,reg_map[src2]));
1863 FAIL_IF(CMPLTS(GREATER_FLAG ,reg_map[src2] ,reg_map[src1]));
1866 /* dst may be the same as src1 or src2. */
1867 if (CHECK_FLAGS(SLJIT_SET_E | SLJIT_SET_U | SLJIT_SET_S | SLJIT_SET_C))
1868 FAIL_IF(SUB(reg_map[dst], reg_map[src1], reg_map[src2]));
1871 if (op & SLJIT_SET_O) {
1872 FAIL_IF(XOR(OVERFLOW_FLAG, reg_map[dst], overflow_ra));
1873 FAIL_IF(SHRUI(OVERFLOW_FLAG, OVERFLOW_FLAG, 63));
1874 return CMOVEQZ(OVERFLOW_FLAG, TMP_EREG1, ZERO);
1877 return SLJIT_SUCCESS;
1880 if ((flags & SRC2_IMM) && src2 == SIMM_16BIT_MIN) {
1881 FAIL_IF(ADDLI(TMP_REG2_mapped, ZERO, src2));
1886 if (flags & SRC2_IMM) {
1887 if (op & SLJIT_SET_C) {
1888 FAIL_IF(load_immediate(compiler, ADDR_TMP_mapped, -src2));
1889 FAIL_IF(CMPLTU(TMP_EREG1, reg_map[src1], ADDR_TMP_mapped));
1892 /* dst may be the same as src1 or src2. */
1893 FAIL_IF(ADDLI(reg_map[dst], reg_map[src1], -src2));
1896 if (op & SLJIT_SET_C)
1897 FAIL_IF(CMPLTU(TMP_EREG1, reg_map[src1], reg_map[src2]));
1898 /* dst may be the same as src1 or src2. */
1899 FAIL_IF(SUB(reg_map[dst], reg_map[src1], reg_map[src2]));
1902 if (op & SLJIT_SET_C)
1903 FAIL_IF(CMOVEQZ(TMP_EREG1, reg_map[dst], ULESS_FLAG));
1905 FAIL_IF(SUB(reg_map[dst], reg_map[dst], ULESS_FLAG));
1907 if (op & SLJIT_SET_C)
1908 FAIL_IF(ADD(ULESS_FLAG, TMP_EREG1, ZERO));
1910 return SLJIT_SUCCESS;
1912 #define EMIT_LOGICAL(op_imm, op_norm) \
1913 if (flags & SRC2_IMM) { \
1914 FAIL_IF(load_immediate(compiler, ADDR_TMP_mapped, src2)); \
1915 if (op & SLJIT_SET_E) \
1916 FAIL_IF(push_3_buffer( \
1917 compiler, op_norm, EQUAL_FLAG, reg_map[src1], \
1918 ADDR_TMP_mapped, __LINE__)); \
1919 if (CHECK_FLAGS(SLJIT_SET_E)) \
1920 FAIL_IF(push_3_buffer( \
1921 compiler, op_norm, reg_map[dst], reg_map[src1], \
1922 ADDR_TMP_mapped, __LINE__)); \
1924 if (op & SLJIT_SET_E) \
1925 FAIL_IF(push_3_buffer( \
1926 compiler, op_norm, EQUAL_FLAG, reg_map[src1], \
1927 reg_map[src2], __LINE__)); \
1928 if (CHECK_FLAGS(SLJIT_SET_E)) \
1929 FAIL_IF(push_3_buffer( \
1930 compiler, op_norm, reg_map[dst], reg_map[src1], \
1931 reg_map[src2], __LINE__)); \
1935 EMIT_LOGICAL(TILEGX_OPC_ANDI, TILEGX_OPC_AND);
1936 return SLJIT_SUCCESS;
1939 EMIT_LOGICAL(TILEGX_OPC_ORI, TILEGX_OPC_OR);
1940 return SLJIT_SUCCESS;
1943 EMIT_LOGICAL(TILEGX_OPC_XORI, TILEGX_OPC_XOR);
1944 return SLJIT_SUCCESS;
1946 #define EMIT_SHIFT(op_imm, op_norm) \
1947 if (flags & SRC2_IMM) { \
1948 if (op & SLJIT_SET_E) \
1949 FAIL_IF(push_3_buffer( \
1950 compiler, op_imm, EQUAL_FLAG, reg_map[src1], \
1951 src2 & 0x3F, __LINE__)); \
1952 if (CHECK_FLAGS(SLJIT_SET_E)) \
1953 FAIL_IF(push_3_buffer( \
1954 compiler, op_imm, reg_map[dst], reg_map[src1], \
1955 src2 & 0x3F, __LINE__)); \
1957 if (op & SLJIT_SET_E) \
1958 FAIL_IF(push_3_buffer( \
1959 compiler, op_imm, reg_map[dst], reg_map[src1], \
1960 src2 & 0x3F, __LINE__)); \
1961 if (CHECK_FLAGS(SLJIT_SET_E)) \
1962 FAIL_IF(push_3_buffer( \
1963 compiler, op_norm, reg_map[dst], reg_map[src1], \
1964 reg_map[src2], __LINE__)); \
1968 EMIT_SHIFT(TILEGX_OPC_SHLI, TILEGX_OPC_SHL);
1969 return SLJIT_SUCCESS;
1972 EMIT_SHIFT(TILEGX_OPC_SHRUI, TILEGX_OPC_SHRU);
1973 return SLJIT_SUCCESS;
1976 EMIT_SHIFT(TILEGX_OPC_SHRSI, TILEGX_OPC_SHRS);
1977 return SLJIT_SUCCESS;
1980 SLJIT_ASSERT_STOP();
1981 return SLJIT_SUCCESS;
1984 static sljit_si emit_op(struct sljit_compiler *compiler, sljit_si op, sljit_si flags, sljit_si dst, sljit_sw dstw, sljit_si src1, sljit_sw src1w, sljit_si src2, sljit_sw src2w)
1986 /* arg1 goes to TMP_REG1 or src reg.
1987 arg2 goes to TMP_REG2, imm or src reg.
1988 TMP_REG3 can be used for caching.
1989 result goes to TMP_REG2, so put result can use TMP_REG1 and TMP_REG3. */
1990 sljit_si dst_r = TMP_REG2;
1992 sljit_sw src2_r = 0;
1993 sljit_si sugg_src2_r = TMP_REG2;
1995 if (!(flags & ALT_KEEP_CACHE)) {
1996 compiler->cache_arg = 0;
1997 compiler->cache_argw = 0;
2000 if (SLJIT_UNLIKELY(dst == SLJIT_UNUSED)) {
2001 if (op >= SLJIT_MOV && op <= SLJIT_MOVU_SI && !(src2 & SLJIT_MEM))
2002 return SLJIT_SUCCESS;
2004 flags |= UNUSED_DEST;
2005 } else if (FAST_IS_REG(dst)) {
2008 if (op >= SLJIT_MOV && op <= SLJIT_MOVU_SI)
2009 sugg_src2_r = dst_r;
2010 } else if ((dst & SLJIT_MEM) && !getput_arg_fast(compiler, flags | ARG_TEST, TMP_REG1_mapped, dst, dstw))
2013 if (flags & IMM_OP) {
2014 if ((src2 & SLJIT_IMM) && src2w) {
2015 if ((!(flags & LOGICAL_OP)
2016 && (src2w <= SIMM_16BIT_MAX && src2w >= SIMM_16BIT_MIN))
2017 || ((flags & LOGICAL_OP) && !(src2w & ~UIMM_16BIT_MAX))) {
2023 if (!(flags & SRC2_IMM) && (flags & CUMULATIVE_OP) && (src1 & SLJIT_IMM) && src1w) {
2024 if ((!(flags & LOGICAL_OP)
2025 && (src1w <= SIMM_16BIT_MAX && src1w >= SIMM_16BIT_MIN))
2026 || ((flags & LOGICAL_OP) && !(src1w & ~UIMM_16BIT_MAX))) {
2030 /* And swap arguments. */
2034 /* src2w = src2_r unneeded. */
2040 if (FAST_IS_REG(src1)) {
2042 flags |= REG1_SOURCE;
2043 } else if (src1 & SLJIT_IMM) {
2045 FAIL_IF(load_immediate(compiler, TMP_REG1_mapped, src1w));
2050 if (getput_arg_fast(compiler, flags | LOAD_DATA, TMP_REG1_mapped, src1, src1w))
2051 FAIL_IF(compiler->error);
2058 if (FAST_IS_REG(src2)) {
2060 flags |= REG2_SOURCE;
2061 if (!(flags & REG_DEST) && op >= SLJIT_MOV && op <= SLJIT_MOVU_SI)
2063 } else if (src2 & SLJIT_IMM) {
2064 if (!(flags & SRC2_IMM)) {
2066 FAIL_IF(load_immediate(compiler, reg_map[sugg_src2_r], src2w));
2067 src2_r = sugg_src2_r;
2070 if ((op >= SLJIT_MOV && op <= SLJIT_MOVU_SI) && (dst & SLJIT_MEM))
2075 if (getput_arg_fast(compiler, flags | LOAD_DATA, reg_map[sugg_src2_r], src2, src2w))
2076 FAIL_IF(compiler->error);
2079 src2_r = sugg_src2_r;
2082 if ((flags & (SLOW_SRC1 | SLOW_SRC2)) == (SLOW_SRC1 | SLOW_SRC2)) {
2083 SLJIT_ASSERT(src2_r == TMP_REG2);
2084 if (!can_cache(src1, src1w, src2, src2w) && can_cache(src1, src1w, dst, dstw)) {
2085 FAIL_IF(getput_arg(compiler, flags | LOAD_DATA, TMP_REG2_mapped, src2, src2w, src1, src1w));
2086 FAIL_IF(getput_arg(compiler, flags | LOAD_DATA, TMP_REG1_mapped, src1, src1w, dst, dstw));
2088 FAIL_IF(getput_arg(compiler, flags | LOAD_DATA, TMP_REG1_mapped, src1, src1w, src2, src2w));
2089 FAIL_IF(getput_arg(compiler, flags | LOAD_DATA, TMP_REG2_mapped, src2, src2w, dst, dstw));
2091 } else if (flags & SLOW_SRC1)
2092 FAIL_IF(getput_arg(compiler, flags | LOAD_DATA, TMP_REG1_mapped, src1, src1w, dst, dstw));
2093 else if (flags & SLOW_SRC2)
2094 FAIL_IF(getput_arg(compiler, flags | LOAD_DATA, reg_map[sugg_src2_r], src2, src2w, dst, dstw));
2096 FAIL_IF(emit_single_op(compiler, op, flags, dst_r, src1_r, src2_r));
2098 if (dst & SLJIT_MEM) {
2099 if (!(flags & SLOW_DEST)) {
2100 getput_arg_fast(compiler, flags, reg_map[dst_r], dst, dstw);
2101 return compiler->error;
2104 return getput_arg(compiler, flags, reg_map[dst_r], dst, dstw, 0, 0);
2107 return SLJIT_SUCCESS;
2110 SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_op_flags(struct sljit_compiler *compiler, sljit_si op, sljit_si dst, sljit_sw dstw, sljit_si src, sljit_sw srcw, sljit_si type)
2112 sljit_si sugg_dst_ar, dst_ar;
2113 sljit_si flags = GET_ALL_FLAGS(op);
2116 check_sljit_emit_op_flags(compiler, op, dst, dstw, src, srcw, type);
2117 ADJUST_LOCAL_OFFSET(dst, dstw);
2119 if (dst == SLJIT_UNUSED)
2120 return SLJIT_SUCCESS;
2122 op = GET_OPCODE(op);
2123 sugg_dst_ar = reg_map[(op < SLJIT_ADD && FAST_IS_REG(dst)) ? dst : TMP_REG2];
2125 compiler->cache_arg = 0;
2126 compiler->cache_argw = 0;
2127 if (op >= SLJIT_ADD && (src & SLJIT_MEM)) {
2128 ADJUST_LOCAL_OFFSET(src, srcw);
2129 FAIL_IF(emit_op_mem2(compiler, WORD_DATA | LOAD_DATA, TMP_REG1_mapped, src, srcw, dst, dstw));
2136 case SLJIT_C_NOT_EQUAL:
2137 FAIL_IF(CMPLTUI(sugg_dst_ar, EQUAL_FLAG, 1));
2138 dst_ar = sugg_dst_ar;
2141 case SLJIT_C_GREATER_EQUAL:
2142 case SLJIT_C_FLOAT_LESS:
2143 case SLJIT_C_FLOAT_GREATER_EQUAL:
2144 dst_ar = ULESS_FLAG;
2146 case SLJIT_C_GREATER:
2147 case SLJIT_C_LESS_EQUAL:
2148 case SLJIT_C_FLOAT_GREATER:
2149 case SLJIT_C_FLOAT_LESS_EQUAL:
2150 dst_ar = UGREATER_FLAG;
2152 case SLJIT_C_SIG_LESS:
2153 case SLJIT_C_SIG_GREATER_EQUAL:
2156 case SLJIT_C_SIG_GREATER:
2157 case SLJIT_C_SIG_LESS_EQUAL:
2158 dst_ar = GREATER_FLAG;
2160 case SLJIT_C_OVERFLOW:
2161 case SLJIT_C_NOT_OVERFLOW:
2162 dst_ar = OVERFLOW_FLAG;
2164 case SLJIT_C_MUL_OVERFLOW:
2165 case SLJIT_C_MUL_NOT_OVERFLOW:
2166 FAIL_IF(CMPLTUI(sugg_dst_ar, OVERFLOW_FLAG, 1));
2167 dst_ar = sugg_dst_ar;
2168 type ^= 0x1; /* Flip type bit for the XORI below. */
2170 case SLJIT_C_FLOAT_EQUAL:
2171 case SLJIT_C_FLOAT_NOT_EQUAL:
2172 dst_ar = EQUAL_FLAG;
2176 SLJIT_ASSERT_STOP();
2177 dst_ar = sugg_dst_ar;
2182 FAIL_IF(XORI(sugg_dst_ar, dst_ar, 1));
2183 dst_ar = sugg_dst_ar;
2186 if (op >= SLJIT_ADD) {
2187 if (TMP_REG2_mapped != dst_ar)
2188 FAIL_IF(ADD(TMP_REG2_mapped, dst_ar, ZERO));
2189 return emit_op(compiler, op | flags, CUMULATIVE_OP | LOGICAL_OP | IMM_OP | ALT_KEEP_CACHE, dst, dstw, src, srcw, TMP_REG2, 0);
2192 if (dst & SLJIT_MEM)
2193 return emit_op_mem(compiler, WORD_DATA, dst_ar, dst, dstw);
2195 if (sugg_dst_ar != dst_ar)
2196 return ADD(sugg_dst_ar, dst_ar, ZERO);
2198 return SLJIT_SUCCESS;
2201 SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_op0(struct sljit_compiler *compiler, sljit_si op) {
2203 check_sljit_emit_op0(compiler, op);
2205 op = GET_OPCODE(op);
2208 return push_0_buffer(compiler, TILEGX_OPC_FNOP, __LINE__);
2210 case SLJIT_BREAKPOINT:
2217 SLJIT_ASSERT_STOP();
2220 return SLJIT_SUCCESS;
2223 SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_op1(struct sljit_compiler *compiler, sljit_si op, sljit_si dst, sljit_sw dstw, sljit_si src, sljit_sw srcw)
2226 check_sljit_emit_op1(compiler, op, dst, dstw, src, srcw);
2227 ADJUST_LOCAL_OFFSET(dst, dstw);
2228 ADJUST_LOCAL_OFFSET(src, srcw);
2230 switch (GET_OPCODE(op)) {
2233 return emit_op(compiler, SLJIT_MOV, WORD_DATA, dst, dstw, TMP_REG1, 0, src, srcw);
2236 return emit_op(compiler, SLJIT_MOV_UI, INT_DATA, dst, dstw, TMP_REG1, 0, src, srcw);
2239 return emit_op(compiler, SLJIT_MOV_SI, INT_DATA | SIGNED_DATA, dst, dstw, TMP_REG1, 0, src, srcw);
2242 return emit_op(compiler, SLJIT_MOV_UB, BYTE_DATA, dst, dstw, TMP_REG1, 0, src, (src & SLJIT_IMM) ? (sljit_ub) srcw : srcw);
2245 return emit_op(compiler, SLJIT_MOV_SB, BYTE_DATA | SIGNED_DATA, dst, dstw, TMP_REG1, 0, src, (src & SLJIT_IMM) ? (sljit_sb) srcw : srcw);
2248 return emit_op(compiler, SLJIT_MOV_UH, HALF_DATA, dst, dstw, TMP_REG1, 0, src, (src & SLJIT_IMM) ? (sljit_uh) srcw : srcw);
2251 return emit_op(compiler, SLJIT_MOV_SH, HALF_DATA | SIGNED_DATA, dst, dstw, TMP_REG1, 0, src, (src & SLJIT_IMM) ? (sljit_sh) srcw : srcw);
2255 return emit_op(compiler, SLJIT_MOV, WORD_DATA | WRITE_BACK, dst, dstw, TMP_REG1, 0, src, srcw);
2258 return emit_op(compiler, SLJIT_MOV_UI, INT_DATA | WRITE_BACK, dst, dstw, TMP_REG1, 0, src, srcw);
2261 return emit_op(compiler, SLJIT_MOV_SI, INT_DATA | SIGNED_DATA | WRITE_BACK, dst, dstw, TMP_REG1, 0, src, srcw);
2264 return emit_op(compiler, SLJIT_MOV_UB, BYTE_DATA | WRITE_BACK, dst, dstw, TMP_REG1, 0, src, (src & SLJIT_IMM) ? (sljit_ub) srcw : srcw);
2267 return emit_op(compiler, SLJIT_MOV_SB, BYTE_DATA | SIGNED_DATA | WRITE_BACK, dst, dstw, TMP_REG1, 0, src, (src & SLJIT_IMM) ? (sljit_sb) srcw : srcw);
2270 return emit_op(compiler, SLJIT_MOV_UH, HALF_DATA | WRITE_BACK, dst, dstw, TMP_REG1, 0, src, (src & SLJIT_IMM) ? (sljit_uh) srcw : srcw);
2273 return emit_op(compiler, SLJIT_MOV_SH, HALF_DATA | SIGNED_DATA | WRITE_BACK, dst, dstw, TMP_REG1, 0, src, (src & SLJIT_IMM) ? (sljit_sh) srcw : srcw);
2276 return emit_op(compiler, op, 0, dst, dstw, TMP_REG1, 0, src, srcw);
2279 return emit_op(compiler, SLJIT_SUB | GET_ALL_FLAGS(op), IMM_OP, dst, dstw, SLJIT_IMM, 0, src, srcw);
2282 return emit_op(compiler, op, 0, dst, dstw, TMP_REG1, 0, src, srcw);
2285 return SLJIT_SUCCESS;
2288 SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_op2(struct sljit_compiler *compiler, sljit_si op, sljit_si dst, sljit_sw dstw, sljit_si src1, sljit_sw src1w, sljit_si src2, sljit_sw src2w)
2291 check_sljit_emit_op2(compiler, op, dst, dstw, src1, src1w, src2, src2w);
2292 ADJUST_LOCAL_OFFSET(dst, dstw);
2293 ADJUST_LOCAL_OFFSET(src1, src1w);
2294 ADJUST_LOCAL_OFFSET(src2, src2w);
2296 switch (GET_OPCODE(op)) {
2299 return emit_op(compiler, op, CUMULATIVE_OP | IMM_OP, dst, dstw, src1, src1w, src2, src2w);
2303 return emit_op(compiler, op, IMM_OP, dst, dstw, src1, src1w, src2, src2w);
2306 return emit_op(compiler, op, CUMULATIVE_OP, dst, dstw, src1, src1w, src2, src2w);
2311 return emit_op(compiler, op, CUMULATIVE_OP | LOGICAL_OP | IMM_OP, dst, dstw, src1, src1w, src2, src2w);
2316 if (src2 & SLJIT_IMM)
2318 if (op & SLJIT_INT_OP)
2321 return emit_op(compiler, op, IMM_OP, dst, dstw, src1, src1w, src2, src2w);
2324 return SLJIT_SUCCESS;
2327 SLJIT_API_FUNC_ATTRIBUTE struct sljit_label * sljit_emit_label(struct sljit_compiler *compiler)
2329 struct sljit_label *label;
2331 flush_buffer(compiler);
2334 check_sljit_emit_label(compiler);
2336 if (compiler->last_label && compiler->last_label->size == compiler->size)
2337 return compiler->last_label;
2339 label = (struct sljit_label *)ensure_abuf(compiler, sizeof(struct sljit_label));
2340 PTR_FAIL_IF(!label);
2341 set_label(label, compiler);
2345 SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_ijump(struct sljit_compiler *compiler, sljit_si type, sljit_si src, sljit_sw srcw)
2347 sljit_si src_r = TMP_REG2;
2348 struct sljit_jump *jump = NULL;
2350 flush_buffer(compiler);
2353 check_sljit_emit_ijump(compiler, type, src, srcw);
2354 ADJUST_LOCAL_OFFSET(src, srcw);
2356 if (FAST_IS_REG(src)) {
2357 if (reg_map[src] != 0)
2360 FAIL_IF(ADD_SOLO(TMP_REG2_mapped, reg_map[src], ZERO));
2363 if (type >= SLJIT_CALL0) {
2364 SLJIT_ASSERT(reg_map[PIC_ADDR_REG] == 16 && PIC_ADDR_REG == TMP_REG2);
2365 if (src & (SLJIT_IMM | SLJIT_MEM)) {
2366 if (src & SLJIT_IMM)
2367 FAIL_IF(emit_const(compiler, reg_map[PIC_ADDR_REG], srcw, 1));
2369 SLJIT_ASSERT(src_r == TMP_REG2 && (src & SLJIT_MEM));
2370 FAIL_IF(emit_op(compiler, SLJIT_MOV, WORD_DATA, TMP_REG2, 0, TMP_REG1, 0, src, srcw));
2373 FAIL_IF(ADD_SOLO(0, reg_map[SLJIT_SCRATCH_REG1], ZERO));
2375 FAIL_IF(ADDI_SOLO(54, 54, -16));
2377 FAIL_IF(JALR_SOLO(reg_map[PIC_ADDR_REG]));
2379 return ADDI_SOLO(54, 54, 16);
2382 /* Register input. */
2383 if (type >= SLJIT_CALL1)
2384 FAIL_IF(ADD_SOLO(0, reg_map[SLJIT_SCRATCH_REG1], ZERO));
2386 FAIL_IF(ADD_SOLO(reg_map[PIC_ADDR_REG], reg_map[src_r], ZERO));
2388 FAIL_IF(ADDI_SOLO(54, 54, -16));
2390 FAIL_IF(JALR_SOLO(reg_map[src_r]));
2392 return ADDI_SOLO(54, 54, 16);
2395 if (src & SLJIT_IMM) {
2396 jump = (struct sljit_jump *)ensure_abuf(compiler, sizeof(struct sljit_jump));
2398 set_jump(jump, compiler, JUMP_ADDR | ((type >= SLJIT_FAST_CALL) ? IS_JAL : 0));
2399 jump->u.target = srcw;
2400 FAIL_IF(emit_const(compiler, TMP_REG2_mapped, 0, 1));
2402 if (type >= SLJIT_FAST_CALL) {
2403 FAIL_IF(ADD_SOLO(ZERO, ZERO, ZERO));
2404 jump->addr = compiler->size;
2405 FAIL_IF(JR_SOLO(reg_map[src_r]));
2407 jump->addr = compiler->size;
2408 FAIL_IF(JR_SOLO(reg_map[src_r]));
2411 return SLJIT_SUCCESS;
2413 } else if (src & SLJIT_MEM)
2414 FAIL_IF(emit_op(compiler, SLJIT_MOV, WORD_DATA, TMP_REG2, 0, TMP_REG1, 0, src, srcw));
2416 FAIL_IF(JR_SOLO(reg_map[src_r]));
2419 jump->addr = compiler->size;
2421 return SLJIT_SUCCESS;
2425 inst = BEQZ_X1 | SRCA_X1(src); \
2428 #define BR_NZ(src) \
2429 inst = BNEZ_X1 | SRCA_X1(src); \
2432 SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump * sljit_emit_jump(struct sljit_compiler *compiler, sljit_si type)
2434 struct sljit_jump *jump;
2438 flush_buffer(compiler);
2441 check_sljit_emit_jump(compiler, type);
2443 jump = (struct sljit_jump *)ensure_abuf(compiler, sizeof(struct sljit_jump));
2445 set_jump(jump, compiler, type & SLJIT_REWRITABLE_JUMP);
2450 case SLJIT_C_FLOAT_NOT_EQUAL:
2453 case SLJIT_C_NOT_EQUAL:
2454 case SLJIT_C_FLOAT_EQUAL:
2458 case SLJIT_C_FLOAT_LESS:
2461 case SLJIT_C_GREATER_EQUAL:
2462 case SLJIT_C_FLOAT_GREATER_EQUAL:
2465 case SLJIT_C_GREATER:
2466 case SLJIT_C_FLOAT_GREATER:
2467 BR_Z(UGREATER_FLAG);
2469 case SLJIT_C_LESS_EQUAL:
2470 case SLJIT_C_FLOAT_LESS_EQUAL:
2471 BR_NZ(UGREATER_FLAG);
2473 case SLJIT_C_SIG_LESS:
2476 case SLJIT_C_SIG_GREATER_EQUAL:
2479 case SLJIT_C_SIG_GREATER:
2482 case SLJIT_C_SIG_LESS_EQUAL:
2483 BR_NZ(GREATER_FLAG);
2485 case SLJIT_C_OVERFLOW:
2486 case SLJIT_C_MUL_OVERFLOW:
2487 BR_Z(OVERFLOW_FLAG);
2489 case SLJIT_C_NOT_OVERFLOW:
2490 case SLJIT_C_MUL_NOT_OVERFLOW:
2491 BR_NZ(OVERFLOW_FLAG);
2494 /* Not conditional branch. */
2499 jump->flags |= flags;
2502 inst = inst | ((type <= SLJIT_JUMP) ? BOFF_X1(5) : BOFF_X1(6));
2503 PTR_FAIL_IF(PI(inst));
2506 PTR_FAIL_IF(emit_const(compiler, TMP_REG2_mapped, 0, 1));
2507 if (type <= SLJIT_JUMP) {
2508 jump->addr = compiler->size;
2509 PTR_FAIL_IF(JR_SOLO(TMP_REG2_mapped));
2511 SLJIT_ASSERT(reg_map[PIC_ADDR_REG] == 16 && PIC_ADDR_REG == TMP_REG2);
2512 /* Cannot be optimized out if type is >= CALL0. */
2513 jump->flags |= IS_JAL | (type >= SLJIT_CALL0 ? SLJIT_REWRITABLE_JUMP : 0);
2514 PTR_FAIL_IF(ADD_SOLO(0, reg_map[SLJIT_SCRATCH_REG1], ZERO));
2515 jump->addr = compiler->size;
2516 PTR_FAIL_IF(JALR_SOLO(TMP_REG2_mapped));
2522 SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_is_fpu_available(void)
2527 SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_fop1(struct sljit_compiler *compiler, sljit_si op, sljit_si dst, sljit_sw dstw, sljit_si src, sljit_sw srcw)
2529 SLJIT_ASSERT_STOP();
2532 SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_fop2(struct sljit_compiler *compiler, sljit_si op, sljit_si dst, sljit_sw dstw, sljit_si src1, sljit_sw src1w, sljit_si src2, sljit_sw src2w)
2534 SLJIT_ASSERT_STOP();
2537 SLJIT_API_FUNC_ATTRIBUTE struct sljit_const * sljit_emit_const(struct sljit_compiler *compiler, sljit_si dst, sljit_sw dstw, sljit_sw init_value)
2539 struct sljit_const *const_;
2542 flush_buffer(compiler);
2545 check_sljit_emit_const(compiler, dst, dstw, init_value);
2546 ADJUST_LOCAL_OFFSET(dst, dstw);
2548 const_ = (struct sljit_const *)ensure_abuf(compiler, sizeof(struct sljit_const));
2549 PTR_FAIL_IF(!const_);
2550 set_const(const_, compiler);
2552 reg = FAST_IS_REG(dst) ? dst : TMP_REG2;
2554 PTR_FAIL_IF(emit_const_64(compiler, reg, init_value, 1));
2556 if (dst & SLJIT_MEM)
2557 PTR_FAIL_IF(emit_op(compiler, SLJIT_MOV, WORD_DATA, dst, dstw, TMP_REG1, 0, TMP_REG2, 0));
2561 SLJIT_API_FUNC_ATTRIBUTE void sljit_set_jump_addr(sljit_uw addr, sljit_uw new_addr)
2563 sljit_ins *inst = (sljit_ins *)addr;
2565 inst[0] = (inst[0] & ~(0xFFFFL << 43)) | (((new_addr >> 32) & 0xffff) << 43);
2566 inst[1] = (inst[1] & ~(0xFFFFL << 43)) | (((new_addr >> 16) & 0xffff) << 43);
2567 inst[2] = (inst[2] & ~(0xFFFFL << 43)) | ((new_addr & 0xffff) << 43);
2568 SLJIT_CACHE_FLUSH(inst, inst + 3);
2571 SLJIT_API_FUNC_ATTRIBUTE void sljit_set_const(sljit_uw addr, sljit_sw new_constant)
2573 sljit_ins *inst = (sljit_ins *)addr;
2575 inst[0] = (inst[0] & ~(0xFFFFL << 43)) | (((new_constant >> 48) & 0xFFFFL) << 43);
2576 inst[1] = (inst[1] & ~(0xFFFFL << 43)) | (((new_constant >> 32) & 0xFFFFL) << 43);
2577 inst[2] = (inst[2] & ~(0xFFFFL << 43)) | (((new_constant >> 16) & 0xFFFFL) << 43);
2578 inst[3] = (inst[3] & ~(0xFFFFL << 43)) | ((new_constant & 0xFFFFL) << 43);
2579 SLJIT_CACHE_FLUSH(inst, inst + 4);