2 * Copyright (C) 2013-2023 Free Software Foundation, Inc.
4 * This file is part of GNU lightning.
6 * GNU lightning is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU Lesser General Public License as published
8 * by the Free Software Foundation; either version 3, or (at your option)
11 * GNU lightning is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
13 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
14 * License for more details.
17 * Paulo Cesar Pereira de Andrade
21 # define _G2_REGNO 0x02
22 # define _G3_REGNO 0x03
23 # define _G4_REGNO 0x04
24 # define _O0_REGNO 0x08
25 # define _O1_REGNO 0x09
26 # define _SP_REGNO 0x0e
27 # define _FP_REGNO 0x1e
28 # define _O7_REGNO 0x0f
29 # define _L0_REGNO 0x10
30 # define _L1_REGNO 0x11
31 # define _L2_REGNO 0x12
32 # define _L3_REGNO 0x13
33 # define _L4_REGNO 0x14
34 # define _L5_REGNO 0x15
35 # define _L6_REGNO 0x16
36 # define _L7_REGNO 0x17
37 # define _I7_REGNO 0x1f
39 * - previous stack frame
41 * fp- local variables (in lightning, 8 bytes space for float conversion)
44 * sp+ 6 words to save register arguments
45 * sp+ 1 word for hidden address of aggregate return value (32 bits only)
46 * sp+ 16 words for in and local registers
48 * decreasing memory address - next stack frame (not yet allocated)
50 # define stack_framesize ((16 + (__WORDSIZE == 32) + 6) * sizeof(jit_word_t))
52 struct { jit_uint32_t b: 2; } op;
53 struct { jit_uint32_t _: 2; jit_uint32_t b: 1; } a;
54 struct { jit_uint32_t _: 2; jit_uint32_t b: 5; } rd;
55 struct { jit_uint32_t _: 2; jit_uint32_t b: 30; } disp30;
56 struct { jit_uint32_t _: 3; jit_uint32_t b: 4; } cond;
57 struct { jit_uint32_t _: 7; jit_uint32_t b: 3; } op2;
58 struct { jit_uint32_t _: 7; jit_uint32_t b: 6; } op3;
59 struct { jit_uint32_t _: 10; jit_uint32_t b: 1; } cc1;
60 struct { jit_uint32_t _: 10; jit_uint32_t b: 22; } imm22;
61 struct { jit_uint32_t _: 10; jit_uint32_t b: 22; } disp22;
62 struct { jit_uint32_t _: 11; jit_uint32_t b: 1; } cc0;
63 struct { jit_uint32_t _: 12; jit_uint32_t b: 1; } p;
64 struct { jit_uint32_t _: 13; jit_uint32_t b: 19; } disp19;
65 struct { jit_uint32_t _: 13; jit_uint32_t b: 5; } rs1;
66 struct { jit_uint32_t _: 18; jit_uint32_t b: 1; } i;
67 struct { jit_uint32_t _: 18; jit_uint32_t b: 9; } opf;
68 struct { jit_uint32_t _: 19; jit_uint32_t b: 1; } x;
69 struct { jit_uint32_t _: 19; jit_uint32_t b: 8; } asi;
70 struct { jit_uint32_t _: 19; jit_uint32_t b: 6; } res;
71 struct { jit_uint32_t _: 19; jit_uint32_t b: 13; } simm13;
72 struct { jit_uint32_t _: 20; jit_uint32_t b: 7; } asix;
73 struct { jit_uint32_t _: 20; jit_uint32_t b: 6; } asis;
74 struct { jit_uint32_t _: 26; jit_uint32_t b: 6; } shim;
75 struct { jit_uint32_t _: 25; jit_uint32_t b: 7; } imm7;
76 struct { jit_uint32_t _: 27; jit_uint32_t b: 5; } rs2;
79 # define ii(i) *_jit->pc.ui++ = i
80 # define s7_p(imm) ((imm) <= 63 && (imm) >= -64)
81 # define s13_p(imm) ((imm) <= 4095 && (imm) >= -4096)
82 # define s19_p(imm) ((imm) <= 262143 && (imm) >= -262144)
83 # define s22_p(imm) ((imm) <= 2097151 && (imm) >= -20971512)
84 # define s30_p(imm) ((imm) <= 536870911 && (imm) >= -536870912)
85 # define f1(op, disp30) _f1(_jit, op, disp30)
86 static void _f1(jit_state_t*,jit_int32_t,jit_int32_t);
87 # define f2r(op, rd, op2, imm22) _f2r(_jit, op, rd, op2, imm22)
88 static void _f2r(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
89 # define f2b(op, a, cond, op2, disp22) _f2b(_jit, op, a, cond, op2, disp22)
91 _f2b(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
93 # define f2bp(op,a,cond,op2,cc1,cc0,p,disp19) \
94 _f2bp(_jit,op,a,cond,op2,cc1,cc0,p,disp19)
96 _f2bp(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
97 jit_int32_t,jit_int32_t,jit_int32_t);
99 # define f3r(op, rd, op3, rs1, rs2) _f3r(_jit, op, rd, op3, rs1, rs2)
100 static void _f3r(jit_state_t*,
101 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
102 # if __WORDSIZE == 64
103 # define f3ri(op, rd, op3, rs1, rs2) _f3ri(_jit, op, rd, op3, rs1, rs2)
104 static void _f3ri(jit_state_t*,
105 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
106 # define f3rx(op, rd, op3, rs1, rs2) _f3rx(_jit, op, rd, op3, rs1, rs2)
107 static void _f3rx(jit_state_t*,
108 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
110 # define f3i(op, rd, op3, rs1, simm13) _f3i(_jit, op, rd, op3, rs1, simm13)
111 static void _f3i(jit_state_t*,
112 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
113 # define f3s(op, rd, op3, rs1, simm13) _f3s(_jit, op, rd, op3, rs1, simm13)
114 static void _f3s(jit_state_t*,
115 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
116 # define f3t(cond, rs1, i, ri) _f3t(_jit, cond, rs1, i, ri)
117 static void _f3t(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t)
119 # define f3a(op,rd,op3,rs1,asi,rs2) _f3a(_jit, op, rd, op3, rs1, asi, rs2)
120 static void _f3a(jit_state_t*,jit_int32_t,
121 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t)
123 # define f2c1(op,rd,op3,rs1,opf,rs2) _f2c1(_jit,op,rd,op3,rs1,opf,rs2)
125 _f2c1(jit_state_t*,jit_int32_t, jit_int32_t,
126 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t)
128 # define LDSB(rs1, rs2, rd) f3r(3, rd, 9, rs1, rs2)
129 # define LDSBI(rs1, imm, rd) f3i(3, rd, 9, rs1, imm)
130 # define LDSH(rs1, rs2, rd) f3r(3, rd, 10, rs1, rs2)
131 # define LDSHI(rs1, imm, rd) f3i(3, rd, 10, rs1, imm)
132 # define LDUB(rs1, rs2, rd) f3r(3, rd, 1, rs1, rs2)
133 # define LDUBI(rs1, imm, rd) f3i(3, rd, 1, rs1, imm)
134 # define LDUH(rs1, rs2, rd) f3r(3, rd, 2, rs1, rs2)
135 # define LDUHI(rs1, imm, rd) f3i(3, rd, 2, rs1, imm)
136 # if __WORDSIZE == 32
137 # define LD(rs1, rs2, rd) f3r(3, rd, 0, rs1, rs2)
138 # define LDI(rs1, imm, rd) f3i(3, rd, 0, rs1, imm)
139 # define LDD(rs1, rs2, rd) f3r(3, rd, 3, rs1, rs2)
140 # define LDDI(rs1, imm, rd) f3i(3, rd, 3, rs1, imm)
142 # define LDSW(rs1, rs2, rd) f3r(3, rd, 8, rs1, rs2)
143 # define LDSWI(rs1, imm, rd) f3i(3, rd, 8, rs1, imm)
144 # define LDUW(rs1, rs2, rd) f3r(3, rd, 0, rs1, rs2)
145 # define LDUWI(rs1, imm, rd) f3i(3, rd, 0, rs1, imm)
146 # define LDX(rs1, rs2, rd) f3r(3, rd, 11, rs1, rs2)
147 # define LDXI(rs1, imm, rd) f3i(3, rd, 11, rs1, imm)
149 # define LDSBA(rs1, rs2, asi, rd) f3a(3, rd, 25, rs1, asi, rs2)
150 # define LDSHA(rs1, rs2, asi, rd) f3a(3, rd, 26, rs1, asi, rs2)
151 # define LDUBA(rs1, rs2, asi, rd) f3a(3, rd, 17, rs1, asi, rs2)
152 # define LDUHA(rs1, rs2, asi, rd) f3a(3, rd, 18, rs1, asi, rs2)
153 # if __WORDSIZE == 32
154 # define LDA(rs1, rs2, asi, rd) f3a(3, rd, 16, rs1, asi, rs2)
155 # define LDDA(rs1, rs2, asi, rd) f3a(3, rd, 19, rs1, asi, rs2)
157 # define LDSWA(rs1, rs2, asi, rd) f3a(3, rd, 24, rs1, asi, rs2)
158 # define LDUWA(rs1, rs2, asi, rd) f3a(3, rd, 16, rs1, asi, rs2)
159 # define LDXA(rs1, rs2, asi, rd) f3a(3, rd, 27, rs1, asi, rs2)
161 # define LDC(rs1, rs2, rd) f3r(3, rd, 48, rs1, rs2)
162 # define LDCI(rs1, imm, rd) f3i(3, rd, 48, rs1, imm)
163 # define LDDC(rs1, rs2, rd) f3r(3, rd, 51, rs1, rs2)
164 # define LDDCI(rs1, imm, rd) f3i(3, rd, 51, rs1, imm)
165 # define LDCSR(rs1, rs2, rd) f3r(3, rd, 49, rs1, rs2)
166 # define LDCSRI(rs1, imm, rd) f3i(3, rd, 49, rs1, imm)
167 # define STB(rd, rs1, rs2) f3r(3, rd, 5, rs1, rs2)
168 # define STBI(rd, rs1, imm) f3i(3, rd, 5, rs1, imm)
169 # define STH(rd, rs1, rs2) f3r(3, rd, 6, rs1, rs2)
170 # define STHI(rd, rs1, imm) f3i(3, rd, 6, rs1, imm)
171 # if __WORDSIZE == 32
172 # define ST(rd, rs1, rs2) f3r(3, rd, 4, rs1, rs2)
173 # define STI(rd, rs1, imm) f3i(3, rd, 4, rs1, imm)
174 # define STD(rrd, s1, rs2) f3r(3, rd, 7, rs1, rs2)
175 # define STDI(rd, rs1, imm) f3i(3, rd, 7, rs1, imm)
177 # define STW(rd, rs1, rs2) f3r(3, rd, 4, rs1, rs2)
178 # define STWI(rd, rs1, imm) f3i(3, rd, 4, rs1, imm)
179 # define STX(rd, rs1, rs2) f3r(3, rd, 14, rs1, rs2)
180 # define STXI(rd, rs1, imm) f3i(3, rd, 14, rs1, imm)
182 # define STBA(rd, rs1, rs2) f3a(3, rd, 21, rs1, asi, rs2)
183 # define STHA(rd, rs1, rs2) f3a(3, rd, 22, rs1, asi, rs2)
184 # if __WORDSIZE == 32
185 # define STA(rd, rs1, rs2) f3a(3, rd, 20, rs1, asi, rs2)
186 # define STDA(rd, rs1, rs2) f3a(3, rd, 23, rs1, asi, rs2)
188 # define STWA(rd, rs1, rs2) f3a(3, rd, 20, rs1, asi, rs2)
189 # define STXA(rd, rs1, rs2) f3a(3, rd, 30, rs1, asi, rs2)
191 # define STC(rd, rs1, rs2) f3r(3, rd, 52, rs1, rs2)
192 # define STCI(rd, rs1, imm) f3i(3, rd, 52, rs1, imm)
193 # define STDC(rd, rs1, rs2) f3r(3, rd, 55, rs1, rs2)
194 # define STDCI(rd, rs1, imm) f3i(3, rd, 55, rs1, imm)
195 # define STCSR(rd, rs1, rs2) f3r(3, rd, 53, rs1, rs2)
196 # define STCSRI(rd, rs1, imm) f3i(3, rd, 53, rs1, imm)
197 # define STDCQ(rd, rs1, rs2) f3r(3, rd, 54, rs1, rs2)
198 # define STDCQI(rd, rs1, imm) f3i(3, rd, 54, rs1, imm)
199 # define LDSTUB(rs1, rs2, rd) f3r(3, rd, 13, rs1, rs2)
200 # define LDSTUBI(rs1, imm, rd) f3r(3, rd, 13, rs1, imm)
201 # define LDSTUBA(rs1, rs2, asi, rd) f3a(3, rd, 21, rs1, asi, rs2)
202 # define SWAP(rs1, rs2, rd) f3r(3, rd, 15, rs1, rs2)
203 # define SWAPI(rs1, imm, rd) f3r(3, rd, 15, rs1, imm)
204 # define SWAPA(rs1, rs2, asi, rd) f3a(3, rd, 23, rs1, asi, rs2)
205 /* Sparc v9 deprecates SWAP* in favor of CAS*A */
206 # define CASA(rs1, rs2, rd) f3a(3, rd, 60, rs1, 128, rs2)
207 # if __WORDSIZE == 64
208 # define CASXA(rs1, rs2, rd) f3a(3, rd, 62, rs1, 128, rs2)
210 # define NOP() SETHI(0, 0)
211 # define HI(im) ((im) >> 10)
212 # define LO(im) ((im) & 0x3ff)
213 # define SETHI(im, rd) f2r(0, rd, 4, im)
214 # define AND(rs1, rs2, rd) f3r(2, rd, 1, rs1, rs2)
215 # define ANDI(rs1, imm, rd) f3i(2, rd, 1, rs1, imm)
216 # define ANDcc(rs1, rs2, rd) f3r(2, rd, 17, rs1, rs2)
217 # define ANDIcc(rs1, imm, rd) f3i(2, rd, 17, rs1, imm)
218 # define BTST(rs1, rs2) ANDcc(rs1, rs2, 0)
219 # define BTSTI(rs1, imm) ANDIcc(rs1, imm, 0)
220 # define ANDN(rs1, rs2, rd) f3r(2, rd, 5, rs1, rs2)
221 # define ANDNI(rs1, imm, rd) f3i(2, rd, 5, rs1, imm)
222 # define ANDNcc(rs1, rs2, rd) f3r(2, rd, 21, rs1, rs2)
223 # define ANDNIcc(rs1, imm, rd) f3i(2, rd, 21, rs1, imm)
224 # define OR(rs1, rs2, rd) f3r(2, rd, 2, rs1, rs2)
225 # define ORI(rs1, imm, rd) f3i(2, rd, 2, rs1, imm)
226 # define ORcc(rs1, rs2, rd) f3r(2, rd, 18, rs1, rs2)
227 # define ORIcc(rs1, imm, rd) f3i(2, rd, 18, rs1, imm)
228 # define ORN(rs1, rs2, rd) f3r(2, rd, 6, rs1, rs2)
229 # define ORNI(rs1, imm, rd) f3i(2, rd, 6, rs1, imm)
230 # define ORNcc(rs1, rs2, rd) f3r(2, rd, 22, rs1, rs2)
231 # define ORNIcc(rs1, imm, rd) f3i(2, rd, 22, rs1, imm)
232 # define XOR(rs1, rs2, rd) f3r(2, rd, 3, rs1, rs2)
233 # define XORI(rs1, imm, rd) f3i(2, rd, 3, rs1, imm)
234 # define XORcc(rs1, rs2, rd) f3r(2, rd, 19, rs1, rs2)
235 # define XORIcc(rs1, imm, rd) f3i(2, rd, 19, rs1, imm)
236 # define XNOR(rs1, rs2, rd) f3r(2, rd, 7, rs1, rs2)
237 # define XNORI(rs1, imm, rd) f3i(2, rd, 7, rs1, imm)
238 # define XNORcc(rs1, rs2, rd) f3r(2, rd, 23, rs1, rs2)
239 # define XNORIcc(rs1, imm, rd) f3i(2, rd, 23, rs1, imm)
240 # define SLL(rs1, rs2, rd) f3r(2, rd, 37, rs1, rs2)
241 # define SLLI(rs1, imm, rd) f3i(2, rd, 37, rs1, imm)
242 # define SRL(rs1, rs2, rd) f3r(2, rd, 38, rs1, rs2)
243 # define SRLI(rs1, imm, rd) f3i(2, rd, 38, rs1, imm)
244 # define SRA(rs1, rs2, rd) f3r(2, rd, 39, rs1, rs2)
245 # define SRAI(rs1, imm, rd) f3i(2, rd, 39, rs1, imm)
246 # if __WORDSIZE == 64
247 # define SLLX(rs1, rs2, rd) f3rx(2, rd, 37, rs1, rs2)
248 # define SLLXI(rs1, imm, rd) f3s(2, rd, 37, rs1, imm)
249 # define SRLX(rs1, rs2, rd) f3rx(2, rd, 38, rs1, rs2)
250 # define SRLXI(rs1, imm, rd) f3s(2, rd, 38, rs1, imm)
251 # define SRAX(rs1, rs2, rd) f3rx(2, rd, 39, rs1, rs2)
252 # define SRAXI(rs1, imm, rd) f3s(2, rd, 39, rs1, imm)
254 # define ADD(rs1, rs2, rd) f3r(2, rd, 0, rs1, rs2)
255 # define ADDI(rs1, imm, rd) f3i(2, rd, 0, rs1, imm)
256 # define ADDcc(rs1, rs2, rd) f3r(2, rd, 16, rs1, rs2)
257 # define ADDIcc(rs1, imm, rd) f3i(2, rd, 16, rs1, imm)
258 # define ADDX(rs1, rs2, rd) f3r(2, rd, 8, rs1, rs2)
259 # define ADDXI(rs1, imm, rd) f3i(2, rd, 8, rs1, imm)
260 # define ADDXcc(rs1, rs2, rd) f3r(2, rd, 24, rs1, rs2)
261 # define ADDXIcc(rs1, imm, rd) f3i(2, rd, 24, rs1, imm)
262 # define TADDcc(rs1, rs2, rd) f3r(2, rd, 32, rs1, rs2)
263 # define TADDIcc(rs1, imm, rd) f3i(2, rd, 32, rs1, imm)
264 # define TADDccTV(rs1, rs2, rd) f3r(2, rd, 34, rs1, rs2)
265 # define TADDIccTV(rs1, imm, rd) f3i(2, rd, 34, rs1, imm)
266 # define SUB(rs1, rs2, rd) f3r(2, rd, 4, rs1, rs2)
267 # define NEG(rs1, rd) SUB(0, rs1, rd)
268 # define SUBI(rs1, imm, rd) f3i(2, rd, 4, rs1, imm)
269 # define SUBcc(rs1, rs2, rd) f3r(2, rd, 20, rs1, rs2)
270 # define SUBIcc(rs1, imm, rd) f3i(2, rd, 20, rs1, imm)
271 # define CMP(rs1, rs2) SUBcc(rs1, rs2, 0)
272 # define CMPI(rs1, imm) SUBIcc(rs1, imm, 0)
273 # define SUBX(rs1, rs2, rd) f3r(2, rd, 12, rs1, rs2)
274 # define SUBXI(rs1, imm, rd) f3i(2, rd, 12, rs1, imm)
275 # define SUBXcc(rs1, rs2, rd) f3r(2, rd, 28, rs1, rs2)
276 # define SUBXIcc(rs1, imm, rd) f3i(2, rd, 28, rs1, imm)
277 # define TSUBcc(rs1, rs2, rd) f3r(2, rd, 33, rs1, rs2)
278 # define TDADDIcc(rs1, imm, rd) f3i(2, rd, 33, rs1, imm)
279 # define TSUBccTV(rs1, rs2, rd) f3r(2, rd, 35, rs1, rs2)
280 # define TSUBIccTV(rs1, imm, rd) f3i(2, rd, 35, rs1, imm)
281 # define MULScc(rs1, rs2, rd) f3r(2, rd, 36, rs1, rs2)
282 # define MULSIcc(rs1, imm, rd) f3i(2, rd, 36, rs1, imm)
283 # define UMUL(rs1, rs2, rd) f3r(2, rd, 10, rs1, rs2)
284 # define UMULI(rs1, imm, rd) f3i(2, rd, 10, rs1, imm)
285 # define SMUL(rs1, rs2, rd) f3r(2, rd, 11, rs1, rs2)
286 # define SMULI(rs1, imm, rd) f3i(2, rd, 11, rs1, imm)
287 # define UMULcc(rs1, rs2, rd) f3r(2, rd, 26, rs1, rs2)
288 # define UMULIcc(rs1, imm, rd) f3i(2, rd, 26, rs1, imm)
289 # define SMULcc(rs1, rs2, rd) f3r(2, rd, 27, rs1, rs2)
290 # define SMULIcc(rs1, imm, rd) f3i(2, rd, 27, rs1, imm)
291 # define UDIV(rs1, rs2, rd) f3r(2, rd, 14, rs1, rs2)
292 # define UDIVI(rs1, imm, rd) f3i(2, rd, 14, rs1, imm)
293 # define SDIV(rs1, rs2, rd) f3r(2, rd, 15, rs1, rs2)
294 # define SDIVI(rs1, imm, rd) f3i(2, rd, 15, rs1, imm)
295 # define UDIVcc(rs1, rs2, rd) f3r(2, rd, 30, rs1, rs2)
296 # define UDIVIcc(rs1, imm, rd) f3i(2, rd, 30, rs1, imm)
297 # define SDIVcc(rs1, rs2, rd) f3r(2, rd, 31, rs1, rs2)
298 # define SDIVIcc(rs1, imm, rd) f3i(2, rd, 31, rs1, imm)
299 # if __WORDSIZE == 64
300 # define MULX(rs1, rs2, rd) f3r(2, rd, 9, rs1, rs2)
301 # define MULXI(rs1, imm, rd) f3i(2, rd, 9, rs1, imm)
302 # define SDIVX(rs1, rs2, rd) f3r(2, rd, 45, rs1, rs2)
303 # define SDIVXI(rs1, imm, rd) f3i(2, rd, 45, rs1, imm)
304 # define UDIVX(rs1, rs2, rd) f3r(2, rd, 13, rs1, rs2)
305 # define UDIVXI(rs1, imm, rd) f3i(2, rd, 13, rs1, imm)
307 # define SAVE(rs1, rs2, rd) f3r(2, rd, 60, rs1, rs2)
308 # define SAVEI(rs1, imm, rd) f3i(2, rd, 60, rs1, imm)
309 # define RESTORE(rs1, rs2, rd) f3r(2, rd, 61, rs1, rs2)
310 # define RESTOREI(rs1, imm, rd) f3i(2, rd, 61, rs1, imm)
311 # define SPARC_BA 8 /* always */
312 # define SPARC_BN 0 /* never */
313 # define SPARC_BNE 9 /* not equal - not Z */
314 # define SPARC_BNZ SPARC_BNE
315 # define SPARC_BE 1 /* equal - Z */
316 # define SPARC_BZ SPARC_BE
317 # define SPARC_BG 10 /* greater - not (Z or (N xor V)) */
318 # define SPARC_BLE 2 /* less or equal - Z or (N xor V) */
319 # define SPARC_BGE 11 /* greater or equal - not (N xor V) */
320 # define SPARC_BL 3 /* less - N xor V */
321 # define SPARC_BGU 12 /* greater unsigned - not (C or Z) */
322 # define SPARC_BLEU 4 /* less or equal unsigned - C or Z */
323 # define SPARC_BCC 13 /* carry clear - not C */
324 # define SPARC_BGEU SPARC_BCC
325 # define SPARC_BCS 5 /* carry set - C */
326 # define SPARC_BLU SPARC_BCS
327 # define SPARC_BPOS 14 /* positive - not N */
328 # define SPARC_BNEG 6 /* negative - N */
329 # define SPARC_BVC 15 /* overflow clear - not V */
330 # define SPARC_BVS 7 /* overflow set - V */
331 /* Preferred BPcc integer branch opcodes */
332 # if __WORDSIZE == 64
333 # define SPARC_BPA 8 /* always - 1 */
334 # define SPARC_BPN 0 /* never - 0 */
335 # define SPARC_BPNE 9 /* not equal - not Z */
336 # define SPARC_BPE 1 /* equal - Z */
337 # define SPARC_BPG 10 /* greater - not (Z or (N xor V)) */
338 # define SPARC_BPLE 2 /* less or equal - Z or (N xor V) */
339 # define SPARC_BPGE 11 /* greater or equal - not (N xor V) */
340 # define SPARC_BPL 3 /* less - N xor V */
341 # define SPARC_BPGU 12 /* greater unsigned - not (C or V) */
342 # define SPARC_BPLEU 4 /* less or equal unsigned - C or Z */
343 # define SPARC_BPCC 13 /* carry clear (greater than or equal, unsigned) - not C */
344 # define SPARC_BPCS 5 /* carry set (less than, unsigned) - C */
345 # define SPARC_BPPOS 14 /* positive - not N */
346 # define SPARC_BPNEG 6 /* negative - N */
347 # define SPARC_BPVC 15 /* overflow clear - not V */
348 # define SPARC_BPVS 7 /* overflow set - V */
350 # define B(cc, imm) f2b(0, 0, cc, 2, imm)
351 # define Ba(cc, imm) f2b(0, 1, cc, 2, imm)
352 # define BA(imm) B(SPARC_BA, imm)
353 # define BAa(imm) Ba(SPARC_BA, imm)
354 # define BN(imm) B(SPARC_BN, imm)
355 # define BNa(imm) Ba(SPARC_BN, imm)
356 # define BNE(imm) B(SPARC_BNE, imm)
357 # define BNEa(imm) Ba(SPARC_BNE, imm)
358 # define BNZ(imm) BNE(imm)
359 # define BNZa(imm) BNEa(imm)
360 # define BE(imm) B(SPARC_BE, imm)
361 # define BEa(imm) Ba(SPARC_BE, imm)
362 # define BZ(imm) BE(imm)
363 # define BZa(imm) BEa(imm)
364 # define BG(imm) B(SPARC_BG, imm)
365 # define BGa(imm) Ba(SPARC_BG, imm)
366 # define BLE(imm) B(SPARC_BLE, imm)
367 # define BLEa(imm) Ba(SPARC_BLE, imm)
368 # define BGE(imm) B(SPARC_BGE, imm)
369 # define BGEa(imm) Ba(SPARC_BGE, imm)
370 # define BL(imm) B(SPARC_BL, imm)
371 # define BLa(imm) Ba(SPARC_BL, imm)
372 # define BGU(imm) B(SPARC_BGU, imm)
373 # define BGUa(imm) Ba(SPARC_BGU, imm)
374 # define BLEU(imm) B(SPARC_BLEU, imm)
375 # define BLEUa(imm) Ba(SPARC_BLEU, imm)
376 # define BCC(imm) B(SPARC_BCC, imm)
377 # define BCCa(imm) Ba(SPARC_BCC, imm)
378 # define BGEU(imm) BCC(imm)
379 # define BGEUa(imm) BCCa(imm)
380 # define BCS(imm) B(SPARC_BCS, imm)
381 # define BCSa(imm) Ba(SPARC_BCS, imm)
382 # define BLU(imm) BCS(imm)
383 # define BLUa(imm) BCSa(imm)
384 # define BPOS(imm) B(SPARC_BPOS, imm)
385 # define BPOSa(imm) Ba(SPARC_BPOS, imm)
386 # define BNEG(imm) B(SPARC_BNEG, imm)
387 # define BNEGa(imm) Ba(SPARC_BNEG, imm)
388 # define BVC(imm) B(SPARC_BVC, imm)
389 # define BVCa(imm) Ba(SPARC_BVC, imm)
390 # define BVS(imm) B(SPARC_BVS, imm)
391 # define BVSa(imm) Ba(SPARC_BVS, imm)
392 # if __WORDSIZE == 64
393 # define BPccap(cc,a,cc1, cc2,p,imm) f2bp(0, a, cc, 1, cc1, cc0, p, imm)
394 # define BPap(cc, imm) f2bp(0, 1, cc, 1, 1, 0, p, imm)
395 # define BPa(cc, imm) f2bp(0, 1, cc, 1, 1, 0, 1, imm)
396 # define BP(cc, imm) f2bp(0, 0, cc, 1, 1, 0, 1, imm)
397 # define BPA(imm) BP(SPARC_BPA, imm)
398 # define BPN(imm) BP(SPARC_BPN, imm)
399 # define BNPE(imm) BP(SPARC_BPNE, imm)
400 # define BPE(imm) BP(SPARC_BPE, imm)
401 # define BPG(imm) BP(SPARC_BPG, imm)
402 # define BPLE(imm) BP(SPARC_BPLE, imm)
403 # define BPGE(imm) BP(SPARC_BPGE, imm)
404 # define BPL(imm) BP(SPARC_BPL, imm)
405 # define BPGU(imm) BP(SPARC_BPGU, imm)
406 # define BPLEU(imm) BP(SPARC_BPLEU, imm)
407 # define BPCC(imm) BP(SPARC_BPCC, imm)
408 # define BPCS(imm) BP(SPARC_BPCS, imm)
409 # define BPPOS(imm) BP(SPARC_BPPOS, imm)
410 # define BPNEG(imm) BP(SPARC_BPNEG, imm)
411 # define BPVC(imm) BP(SPARC_BPVC, imm)
412 # define BPVS(imm) BP(SPARC_BPVS, imm)
414 # define SPARC_CBA 8 /* always */
415 # define SPARC_CBN 0 /* never */
416 # define SPARC_CB3 7 /* 3 */
417 # define SPARC_CB2 6 /* 2 */
418 # define SPARC_CB23 5 /* 2 or 3 */
419 # define SPARC_CB1 4 /* 1 */
420 # define SPARC_CB13 3 /* 1 or 3 */
421 # define SPARC_CB12 2 /* 1 or 2 */
422 # define SPARC_CB123 1 /* 1 or 2 or 3 */
423 # define SPARC_CB0 9 /* 0 */
424 # define SPARC_CB03 10 /* 0 or 3 */
425 # define SPARC_CB02 11 /* 0 or 2 */
426 # define SPARC_CB023 12 /* 0 or 2 or 3 */
427 # define SPARC_CB01 13 /* 0 or 1 */
428 # define SPARC_CB013 14 /* 0 or 1 or 3 */
429 # define SPARC_CB012 15 /* 0 or 1 or 2 */
430 # define CB(cc, imm) f2b(0, 0, cc, 7, imm)
431 # define CBa(cc, imm) f2b(0, 1, cc, 7, imm)
432 # define CBA(imm) CB(SPARC_CBA, imm)
433 # define CBAa(imm) CBa(SPARC_CBA, imm)
434 # define CBN(imm) CB(SPARC_CBN, imm)
435 # define CBNa(imm) CBa(SPARC_CBN, imm)
436 # define CB3(imm) CB(SPARC_CB3, imm)
437 # define CB3a(imm) CBa(SPARC_CB3, imm)
438 # define CB2(imm) CB(SPARC_CB2, imm)
439 # define CB2a(imm) CBa(SPARC_CB2, imm)
440 # define CB23(imm) CB(SPARC_CB23, imm)
441 # define CB23a(imm) CBa(SPARC_CB23, imm)
442 # define CB1(imm) CB(SPARC_CB1, imm)
443 # define CB1a(imm) CBa(SPARC_CB1, imm)
444 # define CB13(imm) CB(SPARC_CB13, imm)
445 # define CB13a(imm) CBa(SPARC_CB13, imm)
446 # define CB12(imm) CB(SPARC_CB12, imm)
447 # define CB12a(imm) CBa(SPARC_CB12, imm)
448 # define CB123(imm) CB(SPARC_CB123, imm)
449 # define CB123a(imm) CBa(SPARC_CB123, imm)
450 # define CB0(imm) CB(SPARC_CB0, imm)
451 # define CB0a(imm) CBa(SPARC_CB0, imm)
452 # define CB03(imm) CB(SPARC_CB03, imm)
453 # define CB03a(imm) CBa(SPARC_CB03, imm)
454 # define CB02(imm) CB(SPARC_CB02, imm)
455 # define CB02a(imm) CBa(SPARC_CB02, imm)
456 # define CB023(imm) CB(SPARC_CB103, imm)
457 # define CB023a(imm) CBa(SPARC_CB023, imm)
458 # define CB01(imm) CB(SPARC_CB01, imm)
459 # define CB01a(imm) CBa(SPARC_CB01, imm)
460 # define CB013(imm) CB(SPARC_CB013, imm)
461 # define CB013a(imm) CBa(SPARC_CB013, imm)
462 # define CB012(imm) CB(SPARC_CB012, imm)
463 # define CB012a(imm) CBa(SPARC_CB012, imm)
464 # define CALLI(imm) f1(1, imm)
465 # define CALL(r0) JMPL(_O7_REGNO, r0, 0)
466 # define RETL() JMPLI(0, _O7_REGNO, 8)
467 # define RET() JMPLI(0, _I7_REGNO, 8)
468 # define JMPL(rd, rs1, rs2) f3r(2, rd, 56, rs1, rs2)
469 # define JMPLI(rd, rs1, imm) f3i(2, rd, 56, rs1, imm)
470 # define RETT(rs1, rs2) f3r(2, 0, 57, rs1, rs2)
471 # define RETTI(rs1, imm) f3i(2, 0, 57, rs1, imm)
472 # define SPARC_TA 8 /* always */
473 # define SPARC_TN 0 /* never */
474 # define SPARC_TNE 9 /* not equal - not Z */
475 # define SPARC_TNZ SPARC_BNE
476 # define SPARC_TE 1 /* equal - Z */
477 # define SPARC_TZ SPARC_BE
478 # define SPARC_TG 10 /* greater - not (Z or (N xor V)) */
479 # define SPARC_TLE 2 /* less or equal - Z or (N xor V) */
480 # define SPARC_TGE 11 /* greater or equal - not (N xor V) */
481 # define SPARC_TL 3 /* less - N xor V */
482 # define SPARC_TGU 12 /* greater unsigned - not (C or Z) */
483 # define SPARC_TLEU 4 /* less or equal unsigned - C or Z */
484 # define SPARC_TCC 13 /* carry clear - not C */
485 # define SPARC_TGEU SPARC_BCC
486 # define SPARC_TCS 5 /* carry set - C */
487 # define SPARC_TLU SPARC_BCS
488 # define SPARC_TPOS 14 /* positive - not N */
489 # define SPARC_TNEG 6 /* negative - N */
490 # define SPARC_TVC 15 /* overflow clear - not V */
491 # define SPARC_TVS 7 /* overflow set - V */
492 # define T(cc, rs1, rs2) f3t(cc, rs1, 0, rs2)
493 # define TI(cc, rs1, imm) f3t(cc, rs1, 1, imm)
494 # define TA(rs1, rs2) T(SPARC_TA, rs1, rs2)
495 # define TAI(rs1, imm) TI(SPARC_TA, rs1, imm)
496 # define TN(rs1, rs2) T(SPARC_TN, rs1, rs2)
497 # define TNI(rs1, imm) TI(SPARC_TN, rs1, imm)
498 # define TNE(rs1, rs2) T(SPARC_TNE, rs1, rs2)
499 # define TNEI(rs1, imm) TI(SPARC_TNE, rs1, imm)
500 # define TNZ(rs1, rs2) TNE(rs1, rs2)
501 # define TNZI(rs1, imm) TNEI(rs1, imm)
502 # define TE(rs1, rs2) T(SPARC_TE, rs1, rs2)
503 # define TEI(rs1, imm) TI(SPARC_TE, rs1, imm)
504 # define TZ(rs1, rs2) TE(rs1, rs2)
505 # define TZI(rs1, imm) TEI(rs1, imm)
506 # define TG(rs1, rs2) T(SPARC_TG, rs1, rs2)
507 # define TGI(rs1, imm) TI(SPARC_TG, rs1, imm)
508 # define TLE(rs1, rs2) T(SPARC_TLE, rs1, rs2)
509 # define TLEI(rs1, imm) TI(SPARC_TLE, rs1, imm)
510 # define TGE(rs1, rs2) T(SPARC_TGE, rs1, rs2)
511 # define TGEI(rs1, imm) TI(SPARC_TGE, rs1, imm)
512 # define TL(rs1, rs2) T(SPARC_TL, rs1, rs2)
513 # define TLI(rs1, imm) TI(SPARC_TL, rs1, imm)
514 # define TGU(rs1, rs2) T(SPARC_TGU, rs1, rs2)
515 # define TGUI(rs1, imm) TI(SPARC_TGU, rs1, imm)
516 # define TLEU(rs1, rs2) T(SPARC_TLEU, rs1, rs2)
517 # define TLEUI(rs1, imm) TI(SPARC_TLEU, rs1, imm)
518 # define TCC(rs1, rs2) T(SPARC_TCC, rs1, rs2)
519 # define TCCI(rs1, imm) TI(SPARC_TCC, rs1, imm)
520 # define TGEU(rs1, rs2) TCC(rs1, rs2)
521 # define TGEUI(rs1, imm) TCCI(rs1, imm)
522 # define TCS(rs1, rs2) T(SPARC_TCC, rs1, rs2)
523 # define TCSI(rs1, imm) TI(SPARC_TCC, rs1, imm)
524 # define TLU(rs1, rs2) TCS(rs1, rs2)
525 # define TLUI(rs1, imm) TCSI(rs1, imm)
526 # define TPOS(rs1, rs2) T(SPARC_TPOS, rs1, rs2)
527 # define TPOSI(rs1, imm) TI(SPARC_TPOS, rs1, imm)
528 # define TNEG(rs1, rs2) T(SPARC_TNEG, rs1, rs2)
529 # define TNEGI(rs1, imm) TI(SPARC_TNEG, rs1, imm)
530 # define TVC(rs1, rs2) T(SPARC_TVC, rs1, rs2)
531 # define TVCI(rs1, imm) TI(SPARC_TVC, rs1, imm)
532 # define TVS(rs1, rs2) T(SPARC_TVS, rs1, rs2)
533 # define TVSI(rs1, imm) TI(SPARC_TVS, rs1, imm)
534 # define RDY(rd) f3r(2, rd, 40, 0, 0)
535 # define RDASR(rs1, rd) f3r(2, rd, 40, rs1, 0)
536 # define RDPSR(rd) f3r(2, rd, 41, 0, 0)
537 # define RDWIM(rd) f3r(2, rd, 42, 0, 0)
538 # define RDTBR(rd) f3r(2, rd, 43, 0, 0)
539 # define WRY(rs1, rs2) f3r(2, 0, 48, rs1, rs2)
540 # define WRYI(rs1, imm) f3i(2, 0, 48, rs1, imm)
541 # define WRASR(rs1, rs2, rd) f3r(2, rd, 48, rs1, rs2)
542 # define WRASRI(rs1, imm, rd) f3i(2, rd, 48, rs1, imm)
543 # define WRPSR(rs1, rs2, rd) f3r(2, rd, 49, rs1, rs2)
544 # define WRPSRI(rs1, imm, rd) f3i(2, rd, 49, rs1, imm)
545 # define WRWIM(rs1, rs2, rd) f3r(2, rd, 50, rs1, rs2)
546 # define WRWIMI(rs1, imm, rd) f3i(2, rd, 50, rs1, imm)
547 # define WRTBR(rs1, rs2, rd) f3r(2, rd, 51, rs1, rs2)
548 # define WRTBRI(rs1, imm, rd) f3i(2, rd, 51, rs1, imm)
549 # define STBAR() f3i(2, 0, 40, 15, 0)
550 # define UNIMP(imm) f2r(0, 0, 0, imm)
551 # define FLUSH(rs1, rs2) f3r(2, 0, 59, rs1, rs2)
552 # define FLUSHI(rs1, im) f3i(2, 0, 59, rs1, imm)
553 # define LZCNT(rs2, rd) f2c1(2, rd, 54, 0, 23, rs2)
554 # define nop(i0) _nop(_jit, i0)
555 static void _nop(jit_state_t*, jit_int32_t);
556 # define movr(r0, r1) _movr(_jit, r0, r1)
557 static void _movr(jit_state_t*, jit_int32_t, jit_int32_t);
558 # define movi(r0, i0) _movi(_jit, r0, i0)
559 static void _movi(jit_state_t*, jit_int32_t, jit_word_t);
560 # define movi_p(r0, i0) _movi_p(_jit, r0, i0)
561 static jit_word_t _movi_p(jit_state_t*, jit_int32_t, jit_word_t);
562 # define bswapr_us(r0, r1) generic_bswapr_us(_jit, r0, r1)
563 # define bswapr_ui(r0, r1) generic_bswapr_ui(_jit, r0, r1)
564 # define bswapr_ul(r0, r1) generic_bswapr_ul(_jit, r0, r1)
565 # define movnr(r0,r1,r2) _movnr(_jit,r0,r1,r2)
566 static void _movnr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
567 # define movzr(r0,r1,r2) _movzr(_jit,r0,r1,r2)
568 static void _movzr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
569 # define casx(r0, r1, r2, r3, i0) _casx(_jit, r0, r1, r2, r3, i0)
570 static void _casx(jit_state_t *_jit,jit_int32_t,jit_int32_t,
571 jit_int32_t,jit_int32_t,jit_word_t);
572 #define casr(r0, r1, r2, r3) casx(r0, r1, r2, r3, 0)
573 #define casi(r0, i0, r1, r2) casx(r0, _NOREG, r1, r2, i0)
574 # define comr(r0, r1) XNOR(r1, 0, r0)
575 # define negr(r0, r1) NEG(r1, r0)
576 # define bitswap(r0, r1) _bitswap(_jit, r0, r1)
577 static void _bitswap(jit_state_t*, jit_int32_t, jit_int32_t);
578 # define clor(r0, r1) _clor(_jit, r0, r1)
579 static void _clor(jit_state_t*, jit_int32_t, jit_int32_t);
580 # define clzr(r0, r1) _clzr(_jit, r0, r1)
581 static void _clzr(jit_state_t*, jit_int32_t, jit_int32_t);
582 # define ctor(r0, r1) _ctor(_jit, r0, r1)
583 static void _ctor(jit_state_t*, jit_int32_t, jit_int32_t);
584 # define ctzr(r0, r1) _ctzr(_jit, r0, r1)
585 static void _ctzr(jit_state_t*, jit_int32_t, jit_int32_t);
586 # define addr(r0, r1, r2) ADD(r1, r2, r0)
587 # define addi(r0, r1, i0) _addi(_jit, r0, r1, i0)
588 static void _addi(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
589 # if __WORDSIZE == 32
590 # define addcr(r0, r1, r2) ADDcc(r1, r2, r0)
592 # define addcr(r0, r1, r2) _addcr(_jit, r0, r1, r2)
593 static void _addcr(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
595 # define addci(r0, r1, i0) _addci(_jit, r0, r1, i0)
596 static void _addci(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
597 # if __WORDSIZE == 32
598 # define addxr(r0, r1, r2) ADDXcc(r1, r2, r0)
600 # define addxr(r0, r1, r2) _addxr(_jit, r0, r1, r2)
601 static void _addxr(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
603 # define addxi(r0, r1, i0) _addxi(_jit, r0, r1, i0)
604 static void _addxi(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
605 # define subr(r0, r1, r2) SUB(r1, r2, r0)
606 # define subi(r0, r1, i0) _subi(_jit, r0, r1, i0)
607 static void _subi(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
608 # if __WORDSIZE == 32
609 # define subcr(r0, r1, r2) SUBcc(r1, r2, r0)
611 # define subcr(r0, r1, r2) _subcr(_jit, r0, r1, r2)
612 static void _subcr(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
614 # define subci(r0, r1, i0) _subci(_jit, r0, r1, i0)
615 static void _subci(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
616 # if __WORDSIZE == 32
617 # define subxr(r0, r1, r2) SUBXcc(r1, r2, r0)
619 # define subxr(r0, r1, r2) _subxr(_jit, r0, r1, r2)
620 static void _subxr(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
622 # define subxi(r0, r1, i0) _subxi(_jit, r0, r1, i0)
623 static void _subxi(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
624 # define rsbi(r0, r1, i0) _rsbi(_jit, r0, r1, i0)
625 static void _rsbi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
626 # if __WORDSIZE == 32
627 # define mulr(r0, r1, r2) UMUL(r1, r2, r0)
629 # define mulr(r0, r1, r2) MULX(r1, r2, r0)
631 # define muli(r0, r1, i0) _muli(_jit, r0, r1, i0)
632 static void _muli(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
633 # if __WORDSIZE == 32
634 # define qmulr(r0,r1,r2,r3) iqmulr(r0,r1,r2,r3,1)
635 # define qmulr_u(r0,r1,r2,r3) iqmulr(r0,r1,r2,r3,0)
636 # define iqmulr(r0,r1,r2,r3,cc) _iqmulr(_jit,r0,r1,r2,r3,cc)
637 static void _iqmulr(jit_state_t*,jit_int32_t,jit_int32_t,
638 jit_int32_t,jit_int32_t,jit_bool_t);
639 # define qmuli(r0,r1,r2,i0) iqmuli(r0,r1,r2,i0,1)
640 # define qmuli_u(r0,r1,r2,i0) iqmuli(r0,r1,r2,i0,0)
641 # define iqmuli(r0,r1,r2,i0,cc) _iqmuli(_jit,r0,r1,r2,i0,cc)
642 static void _iqmuli(jit_state_t*,jit_int32_t,jit_int32_t,
643 jit_int32_t,jit_word_t,jit_bool_t);
645 # define qmulr(r0,r1,r2,r3) _qmulr(_jit,r0,r1,r2,r3)
646 static void _qmulr(jit_state_t*,jit_int32_t,jit_int32_t,
647 jit_int32_t,jit_int32_t);
648 # define qmuli(r0,r1,r2,i0) _qmuli(_jit,r0,r1,r2,i0)
649 static void _qmuli(jit_state_t*,jit_int32_t,jit_int32_t,
650 jit_int32_t,jit_word_t);
651 # define qmulr_u(r0,r1,r2,r3) _qmulr_u(_jit,r0,r1,r2,r3)
652 static void _qmulr_u(jit_state_t*,jit_int32_t,jit_int32_t,
653 jit_int32_t,jit_int32_t);
654 # define qmuli_u(r0,r1,r2,i0) _qmuli_u(_jit,r0,r1,r2,i0)
655 static void _qmuli_u(jit_state_t*,jit_int32_t,jit_int32_t,
656 jit_int32_t,jit_word_t);
658 # define divr(r0, r1, r2) _divr(_jit, r0, r1, r2)
659 static void _divr(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
660 # define divi(r0, r1, i0) _divi(_jit, r0, r1, i0)
661 static void _divi(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
662 # define divr_u(r0, r1, r2) _divr_u(_jit, r0, r1, r2)
663 static void _divr_u(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
664 # define divi_u(r0, r1, i0) _divi_u(_jit, r0, r1, i0)
665 static void _divi_u(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
666 # define qdivr(r0,r1,r2,r3) iqdivr(r0,r1,r2,r3,1)
667 # define qdivr_u(r0,r1,r2,r3) iqdivr(r0,r1,r2,r3,0)
668 # define iqdivr(r0,r1,r2,r3,cc) _iqdivr(_jit,r0,r1,r2,r3,cc)
669 static void _iqdivr(jit_state_t*,jit_int32_t,jit_int32_t,
670 jit_int32_t,jit_int32_t,jit_bool_t);
671 # define qdivi(r0,r1,r2,i0) iqdivi(r0,r1,r2,i0,1)
672 # define qdivi_u(r0,r1,r2,i0) iqdivi(r0,r1,r2,i0,0)
673 # define iqdivi(r0,r1,r2,i0,cc) _iqdivi(_jit,r0,r1,r2,i0,cc)
674 static void _iqdivi(jit_state_t*,jit_int32_t,jit_int32_t,
675 jit_int32_t,jit_word_t,jit_bool_t);
676 # define remr(r0, r1, r2) _remr(_jit, r0, r1, r2)
677 static void _remr(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
678 # define remi(r0, r1, i0) _remi(_jit, r0, r1, i0)
679 static void _remi(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
680 # define remr_u(r0, r1, r2) _remr_u(_jit, r0, r1, r2)
681 static void _remr_u(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
682 # define remi_u(r0, r1, i0) _remi_u(_jit, r0, r1, i0)
683 static void _remi_u(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
684 # define andr(r0, r1, r2) AND(r1, r2, r0)
685 # define andi(r0, r1, i0) _andi(_jit, r0, r1, i0)
686 static void _andi(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
687 # define orr(r0, r1, r2) OR(r1, r2, r0)
688 # define ori(r0, r1, i0) _ori(_jit, r0, r1, i0)
689 static void _ori(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
690 # define xorr(r0, r1, r2) XOR(r1, r2, r0)
691 # define xori(r0, r1, i0) _xori(_jit, r0, r1, i0)
692 static void _xori(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
693 # if __WORDSIZE == 32
694 # define lshr(r0, r1, r2) SLL(r1, r2, r0)
695 # define lshi(r0, r1, i0) SLLI(r1, i0, r0)
696 # define rshr(r0, r1, r2) SRA(r1, r2, r0)
697 # define rshi(r0, r1, i0) SRAI(r1, i0, r0)
698 # define rshr_u(r0, r1, r2) SRL(r1, r2, r0)
699 # define rshi_u(r0, r1, i0) SRLI(r1, i0, r0)
701 # define lshr(r0, r1, r2) SLLX(r1, r2, r0)
702 # define lshi(r0, r1, i0) SLLXI(r1, i0, r0)
703 # define rshr(r0, r1, r2) SRAX(r1, r2, r0)
704 # define rshi(r0, r1, i0) SRAXI(r1, i0, r0)
705 # define rshr_u(r0, r1, r2) SRLX(r1, r2, r0)
706 # define rshi_u(r0, r1, i0) SRLXI(r1, i0, r0)
708 # define extr_c(r0,r1) _extr_c(_jit,r0,r1)
709 static void _extr_c(jit_state_t*,jit_int32_t,jit_int32_t);
710 # define extr_uc(r0,r1) andi(r0, r1, 0xff)
711 # define extr_s(r0,r1) _extr_s(_jit,r0,r1)
712 static void _extr_s(jit_state_t*,jit_int32_t,jit_int32_t);
713 # define extr_us(r0,r1) _extr_us(_jit,r0,r1)
714 static void _extr_us(jit_state_t*,jit_int32_t,jit_int32_t);
715 # if __WORDSIZE == 64
716 # define extr_i(r0,r1) _extr_i(_jit,r0,r1)
717 static void _extr_i(jit_state_t*,jit_int32_t,jit_int32_t);
718 # define extr_ui(r0,r1) _extr_ui(_jit,r0,r1)
719 static void _extr_ui(jit_state_t*,jit_int32_t,jit_int32_t);
721 # define cr(cc, r0, r1, r2) _cr(_jit, cc, r0, r1, r2)
722 static void _cr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
723 # define cw(cc, r0, r1, i0) _cw(_jit, cc, r0, r1, i0)
724 static void _cw(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
725 # if __WORDSIZE == 32
726 # define ltr(r0, r1, r2) cr(SPARC_BL, r0, r1, r2)
727 # define lti(r0, r1, i0) cw(SPARC_BL, r0, r1, i0)
728 # define ltr_u(r0, r1, r2) cr(SPARC_BLU, r0, r1, r2)
729 # define lti_u(r0, r1, i0) cw(SPARC_BLU, r0, r1, i0)
730 # define ler(r0, r1, r2) cr(SPARC_BLE, r0, r1, r2)
731 # define lei(r0, r1, i0) cw(SPARC_BLE, r0, r1, i0)
732 # define ler_u(r0, r1, r2) cr(SPARC_BLEU, r0, r1, r2)
733 # define lei_u(r0, r1, i0) cw(SPARC_BLEU, r0, r1, i0)
734 # define eqr(r0, r1, r2) cr(SPARC_BE, r0, r1, r2)
735 # define eqi(r0, r1, i0) cw(SPARC_BE, r0, r1, i0)
736 # define ger(r0, r1, r2) cr(SPARC_BGE, r0, r1, r2)
737 # define gei(r0, r1, i0) cw(SPARC_BGE, r0, r1, i0)
738 # define ger_u(r0, r1, r2) cr(SPARC_BGEU, r0, r1, r2)
739 # define gei_u(r0, r1, i0) cw(SPARC_BGEU, r0, r1, i0)
740 # define gtr(r0, r1, r2) cr(SPARC_BG, r0, r1, r2)
741 # define gti(r0, r1, i0) cw(SPARC_BG, r0, r1, i0)
742 # define gtr_u(r0, r1, r2) cr(SPARC_BGU, r0, r1, r2)
743 # define gti_u(r0, r1, i0) cw(SPARC_BGU, r0, r1, i0)
744 # define ner(r0, r1, r2) cr(SPARC_BNE, r0, r1, r2)
745 # define nei(r0, r1, i0) cw(SPARC_BNE, r0, r1, i0)
747 # define ltr(r0, r1, r2) cr(SPARC_BPL, r0, r1, r2)
748 # define lti(r0, r1, i0) cw(SPARC_BPL, r0, r1, i0)
749 # define ltr_u(r0, r1, r2) cr(SPARC_BPCS, r0, r1, r2)
750 # define lti_u(r0, r1, i0) cw(SPARC_BPCS, r0, r1, i0)
751 # define ler(r0, r1, r2) cr(SPARC_BPLE, r0, r1, r2)
752 # define lei(r0, r1, i0) cw(SPARC_BPLE, r0, r1, i0)
753 # define ler_u(r0, r1, r2) cr(SPARC_BPLEU, r0, r1, r2)
754 # define lei_u(r0, r1, i0) cw(SPARC_BPLEU, r0, r1, i0)
755 # define eqr(r0, r1, r2) cr(SPARC_BPE, r0, r1, r2)
756 # define eqi(r0, r1, i0) cw(SPARC_BPE, r0, r1, i0)
757 # define ger(r0, r1, r2) cr(SPARC_BPGE, r0, r1, r2)
758 # define gei(r0, r1, i0) cw(SPARC_BPGE, r0, r1, i0)
759 # define ger_u(r0, r1, r2) cr(SPARC_BPCC, r0, r1, r2)
760 # define gei_u(r0, r1, i0) cw(SPARC_BPCC, r0, r1, i0)
761 # define gtr(r0, r1, r2) cr(SPARC_BPG, r0, r1, r2)
762 # define gti(r0, r1, i0) cw(SPARC_BPG, r0, r1, i0)
763 # define gtr_u(r0, r1, r2) cr(SPARC_BPGU, r0, r1, r2)
764 # define gti_u(r0, r1, i0) cw(SPARC_BPGU, r0, r1, i0)
765 # define ner(r0, r1, r2) cr(SPARC_BPNE, r0, r1, r2)
766 # define nei(r0, r1, i0) cw(SPARC_BPNE, r0, r1, i0)
768 # define ldr_c(r0, r1) LDSB(r1, 0, r0)
769 # define ldi_c(r0, i0) _ldi_c(_jit, r0, i0)
770 static void _ldi_c(jit_state_t*,jit_int32_t,jit_word_t);
771 # define ldr_uc(r0, r1) LDUB(r1, 0, r0)
772 # define ldi_uc(r0, i0) _ldi_uc(_jit, r0, i0)
773 static void _ldi_uc(jit_state_t*,jit_int32_t,jit_word_t);
774 # define ldr_s(r0, r1) LDSH(r1, 0, r0)
775 # define ldi_s(r0, i0) _ldi_s(_jit, r0, i0)
776 static void _ldi_s(jit_state_t*,jit_int32_t,jit_word_t);
777 # define ldr_us(r0, r1) LDUH(r1, 0, r0)
778 # define ldi_us(r0, i0) _ldi_us(_jit, r0, i0)
779 static void _ldi_us(jit_state_t*,jit_int32_t,jit_word_t);
780 # if __WORDSIZE == 32
781 # define ldr_i(r0, r1) LD(r1, 0, r0)
782 # define ldr(u, v) ldr_i(u, v)
783 # define ldi(u, v) ldi_i(u, v)
785 # define ldr_i(r0, r1) LDSW(r1, 0, r0)
786 # define ldr_ui(r0, r1) LDUW(r1, 0, r0)
787 # define ldr_l(r0, r1) LDX(r1, 0, r0)
788 # define ldr(u, v) ldr_l(u, v)
789 # define ldi(u, v) ldi_l(u, v)
791 # define ldi_i(r0, i0) _ldi_i(_jit, r0, i0)
792 static void _ldi_i(jit_state_t*,jit_int32_t,jit_word_t);
793 # if __WORDSIZE == 64
794 # define ldi_ui(r0, i0) _ldi_ui(_jit, r0, i0)
795 static void _ldi_ui(jit_state_t*,jit_int32_t,jit_word_t);
796 # define ldi_l(r0, i0) _ldi_l(_jit, r0, i0)
797 static void _ldi_l(jit_state_t*,jit_int32_t,jit_word_t);
799 # define ldxr_c(r0, r1, r2) LDSB(r1, r2, r0)
800 # define ldxi_c(r0, r1, i0) _ldxi_c(_jit, r0, r1, i0)
801 static void _ldxi_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
802 # define ldxr_uc(r0, r1, r2) LDUB(r1, r2, r0)
803 # define ldxi_uc(r0, r1, i0) _ldxi_uc(_jit, r0, r1, i0)
804 static void _ldxi_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
805 # define ldxr_s(r0, r1, r2) LDSH(r1, r2, r0)
806 # define ldxi_s(r0, r1, i0) _ldxi_s(_jit, r0, r1, i0)
807 static void _ldxi_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
808 # define ldxr_us(r0, r1, r2) LDUH(r1, r2, r0)
809 # define ldxi_us(r0, r1, i0) _ldxi_us(_jit, r0, r1, i0)
810 static void _ldxi_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
811 # if __WORDSIZE == 32
812 # define ldxr(u, v, w) ldxr_i(u, v, w)
813 # define ldxr_i(r0, r1, r2) LD(r1, r2, r0)
814 # define ldxi(u, v, w) ldxi_i(u, v, w)
816 # define ldxr(u, v, w) ldxr_l(u, v, w)
817 # define ldxr_i(r0, r1, r2) LDSW(r1, r2, r0)
818 # define ldxr_ui(r0, r1, r2) LDUW(r1, r2, r0)
819 # define ldxr_l(r0, r1, r2) LDX(r1, r2, r0)
820 # define ldxi(u, v, w) ldxi_l(u, v, w)
822 # define ldxi_i(r0, r1, i0) _ldxi_i(_jit, r0, r1, i0)
823 static void _ldxi_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
824 # if __WORDSIZE == 64
825 # define ldxi_ui(r0, r1, i0) _ldxi_ui(_jit, r0, r1, i0)
826 static void _ldxi_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
827 # define ldxi_l(r0, r1, i0) _ldxi_l(_jit, r0, r1, i0)
828 static void _ldxi_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
830 # define str_c(r0, r1) STB(r1, r0, 0)
831 # define sti_c(i0, r0) _sti_c(_jit, i0, r0)
832 static void _sti_c(jit_state_t*,jit_word_t,jit_int32_t);
833 # define str_s(r0, r1) STH(r1, r0, 0)
834 # define sti_s(i0, r0) _sti_s(_jit, i0, r0)
835 static void _sti_s(jit_state_t*,jit_word_t,jit_int32_t);
836 # if __WORDSIZE == 32
837 # define str(u, v) str_i(u, v)
838 # define str_i(r0, r1) STI(r1, r0, 0)
839 # define sti(u, v) sti_i(u, v)
841 # define str(u, v) str_l(u, v)
842 # define str_i(r0, r1) STW(r1, r0, 0)
843 # define str_l(r0, r1) STX(r1, r0, 0)
844 # define sti(u, v) sti_l(u, v)
846 # define sti_i(i0, r0) _sti_i(_jit, i0, r0)
847 static void _sti_i(jit_state_t*,jit_word_t,jit_int32_t);
848 # if __WORDSIZE == 64
849 # define sti_l(i0, r0) _sti_l(_jit, i0, r0)
850 static void _sti_l(jit_state_t*,jit_word_t,jit_int32_t);
852 # define stxr_c(r0, r1, r2) STB(r2, r1, r0)
853 # define stxi_c(i0, r0, r1) _stxi_c(_jit, i0, r0, r1)
854 static void _stxi_c(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
855 # define stxr_s(r0, r1, r2) STH(r2, r1, r0)
856 # define stxi_s(i0, r0, r1) _stxi_s(_jit, i0, r0, r1)
857 static void _stxi_s(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
858 # if __WORDSIZE == 32
859 # define stxr(u, v, w) stxr_i(u, v, w)
860 # define stxr_i(r0, r1, r2) ST(r2, r1, r0)
861 # define stxi(u, v, w) stxi_i(u, v, w)
863 # define stxr(u, v, w) stxr_l(u, v, w)
864 # define stxr_i(r0, r1, r2) STW(r2, r1, r0)
865 # define stxi(u, v, w) stxi_l(u, v, w)
866 # define stxr_l(r0, r1, r2) STX(r2, r1, r0)
868 # define stxi_i(i0, r0, r1) _stxi_i(_jit, i0, r0, r1)
869 static void _stxi_i(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
870 # if __WORDSIZE == 64
871 # define stxi_l(i0, r0, r1) _stxi_l(_jit, i0, r0, r1)
872 static void _stxi_l(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
874 # define br(cc, i0, r0, r1) _br(_jit, cc, i0, r0, r1)
876 _br(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_int32_t);
877 # define bw(cc, i0, r0, i1) _bw(_jit, cc, i0, r0, i1)
879 _bw(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_word_t);
880 # if __WORDSIZE == 32
881 # define bltr(i0, r0, r1) br(SPARC_BL, i0, r0, r1)
882 # define blti(i0, r0, i1) bw(SPARC_BL, i0, r0, i1)
883 # define bltr_u(i0, r0, r1) br(SPARC_BLU, i0, r0, r1)
884 # define blti_u(i0, r0, i1) bw(SPARC_BLU, i0, r0, i1)
885 # define bler(i0, r0, r1) br(SPARC_BLE, i0, r0, r1)
886 # define blei(i0, r0, i1) bw(SPARC_BLE, i0, r0, i1)
887 # define bler_u(i0, r0, r1) br(SPARC_BLEU, i0, r0, r1)
888 # define blei_u(i0, r0, i1) bw(SPARC_BLEU, i0, r0, i1)
889 # define beqr(i0, r0, r1) br(SPARC_BE, i0, r0, r1)
890 # define beqi(i0, r0, i1) bw(SPARC_BE, i0, r0, i1)
891 # define bger(i0, r0, r1) br(SPARC_BGE, i0, r0, r1)
892 # define bgei(i0, r0, i1) bw(SPARC_BGE, i0, r0, i1)
893 # define bger_u(i0, r0, r1) br(SPARC_BGEU, i0, r0, r1)
894 # define bgei_u(i0, r0, i1) bw(SPARC_BGEU, i0, r0, i1)
895 # define bgtr(i0, r0, r1) br(SPARC_BG, i0, r0, r1)
896 # define bgti(i0, r0, i1) bw(SPARC_BG, i0, r0, i1)
897 # define bgtr_u(i0, r0, r1) br(SPARC_BGU, i0, r0, r1)
898 # define bgti_u(i0, r0, i1) bw(SPARC_BGU, i0, r0, i1)
899 # define bner(i0, r0, r1) br(SPARC_BNE, i0, r0, r1)
900 # define bnei(i0, r0, i1) bw(SPARC_BNE, i0, r0, i1)
902 # define bltr(i0, r0, r1) br(SPARC_BPL, i0, r0, r1)
903 # define blti(i0, r0, i1) bw(SPARC_BPL, i0, r0, i1)
904 # define bltr_u(i0, r0, r1) br(SPARC_BPCS, i0, r0, r1)
905 # define blti_u(i0, r0, i1) bw(SPARC_BPCS, i0, r0, i1)
906 # define bler(i0, r0, r1) br(SPARC_BPLE, i0, r0, r1)
907 # define blei(i0, r0, i1) bw(SPARC_BPLE, i0, r0, i1)
908 # define bler_u(i0, r0, r1) br(SPARC_BPLEU, i0, r0, r1)
909 # define blei_u(i0, r0, i1) bw(SPARC_BPLEU, i0, r0, i1)
910 # define beqr(i0, r0, r1) br(SPARC_BPE, i0, r0, r1)
911 # define beqi(i0, r0, i1) bw(SPARC_BPE, i0, r0, i1)
912 # define bger(i0, r0, r1) br(SPARC_BPGE, i0, r0, r1)
913 # define bgei(i0, r0, i1) bw(SPARC_BPGE, i0, r0, i1)
914 # define bger_u(i0, r0, r1) br(SPARC_BPCC, i0, r0, r1)
915 # define bgei_u(i0, r0, i1) bw(SPARC_BPCC, i0, r0, i1)
916 # define bgtr(i0, r0, r1) br(SPARC_BPG, i0, r0, r1)
917 # define bgti(i0, r0, i1) bw(SPARC_BPG, i0, r0, i1)
918 # define bgtr_u(i0, r0, r1) br(SPARC_BPGU, i0, r0, r1)
919 # define bgti_u(i0, r0, i1) bw(SPARC_BPGU, i0, r0, i1)
920 # define bner(i0, r0, r1) br(SPARC_BPNE, i0, r0, r1)
921 # define bnei(i0, r0, i1) bw(SPARC_BPNE, i0, r0, i1)
923 # define b_asr(jif,add,sgn,i0,r0,r1) _b_asr(_jit,jif,add,sgn,i0,r0,r1)
925 _b_asr(jit_state_t*,jit_bool_t,jit_bool_t,jit_bool_t,
926 jit_word_t,jit_int32_t,jit_int32_t);
927 # define b_asw(jif,add,sgn,i0,r0,i1) _b_asw(_jit,jif,add,sgn,i0,r0,i1)
929 _b_asw(jit_state_t*,jit_bool_t,jit_bool_t,jit_bool_t,
930 jit_word_t,jit_int32_t,jit_word_t);
931 # define boaddr(i0, r0, r1) b_asr(1, 1, 1, i0, r0, r1)
932 # define boaddi(i0, r0, i1) b_asw(1, 1, 1, i0, r0, i1)
933 # define boaddr_u(i0, r0, r1) b_asr(1, 1, 0, i0, r0, r1)
934 # define boaddi_u(i0, r0, i1) b_asw(1, 1, 0, i0, r0, i1)
935 # define bxaddr(i0, r0, r1) b_asr(0, 1, 1, i0, r0, r1)
936 # define bxaddi(i0, r0, i1) b_asw(0, 1, 1, i0, r0, i1)
937 # define bxaddr_u(i0, r0, r1) b_asr(0, 1, 0, i0, r0, r1)
938 # define bxaddi_u(i0, r0, i1) b_asw(0, 1, 0, i0, r0, i1)
939 # define bosubr(i0, r0, r1) b_asr(1, 0, 1, i0, r0, r1)
940 # define bosubi(i0, r0, i1) b_asw(1, 0, 1, i0, r0, i1)
941 # define bosubr_u(i0, r0, r1) b_asr(1, 0, 0, i0, r0, r1)
942 # define bosubi_u(i0, r0, i1) b_asw(1, 0, 0, i0, r0, i1)
943 # define bxsubr(i0, r0, r1) b_asr(0, 0, 1, i0, r0, r1)
944 # define bxsubi(i0, r0, i1) b_asw(0, 0, 1, i0, r0, i1)
945 # define bxsubr_u(i0, r0, r1) b_asr(0, 0, 0, i0, r0, r1)
946 # define bxsubi_u(i0, r0, i1) b_asw(0, 0, 0, i0, r0, i1)
947 # define bm_r(set, i0, r0, r1) _bm_r(_jit,set,i0,r0,r1)
949 _bm_r(jit_state_t*,jit_bool_t,jit_word_t,jit_int32_t,jit_int32_t);
950 # define bm_w(set,i0,r0,i1) _bm_w(_jit,set,i0,r0,i1)
952 _bm_w(jit_state_t*,jit_bool_t,jit_word_t,jit_int32_t,jit_word_t);
953 # define bmsr(i0, r0, r1) bm_r(1, i0, r0, r1)
954 # define bmsi(i0, r0, i1) bm_w(1, i0, r0, i1)
955 # define bmcr(i0, r0, r1) bm_r(0, i0, r0, r1)
956 # define bmci(i0, r0, i1) bm_w(0, i0, r0, i1)
957 # define jmpr(r0) _jmpr(_jit, r0)
958 static void _jmpr(jit_state_t*,jit_int32_t);
959 # define jmpi(i0) _jmpi(_jit, i0)
960 static jit_word_t _jmpi(jit_state_t*,jit_word_t);
961 # define jmpi_p(i0) _jmpi_p(_jit, i0)
962 static jit_word_t _jmpi_p(jit_state_t*,jit_word_t);
963 # define callr(r0) _callr(_jit, r0)
964 static void _callr(jit_state_t*,jit_int32_t);
965 # define calli(i0) _calli(_jit, i0)
966 static jit_word_t _calli(jit_state_t*,jit_word_t);
967 # define calli_p(i0) _calli_p(_jit, i0)
968 static jit_word_t _calli_p(jit_state_t*,jit_word_t);
969 # define prolog(node) _prolog(_jit, node)
970 static void _prolog(jit_state_t*,jit_node_t*);
971 # define epilog(node) _epilog(_jit, node)
972 static void _epilog(jit_state_t*,jit_node_t*);
973 #define vastart(r0) _vastart(_jit, r0)
974 static void _vastart(jit_state_t*, jit_int32_t);
975 #define vaarg(r0, r1) _vaarg(_jit, r0, r1)
976 static void _vaarg(jit_state_t*, jit_int32_t, jit_int32_t);
977 #define patch_at(jump, label) _patch_at(_jit, jump, label)
978 static void _patch_at(jit_state_t*,jit_word_t,jit_word_t);
983 _f2r(jit_state_t *_jit,
984 jit_int32_t op, jit_int32_t rd, jit_int32_t op2, jit_int32_t imm22)
987 assert(!(op & 0xfffffffc));
988 assert(!(rd & 0xffffffe0));
989 assert(!(op2 & 0xfffffff8));
990 assert(s22_p(imm22));
999 _f2b(jit_state_t *_jit,
1000 jit_int32_t op, jit_int32_t a, jit_int32_t cond, jit_int32_t op2,
1004 assert(!(op & 0xfffffffc));
1005 assert(!(a & 0xfffffffe));
1006 assert(!(cond & 0xfffffff0));
1007 assert(!(op2 & 0xfffffff8));
1008 assert(s22_p(disp22));
1013 v.disp22.b = disp22;
1017 # if __WORDSIZE == 64
1019 _f2bp(jit_state_t *_jit,
1020 jit_int32_t op, jit_int32_t a, jit_int32_t cond, jit_int32_t op2,
1021 jit_int32_t cc1, jit_int32_t cc0, jit_int32_t p, jit_int32_t disp19)
1024 assert(!(op & 0xfffffffc));
1025 assert(!(a & 0xfffffffe));
1026 assert(!(cond & 0xfffffff0));
1027 assert(!(op2 & 0xfffffff8));
1028 assert(s19_p(disp19));
1036 v.disp19.b = disp19;
1042 _f3r(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd,
1043 jit_int32_t op3, jit_int32_t rs1, jit_int32_t rs2)
1046 assert(!(op & 0xfffffffc));
1047 assert(!(rd & 0xffffffe0));
1048 assert(!(op3 & 0xffffffc0));
1049 assert(!(rs1 & 0xffffffe0));
1050 assert(!(rs2 & 0xffffffe0));
1061 # if __WORDSIZE == 64
1063 _f3ri(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd,
1064 jit_int32_t op3, jit_int32_t rs1, jit_int32_t rs2)
1067 assert(!(op & 0xfffffffc));
1068 assert(!(rd & 0xffffffe0));
1069 assert(!(op3 & 0xffffffc0));
1070 assert(!(rs1 & 0xffffffe0));
1071 assert(!(rs2 & 0xffffffe0));
1083 _f3rx(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd,
1084 jit_int32_t op3, jit_int32_t rs1, jit_int32_t rs2)
1087 assert(!(op & 0xfffffffc));
1088 assert(!(rd & 0xffffffe0));
1089 assert(!(op3 & 0xffffffc0));
1090 assert(!(rs1 & 0xffffffe0));
1091 assert(!(rs2 & 0xffffffe0));
1104 _f3s(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd,
1105 jit_int32_t op3, jit_int32_t rs1, jit_int32_t shim)
1108 assert(!(op & 0xfffffffc));
1109 assert(!(rd & 0xffffffe0));
1110 assert(!(op3 & 0xffffffc0));
1111 assert(!(rs1 & 0xffffffe0));
1112 assert(!(shim & 0xffffffc0));
1126 _f3i(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd,
1127 jit_int32_t op3, jit_int32_t rs1, jit_int32_t simm13)
1130 assert(!(op & 0xfffffffc));
1131 assert(!(rd & 0xffffffe0));
1132 assert(!(op3 & 0xffffffc0));
1133 assert(!(rs1 & 0xffffffe0));
1134 assert(s13_p(simm13));
1140 v.simm13.b = simm13;
1145 _f3t(jit_state_t *_jit, jit_int32_t cond,
1146 jit_int32_t rs1, jit_int32_t i, jit_int32_t rs2_imm7)
1149 assert(!(cond & 0xfffffff0));
1150 assert(!(i & 0xfffffffe));
1151 assert(!(rs1 & 0xffffffe0));
1157 assert(s7_p(rs2_imm7));
1159 v.imm7.b = rs2_imm7;
1162 assert(!(rs2_imm7 & 0xffffffe0));
1170 _f3a(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd,
1171 jit_int32_t op3, jit_int32_t rs1, jit_int32_t asi, jit_int32_t rs2)
1174 assert(!(op & 0xfffffffc));
1175 assert(!(rd & 0xffffffe0));
1176 assert(!(op3 & 0xffffffc0));
1177 assert(!(rs1 & 0xffffffe0));
1178 assert(!(asi & 0xffffff00));
1179 assert(!(rs2 & 0xffffffe0));
1191 _f1(jit_state_t *_jit, jit_int32_t op, jit_int32_t disp30)
1194 assert(!(op & 0xfffffffc));
1195 assert(s30_p(disp30));
1197 v.disp30.b = disp30;
1202 _f2c1(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd,
1203 jit_int32_t op3, jit_int32_t rs1, jit_int32_t opf, jit_int32_t rs2)
1206 assert(!(op & 0xfffffffc));
1207 assert(!(rd & 0xffffffe0));
1208 assert(!(res & 0xffffffc0));
1209 assert(!(rs1 & 0xffffffe0));
1210 assert(!(opf & 0xfffffe00));
1211 assert(!(rs2 & 0xfffffe00));
1222 _nop(jit_state_t *_jit, jit_int32_t i0)
1224 for (; i0 > 0; i0 -= 4)
1230 _movr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1237 _movi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1242 # if __WORDSIZE == 64
1243 if (i0 & 0xffffffff00000000) {
1244 jit_int32_t reg = jit_get_reg(jit_class_gpr);
1245 movi(rn(reg), (i0 >> 32) & 0xffffffff);
1246 movi(r0, i0 & 0xffffffff);
1247 lshi(rn(reg), rn(reg), 32);
1248 OR(rn(reg), r0, r0);
1253 SETHI(HI((int)i0), r0);
1255 ORI(r0, LO(i0), r0);
1256 # if __WORDSIZE == 64
1263 _movi_p(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1266 # if __WORDSIZE == 64
1270 # if __WORDSIZE == 64
1271 reg = jit_get_reg(jit_class_gpr);
1272 SETHI(HI((int)i0), r0);
1273 ORI(r0, LO(i0), r0);
1274 i0 = (int)(i0 >> 32);
1275 SETHI(HI(i0), rn(reg));
1276 ORI(rn(reg), LO(i0), rn(reg));
1277 SLLXI(rn(reg), 32, rn(reg));
1278 OR(rn(reg), r0, r0);
1282 ORI(r0, LO(i0), r0);
1288 _movnr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1291 w = beqi(_jit->pc.w, r2, 0);
1293 patch_at(w, _jit->pc.w);
1297 _movzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1300 w = bnei(_jit->pc.w, r2, 0);
1302 patch_at(w, _jit->pc.w);
1306 _casx(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1307 jit_int32_t r2, jit_int32_t r3, jit_word_t i0)
1309 jit_int32_t iscasi, r1_reg;
1310 if ((iscasi = (r1 == _NOREG))) {
1311 r1_reg = jit_get_reg(jit_class_gpr);
1315 /* Do not clobber r2 */
1317 /* The CASXA instruction compares the value in register r[rs2] with
1318 * the doubleword in memory pointed to by the doubleword address in
1319 * r[rs1]. If the values are equal, the value in r[rd] is swapped
1320 * with the doubleword pointed to by the doubleword address in r[rs1].
1321 * If the values are not equal, the contents of the doubleword pointed
1322 * to by r[rs1] replaces the value in r[rd], but the memory location
1323 * remains unchanged.
1325 # if __WORDSIZE == 32
1332 jit_unget_reg(r1_reg);
1336 _bitswap(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1338 jit_int32_t t0, t1, t2, t3, t4;
1340 t0 = jit_get_reg(jit_class_gpr);
1341 t1 = jit_get_reg(jit_class_gpr);
1342 t2 = jit_get_reg(jit_class_gpr);
1343 movi(rn(t0), __WORDSIZE == 32 ? 0x55555555L : 0x5555555555555555L);
1344 rshi_u(rn(t1), r0, 1); /* t1 = v >> 1 */
1345 andr(rn(t1), rn(t1), rn(t0)); /* t1 &= t0 */
1346 andr(rn(t2), r0, rn(t0)); /* t2 = v & t0*/
1347 lshi(rn(t2), rn(t2), 1); /* t2 <<= 1 */
1348 orr(r0, rn(t1), rn(t2)); /* v = t1 | t2 */
1349 movi(rn(t0), __WORDSIZE == 32 ? 0x33333333L : 0x3333333333333333L);
1350 rshi_u(rn(t1), r0, 2); /* t1 = v >> 2 */
1351 andr(rn(t1), rn(t1), rn(t0)); /* t1 &= t0 */
1352 andr(rn(t2), r0, rn(t0)); /* t2 = v & t0*/
1353 lshi(rn(t2), rn(t2), 2); /* t2 <<= 2 */
1354 orr(r0, rn(t1), rn(t2)); /* v = t1 | t2 */
1355 movi(rn(t0), __WORDSIZE == 32 ? 0x0f0f0f0fL : 0x0f0f0f0f0f0f0f0fL);
1356 rshi_u(rn(t1), r0, 4); /* t1 = v >> 4 */
1357 andr(rn(t1), rn(t1), rn(t0)); /* t1 &= t0 */
1358 andr(rn(t2), r0, rn(t0)); /* t2 = v & t0*/
1359 lshi(rn(t2), rn(t2), 4); /* t2 <<= 4 */
1360 orr(r0, rn(t1), rn(t2)); /* v = t1 | t2 */
1361 movi(rn(t0), __WORDSIZE == 32 ? 0x00ff00ffL : 0x00ff00ff00ff00ffL);
1362 rshi_u(rn(t1), r0, 8); /* t1 = v >> 8 */
1363 andr(rn(t1), rn(t1), rn(t0)); /* t1 &= t0 */
1364 andr(rn(t2), r0, rn(t0)); /* t2 = v & t0*/
1365 lshi(rn(t2), rn(t2), 8); /* t2 <<= 8 */
1366 orr(r0, rn(t1), rn(t2)); /* v = t1 | t2 */
1367 # if __WORDSIZE == 32
1368 rshi_u(rn(t1), r0, 16); /* t1 = v >> 16 */
1369 lshi(rn(t2), r0, 16); /* t2 = v << 16 */
1370 orr(r0, rn(t1), rn(t2)); /* v = t1 | t2 */
1372 movi(rn(t0), 0x0000ffff0000ffffL);
1373 rshi_u(rn(t1), r0, 16); /* t1 = v >> 16 */
1374 andr(rn(t1), rn(t1), rn(t0)); /* t1 &= t0 */
1375 andr(rn(t2), r0, rn(t0)); /* t2 = v & t0*/
1376 lshi(rn(t2), rn(t2), 16); /* t2 <<= 16 */
1377 orr(r0, rn(t1), rn(t2)); /* v = t1 | t2 */
1378 rshi_u(rn(t1), r0, 32); /* t1 = v >> 32 */
1379 lshi(rn(t2), r0, 32); /* t2 = v << 32 */
1380 orr(r0, rn(t1), rn(t2)); /* v = t1 | t2 */
1388 _clor(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1390 if (jit_cpu.lzcnt) {
1395 fallback_clo(r0, r1);
1399 _clzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1401 if (jit_cpu.lzcnt) {
1402 #if __WORDSIZE == 32
1406 #if __WORDSIZE == 32
1407 w = blei(_jit->pc.w, r0, 31);
1408 rshi(r0, r0, 1); /* r0 is 64 */
1409 patch_at(w, _jit->pc.w);
1415 fallback_clz(r0, r1);
1419 _ctor(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1421 if (jit_cpu.lzcnt) {
1426 fallback_cto(r0, r1);
1430 _ctzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1432 if (jit_cpu.lzcnt) {
1437 fallback_ctz(r0, r1);
1441 _addi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1447 reg = jit_get_reg(jit_class_gpr);
1449 addr(r0, r1, rn(reg));
1454 # if __WORDSIZE == 64
1456 _addcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1459 if (jit_carry == _NOREG)
1460 jit_carry = jit_get_reg(jit_class_gpr);
1462 reg = jit_get_reg(jit_class_gpr);
1463 addr(rn(reg), r1, r2);
1464 ltr_u(rn(jit_carry), rn(reg), r1);
1470 ltr_u(rn(jit_carry), r0, r1);
1476 _addci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1478 # if __WORDSIZE == 32
1483 reg = jit_get_reg(jit_class_gpr);
1485 addcr(r0, r1, rn(reg));
1490 if (jit_carry == _NOREG)
1491 jit_carry = jit_get_reg(jit_class_gpr);
1493 reg = jit_get_reg(jit_class_gpr);
1494 addi(rn(reg), r1, i0);
1495 ltr_u(rn(jit_carry), rn(reg), r1);
1501 ltr_u(rn(jit_carry), r0, r1);
1506 # if __WORDSIZE == 64
1508 _addxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1511 assert(jit_carry != _NOREG);
1512 reg = jit_get_reg(jit_class_gpr);
1513 movr(rn(reg), rn(jit_carry));
1515 addcr(r0, r0, rn(reg));
1521 _addxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1523 # if __WORDSIZE == 32
1526 ADDXIcc(r1, i0, r0);
1528 reg = jit_get_reg(jit_class_gpr);
1530 addxr(r0, r1, rn(reg));
1535 assert(jit_carry != _NOREG);
1536 reg = jit_get_reg(jit_class_gpr);
1537 movr(rn(reg), rn(jit_carry));
1539 addcr(r0, r0, rn(reg));
1545 _subi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1551 reg = jit_get_reg(jit_class_gpr);
1553 subr(r0, r1, rn(reg));
1558 # if __WORDSIZE == 64
1560 _subcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1563 if (jit_carry == _NOREG)
1564 jit_carry = jit_get_reg(jit_class_gpr);
1566 reg = jit_get_reg(jit_class_gpr);
1567 subr(rn(reg), r1, r2);
1568 ltr_u(rn(jit_carry), r1, rn(reg));
1574 ltr_u(rn(jit_carry), r1, r0);
1580 _subci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1582 # if __WORDSIZE == 32
1587 reg = jit_get_reg(jit_class_gpr);
1589 subcr(r0, r1, rn(reg));
1594 if (jit_carry == _NOREG)
1595 jit_carry = jit_get_reg(jit_class_gpr);
1597 reg = jit_get_reg(jit_class_gpr);
1598 addi(rn(reg), r1, -i0);
1599 ltr_u(rn(jit_carry), r1, rn(reg));
1605 ltr_u(rn(jit_carry), r1, r0);
1610 # if __WORDSIZE == 64
1612 _subxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1615 assert(jit_carry != _NOREG);
1616 reg = jit_get_reg(jit_class_gpr);
1617 movr(rn(reg), rn(jit_carry));
1619 subcr(r0, r0, rn(reg));
1625 _subxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1627 # if __WORDSIZE == 32
1630 SUBXIcc(r1, i0, r0);
1632 reg = jit_get_reg(jit_class_gpr);
1634 subxr(r0, r1, rn(reg));
1639 assert(jit_carry != _NOREG);
1640 reg = jit_get_reg(jit_class_gpr);
1641 movr(rn(reg), rn(jit_carry));
1643 subcr(r0, r0, rn(reg));
1649 _rsbi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1656 _muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1660 # if __WORDSIZE == 32
1667 reg = jit_get_reg(jit_class_gpr);
1669 mulr(r0, r1, rn(reg));
1674 # if __WORDSIZE == 32
1676 _iqmulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1677 jit_int32_t r2, jit_int32_t r3, jit_bool_t sign)
1687 _iqmuli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1688 jit_int32_t r2, jit_word_t i0, jit_bool_t sign)
1699 reg = jit_get_reg(jit_class_gpr);
1701 iqmulr(r0, r1, r2, rn(reg), sign);
1707 static __int128_t __llmul(jit_word_t a, jit_word_t b)
1709 return (__int128_t)a * (__int128_t)b;
1712 # define QMUL_PROLOG() \
1714 (void)jit_get_reg(_O0|jit_class_gpr|jit_class_named); \
1715 (void)jit_get_reg(_O1|jit_class_gpr|jit_class_named); \
1716 if (r0 != _G2_REGNO && r1 != _G2_REGNO) \
1717 stxi(BIAS(-8), _FP_REGNO, _G2_REGNO); \
1718 if (r0 != _G3_REGNO && r1 != _G3_REGNO) \
1719 stxi(BIAS(-16), _FP_REGNO, _G3_REGNO); \
1720 if (r0 != _G4_REGNO && r1 != _G4_REGNO) \
1721 stxi(BIAS(-24), _FP_REGNO, _G4_REGNO); \
1724 # define QMUL_EPILOG() \
1726 if (r0 != _G2_REGNO && r1 != _G2_REGNO) \
1727 ldxi(_G2_REGNO, _FP_REGNO, BIAS(-8)); \
1728 if (r0 != _G3_REGNO && r1 != _G3_REGNO) \
1729 ldxi(_G3_REGNO, _FP_REGNO, BIAS(-16)); \
1730 if (r0 != _G4_REGNO && r1 != _G4_REGNO) \
1731 ldxi(_G4_REGNO, _FP_REGNO, BIAS(-24)); \
1732 (void)jit_unget_reg(_O0); \
1733 (void)jit_unget_reg(_O1); \
1737 _qmulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1738 jit_int32_t r2, jit_int32_t r3)
1741 movr(_O0_REGNO, r3);
1742 movr(_O1_REGNO, r2);
1743 calli((jit_word_t)__llmul);
1744 movr(r0, _O1_REGNO);
1745 movr(r1, _O0_REGNO);
1750 _qmuli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1751 jit_int32_t r2, jit_word_t i0)
1754 movi(_O0_REGNO, i0);
1755 movr(_O1_REGNO, r2);
1756 calli((jit_word_t)__llmul);
1757 movr(r0, _O1_REGNO);
1758 movr(r1, _O0_REGNO);
1762 static __uint128_t __ullmul(jit_uword_t a, jit_uword_t b)
1764 return (__uint128_t)a * (__uint128_t)b;
1768 _qmulr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1769 jit_int32_t r2, jit_int32_t r3)
1772 movr(_O0_REGNO, r3);
1773 movr(_O1_REGNO, r2);
1774 calli((jit_word_t)__ullmul);
1775 movr(r0, _O1_REGNO);
1776 movr(r1, _O0_REGNO);
1781 _qmuli_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1782 jit_int32_t r2, jit_word_t i0)
1785 movi(_O0_REGNO, i0);
1786 movr(_O1_REGNO, r2);
1787 calli((jit_word_t)__ullmul);
1788 movr(r0, _O1_REGNO);
1789 movr(r1, _O0_REGNO);
1795 _divr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1797 # if __WORDSIZE == 32
1799 reg = jit_get_reg(jit_class_gpr);
1800 rshi(rn(reg), r1, 31);
1810 _divi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1813 # if __WORDSIZE == 32
1814 reg = jit_get_reg(jit_class_gpr);
1817 # if __WORDSIZE == 32
1818 rshi(rn(reg), r1, 31);
1826 # if __WORDSIZE == 64
1827 reg = jit_get_reg(jit_class_gpr);
1830 divr(r0, r1, rn(reg));
1831 # if __WORDSIZE == 64
1835 # if __WORDSIZE == 32
1841 _divr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1843 # if __WORDSIZE == 32
1852 _divi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1856 # if __WORDSIZE == 32
1864 reg = jit_get_reg(jit_class_gpr);
1866 divr_u(r0, r1, rn(reg));
1872 _iqdivr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1873 jit_int32_t r2, jit_int32_t r3, jit_bool_t sign)
1875 jit_int32_t sv0, rg0;
1876 jit_int32_t sv1, rg1;
1878 if (r0 == r2 || r0 == r3) {
1879 sv0 = jit_get_reg(jit_class_gpr);
1884 if (r1 == r2 || r1 == r3) {
1885 sv1 = jit_get_reg(jit_class_gpr);
1894 divr_u(rg0, r2, r3);
1908 _iqdivi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1909 jit_int32_t r2, jit_word_t i0, jit_bool_t sign)
1912 reg = jit_get_reg(jit_class_gpr);
1914 iqdivr(r0, r1, r2, rn(reg), sign);
1919 _remr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1922 if (r0 == r1 || r0 == r2) {
1923 reg = jit_get_reg(jit_class_gpr);
1924 divr(rn(reg), r1, r2);
1925 mulr(rn(reg), r2, rn(reg));
1926 subr(r0, r1, rn(reg));
1937 _remi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1940 reg = jit_get_reg(jit_class_gpr);
1942 remr(r0, r1, rn(reg));
1947 _remr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1950 if (r0 == r1 || r0 == r2) {
1951 reg = jit_get_reg(jit_class_gpr);
1952 divr_u(rn(reg), r1, r2);
1953 mulr(rn(reg), r2, rn(reg));
1954 subr(r0, r1, rn(reg));
1965 _remi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1968 reg = jit_get_reg(jit_class_gpr);
1970 remr_u(r0, r1, rn(reg));
1975 _andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1981 reg = jit_get_reg(jit_class_gpr);
1983 andr(r0, r1, rn(reg));
1989 _ori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1995 reg = jit_get_reg(jit_class_gpr);
1997 orr(r0, r1, rn(reg));
2003 _xori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2009 reg = jit_get_reg(jit_class_gpr);
2011 xorr(r0, r1, rn(reg));
2017 _extr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2019 lshi(r0, r1, __WORDSIZE - 8);
2020 rshi(r0, r0, __WORDSIZE - 8);
2024 _extr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2026 lshi(r0, r1, __WORDSIZE - 16);
2027 rshi(r0, r0, __WORDSIZE - 16);
2031 _extr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2033 lshi(r0, r1, __WORDSIZE - 16);
2034 rshi_u(r0, r0, __WORDSIZE - 16);
2037 #if __WORDSIZE == 64
2039 _extr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2041 lshi(r0, r1, __WORDSIZE - 32);
2042 rshi(r0, r0, __WORDSIZE - 32);
2046 _extr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2048 lshi(r0, r1, __WORDSIZE - 32);
2049 rshi_u(r0, r0, __WORDSIZE - 32);
2054 _cr(jit_state_t *_jit, jit_int32_t cc,
2055 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2058 # if __WORDSIZE == 32
2068 _cw(jit_state_t *_jit, jit_int32_t cc,
2069 jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2074 # if __WORDSIZE == 32
2083 reg = jit_get_reg(jit_class_gpr);
2085 cr(cc, r0, r1, rn(reg));
2091 _ldi_c(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2097 reg = jit_get_reg(jit_class_gpr);
2105 _ldi_uc(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2111 reg = jit_get_reg(jit_class_gpr);
2113 ldr_uc(r0, rn(reg));
2119 _ldi_s(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2125 reg = jit_get_reg(jit_class_gpr);
2133 _ldi_us(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2139 reg = jit_get_reg(jit_class_gpr);
2141 ldr_us(r0, rn(reg));
2147 _ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2151 # if __WORDSIZE == 32
2158 reg = jit_get_reg(jit_class_gpr);
2165 # if __WORDSIZE == 64
2167 _ldi_ui(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2173 reg = jit_get_reg(jit_class_gpr);
2175 ldr_ui(r0, rn(reg));
2181 _ldi_l(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2187 reg = jit_get_reg(jit_class_gpr);
2196 _ldxi_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2202 reg = jit_get_reg(jit_class_gpr);
2204 ldxr_c(r0, r1, rn(reg));
2210 _ldxi_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2216 reg = jit_get_reg(jit_class_gpr);
2218 ldxr_uc(r0, r1, rn(reg));
2224 _ldxi_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2230 reg = jit_get_reg(jit_class_gpr);
2232 ldxr_s(r0, r1, rn(reg));
2238 _ldxi_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2244 reg = jit_get_reg(jit_class_gpr);
2246 ldxr_us(r0, r1, rn(reg));
2252 _ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2256 # if __WORDSIZE == 32
2263 reg = jit_get_reg(jit_class_gpr);
2265 ldxr_i(r0, r1, rn(reg));
2270 # if __WORDSIZE == 64
2272 _ldxi_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2278 reg = jit_get_reg(jit_class_gpr);
2280 ldxr_ui(r0, r1, rn(reg));
2286 _ldxi_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2292 reg = jit_get_reg(jit_class_gpr);
2294 ldxr_l(r0, r1, rn(reg));
2301 _sti_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2307 reg = jit_get_reg(jit_class_gpr);
2315 _sti_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2321 reg = jit_get_reg(jit_class_gpr);
2329 _sti_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2333 # if __WORDSIZE == 32
2340 reg = jit_get_reg(jit_class_gpr);
2347 # if __WORDSIZE == 64
2349 _sti_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2355 reg = jit_get_reg(jit_class_gpr);
2364 _stxi_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2370 reg = jit_get_reg(jit_class_gpr);
2372 stxr_c(r0, rn(reg), r1);
2378 _stxi_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2384 reg = jit_get_reg(jit_class_gpr);
2386 stxr_s(r0, rn(reg), r1);
2392 _stxi_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2396 # if __WORDSIZE == 32
2403 reg = jit_get_reg(jit_class_gpr);
2405 stxr_i(r0, rn(reg), r1);
2410 # if __WORDSIZE == 64
2412 _stxi_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2418 reg = jit_get_reg(jit_class_gpr);
2420 stxr_l(r0, rn(reg), r1);
2427 _br(jit_state_t *_jit, jit_int32_t cc,
2428 jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2433 # if __WORDSIZE == 32
2434 B(cc, (i0 - w) >> 2);
2436 BP(cc, (i0 - w) >> 2);
2443 _bw(jit_state_t *_jit, jit_int32_t cc,
2444 jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2451 # if __WORDSIZE == 32
2452 B(cc, (i0 - w) >> 2);
2454 BP(cc, (i0 - w) >> 2);
2459 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2461 w = br(cc, i0, r0, rn(reg));
2468 _b_asr(jit_state_t *_jit, jit_bool_t jif, jit_bool_t add, jit_bool_t sgn,
2469 jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2477 # if __WORDSIZE == 32
2479 (jif ? SPARC_BVS : SPARC_BVC) :
2480 (jif ? SPARC_BCS : SPARC_BCC),
2484 (jif ? SPARC_BPVS : SPARC_BPVC) :
2485 (jif ? SPARC_BPCS : SPARC_BPCC),
2493 _b_asw(jit_state_t *_jit, jit_bool_t jif, jit_bool_t add, jit_bool_t sgn,
2494 jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2504 # if __WORDSIZE == 32
2506 (jif ? SPARC_BVS : SPARC_BVC) :
2507 (jif ? SPARC_BCS : SPARC_BCC),
2511 (jif ? SPARC_BPVS : SPARC_BPVC) :
2512 (jif ? SPARC_BPCS : SPARC_BPCC),
2518 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2520 w = b_asr(jif, add, sgn, i0, r0, rn(reg));
2527 _bm_r(jit_state_t *_jit, jit_bool_t set,
2528 jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2533 # if __WORDSIZE == 32
2534 B(set ? SPARC_BNZ : SPARC_BZ, (i0 - w) >> 2);
2536 BP(set ? SPARC_BPNE : SPARC_BPE, (i0 - w) >> 2);
2543 _bm_w(jit_state_t *_jit, jit_bool_t set,
2544 jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2551 # if __WORDSIZE == 32
2552 B(set ? SPARC_BNZ : SPARC_BZ, (i0 - w) >> 2);
2554 BP(set ? SPARC_BPNE : SPARC_BPE, (i0 - w) >> 2);
2559 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2561 w = bm_r(set, i0, r0, rn(reg));
2568 _jmpr(jit_state_t *_jit, jit_int32_t r0)
2575 _jmpi(jit_state_t *_jit, jit_word_t i0)
2586 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2595 _jmpi_p(jit_state_t *_jit, jit_word_t i0)
2599 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2600 w = movi_p(rn(reg), i0);
2607 _callr(jit_state_t *_jit, jit_int32_t r0)
2614 _calli(jit_state_t *_jit, jit_word_t i0)
2629 _calli_p(jit_state_t *_jit, jit_word_t i0)
2633 reg = jit_get_reg(jit_class_gpr);
2634 w = movi_p(rn(reg), i0);
2640 #define OFF(n) BIAS(((n) * sizeof(jit_word_t)))
2642 _prolog(jit_state_t *_jit, jit_node_t *node)
2645 if (_jitc->function->define_frame || _jitc->function->assume_frame) {
2646 jit_int32_t frame = -_jitc->function->frame;
2647 assert(_jitc->function->self.aoff >= frame);
2648 if (_jitc->function->assume_frame)
2650 _jitc->function->self.aoff = frame;
2652 if (_jitc->function->allocar)
2653 _jitc->function->self.aoff &= -16;
2654 /* align at 16 bytes boundary */
2655 _jitc->function->stack = ((stack_framesize +
2656 _jitc->function->self.alen -
2657 _jitc->function->self.aoff) + 15) & -16;
2658 SAVEI(_SP_REGNO, -_jitc->function->stack, _SP_REGNO);
2660 /* (most) other backends do not save incoming arguments, so,
2661 * only save locals here */
2662 if (jit_regset_tstbit(&_jitc->function->regset, _L0))
2663 stxi(OFF(0), _SP_REGNO, _L0_REGNO);
2664 if (jit_regset_tstbit(&_jitc->function->regset, _L1))
2665 stxi(OFF(1), _SP_REGNO, _L1_REGNO);
2666 if (jit_regset_tstbit(&_jitc->function->regset, _L2))
2667 stxi(OFF(2), _SP_REGNO, _L2_REGNO);
2668 if (jit_regset_tstbit(&_jitc->function->regset, _L3))
2669 stxi(OFF(3), _SP_REGNO, _L3_REGNO);
2670 if (jit_regset_tstbit(&_jitc->function->regset, _L4))
2671 stxi(OFF(4), _SP_REGNO, _L4_REGNO);
2672 if (jit_regset_tstbit(&_jitc->function->regset, _L5))
2673 stxi(OFF(5), _SP_REGNO, _L5_REGNO);
2674 if (jit_regset_tstbit(&_jitc->function->regset, _L6))
2675 stxi(OFF(6), _SP_REGNO, _L6_REGNO);
2676 if (jit_regset_tstbit(&_jitc->function->regset, _L7))
2677 stxi(OFF(7), _SP_REGNO, _L7_REGNO);
2679 if (_jitc->function->allocar) {
2680 reg = jit_get_reg(jit_class_gpr);
2681 movi(rn(reg), BIAS(_jitc->function->self.aoff));
2682 /* Already "biased" by allocai */
2683 stxi_i(_jitc->function->aoffoff, _FP_REGNO, rn(reg));
2687 if (_jitc->function->self.call & jit_call_varargs) {
2688 for (reg = _jitc->function->vagp; jit_arg_reg_p(reg); ++reg)
2689 stxi(BIAS((16 + (__WORDSIZE == 32)) * sizeof(jit_word_t) +
2690 reg * sizeof(jit_word_t)), _FP_REGNO, rn(_I0 + reg));
2695 _epilog(jit_state_t *_jit, jit_node_t *node)
2697 if (_jitc->function->assume_frame)
2699 if (_jitc->function->allocar)
2700 subi(_SP_REGNO, _FP_REGNO, _jitc->function->stack);
2701 if (jit_regset_tstbit(&_jitc->function->regset, _L0))
2702 ldxi(_L0_REGNO, _SP_REGNO, _jitc->function->stack + OFF(0));
2703 if (jit_regset_tstbit(&_jitc->function->regset, _L1))
2704 ldxi(_L1_REGNO, _SP_REGNO, _jitc->function->stack + OFF(1));
2705 if (jit_regset_tstbit(&_jitc->function->regset, _L2))
2706 ldxi(_L2_REGNO, _SP_REGNO, _jitc->function->stack + OFF(2));
2707 if (jit_regset_tstbit(&_jitc->function->regset, _L3))
2708 ldxi(_L3_REGNO, _SP_REGNO, _jitc->function->stack + OFF(3));
2709 if (jit_regset_tstbit(&_jitc->function->regset, _L4))
2710 ldxi(_L4_REGNO, _SP_REGNO, _jitc->function->stack + OFF(4));
2711 if (jit_regset_tstbit(&_jitc->function->regset, _L5))
2712 ldxi(_L5_REGNO, _SP_REGNO, _jitc->function->stack + OFF(5));
2713 if (jit_regset_tstbit(&_jitc->function->regset, _L6))
2714 ldxi(_L6_REGNO, _SP_REGNO, _jitc->function->stack + OFF(6));
2715 if (jit_regset_tstbit(&_jitc->function->regset, _L7))
2716 ldxi(_L7_REGNO, _SP_REGNO, _jitc->function->stack + OFF(7));
2723 _vastart(jit_state_t *_jit, jit_int32_t r0)
2725 /* Initialize stack pointer to the first stack argument. */
2726 if (jit_arg_reg_p(_jitc->function->vagp))
2727 addi(r0, _FP_REGNO, BIAS((16 + (__WORDSIZE == 32) +
2728 _jitc->function->vagp) *
2729 sizeof(jit_word_t)));
2731 addi(r0, _FP_REGNO, BIAS(_jitc->function->self.size));
2735 _vaarg(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2737 assert(_jitc->function->self.call & jit_call_varargs);
2739 /* Load argument. */
2742 /* Update vararg stack pointer. */
2743 addi(r1, r1, sizeof(jit_word_t));
2747 _patch_at(jit_state_t *_jit, jit_word_t instr, jit_word_t label)
2758 if (i.op.b == 0) { /* conditional branch */
2759 if (i.op2.b == 2 || i.op2.b == 6) { /* int or float condition */
2760 i.disp22.b = (label - instr) >> 2;
2763 # if __WORDSIZE == 64
2764 else if (i.op2.b == 1) {
2765 i.disp19.b = (label - instr) >> 2;
2769 else if (i.op2.b == 4) { /* movi_p */
2771 i.imm22.b = HI((int)label);
2774 if (i.op.b == 2 && i.op3.b == 2) {
2776 i.simm13.b = LO(label);
2778 # if __WORDSIZE == 64
2780 assert(i.op2.b == 4);
2781 label = (label >> 32) & 0xffffffff;
2782 i.imm22.b = HI((int)label);
2785 assert(i.op.b == 2 && i.op3.b == 2);
2787 i.simm13.b = LO(label);
2797 else if (i.op.b == 1) {
2798 assert(s30_p((label - instr) >> 2));
2799 i.disp30.b = (label - instr) >> 2;