2 * Copyright (C) 2012-2022 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
22 #if __BYTE_ORDER == __LITTLE_ENDIAN
23 struct { jit_uint32_t _:26; jit_uint32_t b : 6; } hc;
24 struct { jit_uint32_t _:21; jit_uint32_t b : 5; } rs;
25 struct { jit_uint32_t _:21; jit_uint32_t b : 5; } fm;
26 struct { jit_uint32_t _:16; jit_uint32_t b : 5; } rt;
27 struct { jit_uint32_t _:16; jit_uint32_t b : 5; } ft;
28 struct { jit_uint32_t _:11; jit_uint32_t b : 5; } rd;
29 struct { jit_uint32_t _:11; jit_uint32_t b : 5; } fs;
30 struct { jit_uint32_t _: 6; jit_uint32_t b : 5; } ic;
31 struct { jit_uint32_t _: 6; jit_uint32_t b : 5; } fd;
32 struct { jit_uint32_t _: 6; jit_uint32_t b : 10; } tr;
33 struct { jit_uint32_t _: 6; jit_uint32_t b : 20; } br;
34 struct { jit_uint32_t b : 6; } tc;
35 struct { jit_uint32_t b : 11; } cc;
36 struct { jit_uint32_t b : 16; } is;
37 struct { jit_uint32_t b : 26; } ii;
39 struct { jit_uint32_t b : 6; } hc;
40 struct { jit_uint32_t _: 6; jit_uint32_t b : 5; } rs;
41 struct { jit_uint32_t _: 6; jit_uint32_t b : 5; } fm;
42 struct { jit_uint32_t _:11; jit_uint32_t b : 5; } rt;
43 struct { jit_uint32_t _:11; jit_uint32_t b : 5; } ft;
44 struct { jit_uint32_t _:16; jit_uint32_t b : 5; } rd;
45 struct { jit_uint32_t _:16; jit_uint32_t b : 5; } fs;
46 struct { jit_uint32_t _:21; jit_uint32_t b : 5; } ic;
47 struct { jit_uint32_t _:21; jit_uint32_t b : 5; } fd;
48 struct { jit_uint32_t _:21; jit_uint32_t b : 10; } tr;
49 struct { jit_uint32_t _:21; jit_uint32_t b : 20; } br;
50 struct { jit_uint32_t _:26; jit_uint32_t b : 6; } tc;
51 struct { jit_uint32_t _:21; jit_uint32_t b : 11; } cc;
52 struct { jit_uint32_t _:16; jit_uint32_t b : 16; } is;
53 struct { jit_uint32_t _: 6; jit_uint32_t b : 26; } ii;
57 #if defined(_MIPS_ARCH_MIPS32R2) || defined(_MIPS_ARCH_MIPS64R2)
58 # define jit_mips2_p() 1
60 # define jit_mips2_p() 0
62 # define _ZERO_REGNO 0
63 # define _T0_REGNO 0x08
64 # define _T1_REGNO 0x09
65 # define _T2_REGNO 0x0a
66 # define _T3_REGNO 0x0b
67 # define _T4_REGNO 0x0c
68 # define _T5_REGNO 0x0d
69 # define _T6_REGNO 0x0e
70 # define _T7_REGNO 0x0f
71 # define _S0_REGNO 0x10
72 # define _S1_REGNO 0x11
73 # define _S2_REGNO 0x12
74 # define _S3_REGNO 0x13
75 # define _S4_REGNO 0x14
76 # define _S5_REGNO 0x15
77 # define _S6_REGNO 0x16
78 # define _S7_REGNO 0x17
79 # define _T8_REGNO 0x18
80 # define _T9_REGNO 0x19
81 # define _SP_REGNO 0x1d
82 # define _BP_REGNO 0x1e
83 # define _RA_REGNO 0x1f
84 # define _F16_REGNO 16
85 # define _F18_REGNO 18
86 # define _F20_REGNO 20
87 # define _F22_REGNO 22
88 # define _F24_REGNO 24
89 # define _F26_REGNO 26
90 # define _F28_REGNO 28
91 # define _F30_REGNO 30
94 # define stack_framesize 144
96 # define stack_framesize 112
98 # define ldr(u,v) ldr_i(u,v)
99 # define ldi(u,v) ldi_i(u,v)
100 # define ldxi(u,v,w) ldxi_i(u,v,w)
101 # define sti(u,v) sti_i(u,v)
102 # define stxi(u,v,w) stxi_i(u,v,w)
104 # define stack_framesize 144
105 # define ldr(u,v) ldr_l(u,v)
106 # define ldi(u,v) ldi_l(u,v)
107 # define ldxi(u,v,w) ldxi_l(u,v,w)
108 # define sti(u,v) sti_l(u,v)
109 # define stxi(u,v,w) stxi_l(u,v,w)
111 # define can_sign_extend_short_p(im) ((im) >= -32678 && (im) <= 32767)
112 # define can_zero_extend_short_p(im) ((im) >= 0 && (im) <= 65535)
113 # define is_low_mask(im) (((im) & 1) ? (__builtin_popcountl((im) + 1) <= 1) : 0)
114 # define is_middle_mask(im) ((im) ? (__builtin_popcountl((im) + (1 << __builtin_ctzl(im))) <= 1) : 0)
115 # define is_high_mask(im) ((im) ? (__builtin_popcountl((im) + (1 << __builtin_ctzl(im))) == 0) : 0)
116 # define masked_bits_count(im) __builtin_popcountl(im)
117 # define unmasked_bits_count(im) (__WORDSIZE - masked_bits_count(im))
118 # if __WORDSIZE == 32
119 # define can_sign_extend_int_p(im) 1
120 # define can_zero_extend_int_p(im) 1
122 # define can_sign_extend_int_p(im) \
123 (((im) >= 0 && (im) <= 0x7fffffffL) || \
124 ((im) < 0 && (im) >= -0x80000000L))
125 # define can_zero_extend_int_p(im) ((im) >= 0 && (im) <= 0xffffffff)
127 # define MIPS_SPECIAL 0x00
128 # define MIPS_REGIMM 0x01
130 # define MIPS_SRL 0x02
131 # define MIPS_JAL 0x03
132 # define MIPS_SRA 0x03
133 # define MIPS_BEQ 0x04
134 # define MIPS_BNE 0x05
135 # define MIPS_BLEZ 0x06
136 # define MIPS_BGTZ 0x07
137 # define MIPS_ADDI 0x08
138 # define MIPS_ADDIU 0x09
139 # define MIPS_SLTI 0x0a
140 # define MIPS_SLTIU 0x0b
141 # define MIPS_ANDI 0x0c
142 # define MIPS_ORI 0x0d
143 # define MIPS_XORI 0x0e
144 # define MIPS_LUI 0x0f
145 # define MIPS_COP0 0x10
146 # define MIPS_COP1 0x11
147 # define MIPS_COP2 0x12
148 # define MIPS_COP1X 0x13
149 # define MIPS_BEQL 0x14
150 # define MIPS_BNEL 0x15
151 # define MIPS_BLEZL 0x16
152 # define MIPS_BGTZL 0x17
153 # define MIPS_DADDI 0x18
154 # define MIPS_DADDIU 0x19
155 # define MIPS_LDL 0x1a
156 # define MIPS_LDR 0x1b
157 # define MIPS_SPECIAL2 0x1c
158 # define MIPS_JALX 0x1d
159 # define MIPS_SPECIAL3 0x1f
160 # define MIPS_LB 0x20
161 # define MIPS_LH 0x21
162 # define MIPS_LWL 0x22
163 # define MIPS_LW 0x23
164 # define MIPS_LBU 0x24
165 # define MIPS_LHU 0x25
166 # define MIPS_LWR 0x26
167 # define MIPS_LWU 0x27
168 # define MIPS_SB 0x28
169 # define MIPS_SH 0x29
170 # define MIPS_SWL 0x2a
171 # define MIPS_SW 0x2b
172 # define MIPS_SWR 0x2e
173 # define MIPS_CACHE 0x2f
174 # define MIPS_LL 0x30
175 # define MIPS_LWC1 0x31
176 # define MIPS_LWC2 0x32
177 # define MIPS_PREF 0x33
178 # define MIPS_LLD 0x34
179 # define MIPS_LDC1 0x35
180 # define MIPS_LDC2 0x36
181 # define MIPS_LD 0x37
182 # define MIPS_SC 0x38
183 # define MIPS_SCD 0x3c
184 # define MIPS_SDC1 0x3d
185 # define MIPS_SDC2 0x3e
186 # define MIPS_SWC1 0x39
187 # define MIPS_SWC2 0x3a
188 # define MIPS_SD 0x3f
189 # define MIPS_MF 0x00
190 # define MIPS_DMF 0x01
191 # define MIPS_CF 0x02
192 # define MIPS_MFH 0x03
193 # define MIPS_MT 0x04
194 # define MIPS_DMT 0x05
195 # define MIPS_CT 0x06
196 # define MIPS_MTH 0x07
197 # define MIPS_BC 0x08
198 # define MIPS_WRPGPR 0x0e
199 # define MIPS_BGZAL 0x11
200 # define MIPS_MFMC0 0x11
201 # define MIPS_BCF 0x00
202 # define MIPS_BLTZ 0x00
203 # define MIPS_BCT 0x01
204 # define MIPS_BGEZ 0x01
205 # define MIPS_BCFL 0x02
206 # define MIPS_BLTZL 0x02
207 # define MIPS_BCTL 0x03
208 # define MIPS_BGEZL 0x03
209 # define MIPS_TGEI 0x08
210 # define MIPS_TGEIU 0x09
211 # define MIPS_TLTI 0x0a
212 # define MIPS_TLTIU 0x0b
213 # define MIPS_TEQI 0x0c
214 # define MIPS_TNEI 0x0e
215 # define MIPS_BLTZAL 0x10
216 # define MIPS_BGEZAL 0x11
217 # define MIPS_BLTZALL 0x12
218 # define MIPS_BGEZALL 0x13
219 # define MIPS_SYNCI 0x1f
220 # define MIPS_WSBH 0x02
221 # define MIPS_DBSH 0x02
222 # define MIPS_DSHD 0x05
223 # define MIPS_SEB 0x10
224 # define MIPS_SEH 0x18
225 # define MIPS_MADD 0x00
226 # define MIPS_SLL 0x00
227 # define MIPS_EXT 0x00
228 # define MIPS_DEXTM 0x01
229 # define MIPS_MADDU 0x01
230 # define MIPS_MOVFT 0x01
231 # define MIPS_TLBR 0x01
232 # define MIPS_MUL 0x02
233 # define MIPS_DEXTU 0x02
234 # define MIPS_TLBWI 0x02
235 # define MIPS_DEXT 0x03
236 # define MIPS_SLLV 0x04
237 # define MIPS_INS 0x04
238 # define MIPS_MSUB 0x04
239 # define MIPS_DINSM 0x05
240 # define MIPS_MSUBU 0x05
241 # define MIPS_SRLV 0x06
242 # define MIPS_DINSU 0x06
243 # define MIPS_TLBWR 0x06
244 # define MIPS_SRAV 0x07
245 # define MIPS_DINS 0x07
246 # define MIPS_JR 0x08
247 # define MIPS_TLBP 0x08
248 # define MIPS_JALR 0x09
249 # define MIPS_MOVZ 0x0a
250 # define MIPS_MOVN 0x0b
251 # define MIPS_SYSCALL 0x0c
252 # define MIPS_BREAK 0x0d
253 # define MIPS_PREFX 0x0f
254 # define MIPS_SYNC 0x0f
255 # define MIPS_MFHI 0x10
256 # define MIPS_MTHI 0x11
257 # define MIPS_MFLO 0x12
258 # define MIPS_MTLO 0x13
259 # define MIPS_DSLLV 0x14
260 # define MIPS_DSRLV 0x16
261 # define MIPS_DSRAV 0x17
262 # define MIPS_MULT 0x18
263 # define MIPS_ERET 0x18
264 # define MIPS_MULTU 0x19
265 # define MIPS_DIV 0x1a
266 # define MIPS_DIVU 0x1b
267 # define MIPS_DMULT 0x1c
268 # define MIPS_DMULTU 0x1d
269 # define MIPS_DDIV 0x1e
270 # define MIPS_DDIVU 0x1f
271 # define MIPS_DERET 0x1f
272 # define MIPS_ADD 0x20
273 # define MIPS_CLZ 0x20
274 # define MIPS_BSHFL 0x20
275 # define MIPS_ADDU 0x21
276 # define MIPS_CLO 0x21
277 # define MIPS_SUB 0x22
278 # define MIPS_SUBU 0x23
279 # define MIPS_AND 0x24
280 # define MIPS_DCLZ 0x24
281 # define MIPS_DBSHFL 0x24
282 # define MIPS_OR 0x25
283 # define MIPS_DCLO 0x25
284 # define MIPS_XOR 0x26
285 # define MIPS_NOR 0x27
286 # define MIPS_SLT 0x2a
287 # define MIPS_SLTU 0x2b
288 # define MIPS_DADD 0x2c
289 # define MIPS_DADDU 0x2d
290 # define MIPS_DSUB 0x2e
291 # define MIPS_DSUBU 0x2f
292 # define MIPS_TGE 0x30
293 # define MIPS_TGEU 0x31
294 # define MIPS_TLT 0x32
295 # define MIPS_TLTU 0x33
296 # define MIPS_TEQ 0x34
297 # define MIPS_TNE 0x36
298 # define MIPS_DSLL 0x38
299 # define MIPS_DSRL 0x3a
300 # define MIPS_DSRA 0x3b
301 # define MIPS_DSLL32 0x3c
302 # define MIPS_DSRL32 0x3e
303 # define MIPS_DSRA32 0x3f
304 # define MIPS_SDBPP 0x3f
305 # define ii(i) *_jit->pc.ui++ = i
307 _hrrrit(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
308 jit_int32_t,jit_int32_t);
309 # define hrrrit(hc,rs,rt,rd,im,tc) _hrrrit(_jit,hc,rs,rt,rd,im,tc)
310 # define hrrr_t(hc,rs,rt,rd,tc) hrrrit(hc,rs,rt,rd,0,tc)
311 # define rrr_t(rs,rt,rd,tc) hrrr_t(0,rs,rt,rd,tc)
312 # define hrri(hc,rs,rt,im) _hrri(_jit,hc,rs,rt,im)
313 static void _hrri(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
314 # define hi(hc,im) _hi(_jit,hc,im)
315 static void _hi(jit_state_t*,jit_int32_t,jit_int32_t);
316 # define NOP(i0) ii(0)
317 # define nop(i0) _nop(_jit,i0)
318 static void _nop(jit_state_t*,jit_int32_t);
319 # define h_ri(hc,rt,im) _hrri(_jit,hc,0,rt,im)
320 # define rrit(rt,rd,im,tc) _hrrrit(_jit,0,0,rt,rd,im,tc)
321 # define LUI(rt,im) h_ri(MIPS_LUI,rt,im)
322 # define ADDU(rd,rs,rt) rrr_t(rs,rt,rd,MIPS_ADDU)
323 # define DADDU(rd,rs,rt) rrr_t(rs,rt,rd,MIPS_DADDU)
324 # define ADDIU(rt,rs,im) hrri(MIPS_ADDIU,rs,rt,im)
325 # define DADDIU(rt,rs,im) hrri(MIPS_DADDIU,rs,rt,im)
326 # define SUBU(rd,rs,rt) rrr_t(rs,rt,rd,MIPS_SUBU)
327 # define DSUBU(rd,rs,rt) rrr_t(rs,rt,rd,MIPS_DSUBU)
328 # define MUL(rd,rs,rt) hrrr_t(MIPS_SPECIAL2,rs,rt,rd,MIPS_MUL)
329 # define MULT(rs,rt) rrr_t(rs,rt,_ZERO_REGNO,MIPS_MULT)
330 # define MULTU(rs,rt) rrr_t(rs,rt,_ZERO_REGNO,MIPS_MULTU)
331 # define DMULT(rs,rt) rrr_t(rs,rt,_ZERO_REGNO,MIPS_DMULT)
332 # define DMULTU(rs,rt) rrr_t(rs,rt,_ZERO_REGNO,MIPS_DMULTU)
333 # define DIV(rs,rt) rrr_t(rs,rt,_ZERO_REGNO,MIPS_DIV)
334 # define DIVU(rs,rt) rrr_t(rs,rt,_ZERO_REGNO,MIPS_DIVU)
335 # define DDIV(rs,rt) rrr_t(rs,rt,_ZERO_REGNO,MIPS_DDIV)
336 # define DDIVU(rs,rt) rrr_t(rs,rt,_ZERO_REGNO,MIPS_DDIVU)
337 # define SLLV(rd,rt,rs) rrr_t(rs,rt,rd,MIPS_SLLV)
338 # define SLL(rd,rt,sa) rrit(rt,rd,sa,MIPS_SLL)
339 # define DSLLV(rd,rt,rs) rrr_t(rs,rt,rd,MIPS_DSLLV)
340 # define DSLL(rd,rt,sa) rrit(rt,rd,sa,MIPS_DSLL)
341 # define DSLL32(rd,rt,sa) rrit(rt,rd,sa,MIPS_DSLL32)
342 # define SRAV(rd,rt,rs) rrr_t(rs,rt,rd,MIPS_SRAV)
343 # define SRA(rd,rt,sa) rrit(rt,rd,sa,MIPS_SRA)
344 # define SRLV(rd,rt,rs) rrr_t(rs,rt,rd,MIPS_SRLV)
345 # define SRL(rd,rt,sa) rrit(rt,rd,sa,MIPS_SRL)
346 # define DSRAV(rd,rt,rs) rrr_t(rs,rt,rd,MIPS_DSRAV)
347 # define DSRA(rd,rt,sa) rrit(rt,rd,sa,MIPS_DSRA)
348 # define DSRA32(rd,rt,sa) rrit(rt,rd,sa,MIPS_DSRA32)
349 # define DSRLV(rd,rt,rs) rrr_t(rs,rt,rd,MIPS_DSRLV)
350 # define DSRL(rd,rt,sa) rrit(rt,rd,sa,MIPS_DSRL)
351 # define DSRL32(rd,rt,sa) rrit(rt,rd,sa,MIPS_DSRL32)
352 # define INS(rt,rs,pos,size) hrrrit(MIPS_SPECIAL3,rs,rt,pos+size-1,pos,MIPS_INS)
353 # define DINS(rt,rs,pos,size) hrrrit(MIPS_SPECIAL3,rs,rt,pos+size-1,pos,MIPS_DINS)
354 # define DINSU(rt,rs,pos,size) hrrrit(MIPS_SPECIAL3,rs,rt,pos+size-32-1,pos-32,MIPS_DINSU)
355 # define DINSM(rt,rs,pos,size) hrrrit(MIPS_SPECIAL3,rs,rt,pos+size-32-1,pos,MIPS_DINSM)
356 # define EXT(rt,rs,pos,size) hrrrit(MIPS_SPECIAL3,rs,rt,size-1,pos,MIPS_EXT)
357 # define DEXT(rt,rs,pos,size) hrrrit(MIPS_SPECIAL3,rs,rt,size-1,pos,MIPS_DEXT)
358 # define DEXTU(rt,rs,pos,size) hrrrit(MIPS_SPECIAL3,rs,rt,size-1,pos-32,MIPS_DEXTU)
359 # define DEXTM(rt,rs,pos,size) hrrrit(MIPS_SPECIAL3,rs,rt,size-32-1,pos,MIPS_DEXTM)
360 # define ROTR(rd,rt,sa) hrrrit(MIPS_SPECIAL,1,rt,rd,sa,MIPS_SRL)
361 # define DROTR(rd,rt,sa) hrrrit(MIPS_SPECIAL,1,rt,rd,sa,MIPS_DSRL)
362 # define SYNC() rrr_t(_ZERO_REGNO,_ZERO_REGNO,_ZERO_REGNO,MIPS_SYNC)
363 # define MFHI(rd) rrr_t(_ZERO_REGNO,_ZERO_REGNO,rd,MIPS_MFHI)
364 # define MFLO(rd) rrr_t(_ZERO_REGNO,_ZERO_REGNO,rd,MIPS_MFLO)
365 # define MTHI(rs) rrr_t(rs,_ZERO_REGNO,_ZERO_REGNO,MIPS_MTHI)
366 # define MTLO(rs) rrr_t(rs,_ZERO_REGNO,_ZERO_REGNO,MIPS_MTLO)
367 # define AND(rd,rs,rt) rrr_t(rs,rt,rd,MIPS_AND)
368 # define ANDI(rt,rs,im) hrri(MIPS_ANDI,rs,rt,im)
369 # define OR(rd,rs,rt) rrr_t(rs,rt,rd,MIPS_OR)
370 # define ORI(rt,rs,im) hrri(MIPS_ORI,rs,rt,im)
371 # define XOR(rd,rs,rt) rrr_t(rs,rt,rd,MIPS_XOR)
372 # define XORI(rt,rs,im) hrri(MIPS_XORI,rs,rt,im)
373 # define LB(rt,of,rb) hrri(MIPS_LB,rb,rt,of)
374 # define LBU(rt,of,rb) hrri(MIPS_LBU,rb,rt,of)
375 # define LH(rt,of,rb) hrri(MIPS_LH,rb,rt,of)
376 # define LHU(rt,of,rb) hrri(MIPS_LHU,rb,rt,of)
377 # define LW(rt,of,rb) hrri(MIPS_LW,rb,rt,of)
378 # define LWU(rt,of,rb) hrri(MIPS_LWU,rb,rt,of)
379 # define LD(rt,of,rb) hrri(MIPS_LD,rb,rt,of)
380 # define LL(rt,of,rb) hrri(MIPS_LL,rb,rt,of)
381 # define LLD(rt,of,rb) hrri(MIPS_LLD,rb,rt,of)
382 # define SB(rt,of,rb) hrri(MIPS_SB,rb,rt,of)
383 # define SH(rt,of,rb) hrri(MIPS_SH,rb,rt,of)
384 # define SW(rt,of,rb) hrri(MIPS_SW,rb,rt,of)
385 # define SD(rt,of,rb) hrri(MIPS_SD,rb,rt,of)
386 # define SC(rt,of,rb) hrri(MIPS_SC,rb,rt,of)
387 # define SCD(rt,of,rb) hrri(MIPS_SCD,rb,rt,of)
388 # define WSBH(rd,rt) hrrrit(MIPS_SPECIAL3,0,rt,rd,MIPS_WSBH,MIPS_BSHFL)
389 # define SEB(rd,rt) hrrrit(MIPS_SPECIAL3,0,rt,rd,MIPS_SEB,MIPS_BSHFL)
390 # define SEH(rd,rt) hrrrit(MIPS_SPECIAL3,0,rt,rd,MIPS_SEH,MIPS_BSHFL)
391 # define SLT(rd,rs,rt) rrr_t(rs,rt,rd,MIPS_SLT)
392 # define SLTU(rd,rs,rt) rrr_t(rs,rt,rd,MIPS_SLTU)
393 # define SLTI(rt,rs,im) hrri(MIPS_SLTI,rs,rt,im)
394 # define SLTIU(rt,rs,im) hrri(MIPS_SLTIU,rs,rt,im)
395 # define BLTZ(rs,im) hrri(MIPS_REGIMM,rs,MIPS_BLTZ,im)
396 # define BLEZ(rs,im) hrri(MIPS_BLEZ,rs,_ZERO_REGNO,im)
397 # define BEQ(rs,rt,im) hrri(MIPS_BEQ,rs,rt,im)
398 # define BGEZ(rs,im) hrri(MIPS_REGIMM,rs,MIPS_BGEZ,im)
399 # define BGTZ(rs,im) hrri(MIPS_BGTZ,rs,_ZERO_REGNO,im)
400 # define BNE(rs,rt,im) hrri(MIPS_BNE,rs,rt,im)
401 # define JALR(r0) hrrrit(MIPS_SPECIAL,r0,0,_RA_REGNO,0,MIPS_JALR)
402 # if 1 /* supports MIPS32 R6 */
403 # define JR(r0) hrrrit(MIPS_SPECIAL,r0,0,0,0,MIPS_JALR)
404 # else /* does not support MIPS32 R6 */
405 # define JR(r0) hrrrit(MIPS_SPECIAL,r0,0,0,0,MIPS_JR)
407 # define J(i0) hi(MIPS_J,i0)
408 # define JAL(i0) hi(MIPS_JAL,i0)
409 # define MOVN(rd,rs,rt) hrrrit(0,rs,rt,rd,0,MIPS_MOVN)
410 # define MOVZ(rd,rs,rt) hrrrit(0,rs,rt,rd,0,MIPS_MOVZ)
411 # define comr(r0,r1) xori(r0,r1,-1)
412 # define negr(r0,r1) subr(r0,_ZERO_REGNO,r1)
413 # if __WORDSIZE == 32
414 # define addr(rd,rs,rt) ADDU(rd,rs,rt)
415 # define addiu(r0,r1,i0) ADDIU(r0,r1,i0)
416 # define subr(rd,rs,rt) SUBU(rd,rs,rt)
417 # define mult(rs,rt) MULT(rs,rt)
418 # define multu(rs,rt) MULTU(rs,rt)
419 # define div(rs,rt) DIV(rs,rt)
420 # define divu(rs,rt) DIVU(rs,rt)
422 # define addr(rd,rs,rt) DADDU(rd,rs,rt)
423 # define addiu(r0,r1,i0) DADDIU(r0,r1,i0)
424 # define subr(rd,rs,rt) DSUBU(rd,rs,rt)
425 # define mult(rs,rt) DMULT(rs,rt)
426 # define multu(rs,rt) DMULTU(rs,rt)
427 # define div(rs,rt) DDIV(rs,rt)
428 # define divu(rs,rt) DDIVU(rs,rt)
430 # define extr(rd,rt,lsb,nb) _extr(_jit,rd,rt,lsb,nb)
431 static void _extr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
432 # define insr(rd,rt,lsb,nb) _insr(_jit,rd,rt,lsb,nb)
433 static void _insr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
434 # define addi(r0,r1,i0) _addi(_jit,r0,r1,i0)
435 static void _addi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
436 #define addcr(r0,r1,r2) _addcr(_jit,r0,r1,r2)
437 static void _addcr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
438 #define addci(r0,r1,i0) _addci(_jit,r0,r1,i0)
439 static void _addci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
440 # define addxr(r0,r1,r2) _addxr(_jit,r0,r1,r2)
441 static void _addxr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
442 # define addxi(r0,r1,i0) _addxi(_jit,r0,r1,i0)
443 static void _addxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
444 # define subi(r0,r1,i0) _subi(_jit,r0,r1,i0)
445 static void _subi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
446 # define subcr(r0,r1,r2) _subcr(_jit,r0,r1,r2)
447 static void _subcr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
448 # define subci(r0,r1,i0) _subci(_jit,r0,r1,i0)
449 static void _subci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
450 # define subxr(r0,r1,r2) _subxr(_jit,r0,r1,r2)
451 static void _subxr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
452 # define subxi(r0,r1,i0) _subxi(_jit,r0,r1,i0)
453 static void _subxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
454 # define rsbi(r0, r1, i0) _rsbi(_jit, r0, r1, i0)
455 static void _rsbi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
456 # define mulr(r0,r1,r2) _mulr(_jit,r0,r1,r2)
457 static void _mulr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
458 # define muli(r0,r1,i0) _muli(_jit,r0,r1,i0)
459 static void _muli(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
460 # define qmulr(r0,r1,r2,r3) iqmulr(r0,r1,r2,r3,1)
461 # define qmulr_u(r0,r1,r2,r3) iqmulr(r0,r1,r2,r3,0)
462 # define iqmulr(r0,r1,r2,r3,cc) _iqmulr(_jit,r0,r1,r2,r3,cc)
463 static void _iqmulr(jit_state_t*,jit_int32_t,jit_int32_t,
464 jit_int32_t,jit_int32_t,jit_bool_t);
465 # define qmuli(r0,r1,r2,i0) iqmuli(r0,r1,r2,i0,1)
466 # define qmuli_u(r0,r1,r2,i0) iqmuli(r0,r1,r2,i0,0)
467 # define iqmuli(r0,r1,r2,i0,cc) _iqmuli(_jit,r0,r1,r2,i0,cc)
468 static void _iqmuli(jit_state_t*,jit_int32_t,jit_int32_t,
469 jit_int32_t,jit_word_t,jit_bool_t);
470 # define divr(r0,r1,r2) _divr(_jit,r0,r1,r2)
471 static void _divr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
472 # define divi(r0,r1,i0) _divi(_jit,r0,r1,i0)
473 static void _divi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
474 # define divr_u(r0,r1,r2) _divr_u(_jit,r0,r1,r2)
475 static void _divr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
476 # define divi_u(r0,r1,i0) _divi_u(_jit,r0,r1,i0)
477 static void _divi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
478 # define qdivr(r0,r1,r2,r3) iqdivr(r0,r1,r2,r3,1)
479 # define qdivr_u(r0,r1,r2,r3) iqdivr(r0,r1,r2,r3,0)
480 # define iqdivr(r0,r1,r2,r3,cc) _iqdivr(_jit,r0,r1,r2,r3,cc)
481 static void _iqdivr(jit_state_t*,jit_int32_t,jit_int32_t,
482 jit_int32_t,jit_int32_t,jit_bool_t);
483 # define qdivi(r0,r1,r2,i0) iqdivi(r0,r1,r2,i0,1)
484 # define qdivi_u(r0,r1,r2,i0) iqdivi(r0,r1,r2,i0,0)
485 # define iqdivi(r0,r1,r2,i0,cc) _iqdivi(_jit,r0,r1,r2,i0,cc)
486 static void _iqdivi(jit_state_t*,jit_int32_t,jit_int32_t,
487 jit_int32_t,jit_word_t,jit_bool_t);
488 # define remr(r0,r1,r2) _remr(_jit,r0,r1,r2)
489 static void _remr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
490 # define remi(r0,r1,i0) _remi(_jit,r0,r1,i0)
491 static void _remi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
492 # define remr_u(r0,r1,r2) _remr_u(_jit,r0,r1,r2)
493 static void _remr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
494 # define remi_u(r0,r1,i0) _remi_u(_jit,r0,r1,i0)
495 static void _remi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
496 # if __WORDSIZE == 32
497 # define lshr(r0,r1,r2) SLLV(r0,r1,r2)
498 # define lshi(r0,r1,i0) SLL(r0,r1,i0)
499 # define rshr(r0,r1,r2) SRAV(r0,r1,r2)
500 # define rshi(r0,r1,i0) SRA(r0,r1,i0)
501 # define rshr_u(r0,r1,r2) SRLV(r0,r1,r2)
502 # define rshi_u(r0,r1,i0) SRL(r0,r1,i0)
504 # define lshr(r0,r1,r2) DSLLV(r0,r1,r2)
505 # define lshi(r0,r1,i0) _lshi(_jit,r0,r1,i0)
506 static void _lshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
507 # define rshr(r0,r1,r2) DSRAV(r0,r1,r2)
508 # define rshi(r0,r1,i0) _rshi(_jit,r0,r1,i0)
509 static void _rshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
510 # define rshr_u(r0,r1,r2) DSRLV(r0,r1,r2)
511 # define rshi_u(r0,r1,i0) _rshi_u(_jit,r0,r1,i0)
512 static void _rshi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
514 # define andr(r0,r1,r2) AND(r0,r1,r2)
515 # define andi(r0,r1,i0) _andi(_jit,r0,r1,i0)
516 static void _andi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
517 # define orr(r0,r1,r2) OR(r0,r1,r2)
518 # define ori(r0,r1,i0) _ori(_jit,r0,r1,i0)
519 static void _ori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
520 # define xorr(r0,r1,r2) XOR(r0,r1,r2)
521 # define xori(r0,r1,i0) _xori(_jit,r0,r1,i0)
522 static void _xori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
523 # define movr(r0,r1) _movr(_jit,r0,r1)
524 static void _movr(jit_state_t*,jit_int32_t,jit_int32_t);
525 # define movi(r0,i0) _movi(_jit,r0,i0)
526 static void _movi(jit_state_t*,jit_int32_t,jit_word_t);
527 # define movi_p(r0,i0) _movi_p(_jit,r0,i0)
528 static jit_word_t _movi_p(jit_state_t*,jit_int32_t,jit_word_t);
529 # define movnr(r0,r1,r2) MOVN(r0, r1, r2)
530 # define movzr(r0,r1,r2) MOVZ(r0, r1, r2)
531 # define casx(r0, r1, r2, r3, i0) _casx(_jit, r0, r1, r2, r3, i0)
532 static void _casx(jit_state_t *_jit,jit_int32_t,jit_int32_t,
533 jit_int32_t,jit_int32_t,jit_word_t);
534 #define casr(r0, r1, r2, r3) casx(r0, r1, r2, r3, 0)
535 #define casi(r0, i0, r1, r2) casx(r0, _NOREG, r1, r2, i0)
536 # define ldr_c(r0,r1) LB(r0,0,r1)
537 # define ldi_c(r0,i0) _ldi_c(_jit,r0,i0)
538 static void _ldi_c(jit_state_t*,jit_int32_t,jit_word_t);
539 # define ldr_uc(r0,r1) LBU(r0,0,r1)
540 # define ldi_uc(r0,i0) _ldi_uc(_jit,r0,i0)
541 static void _ldi_uc(jit_state_t*,jit_int32_t,jit_word_t);
542 # define ldr_s(r0,r1) LH(r0,0,r1)
543 # define ldi_s(r0,i0) _ldi_s(_jit,r0,i0)
544 static void _ldi_s(jit_state_t*,jit_int32_t,jit_word_t);
545 # define ldr_us(r0,r1) LHU(r0,0,r1)
546 # define ldi_us(r0,i0) _ldi_us(_jit,r0,i0)
547 static void _ldi_us(jit_state_t*,jit_int32_t,jit_word_t);
548 # define ldr_i(r0,r1) LW(r0,0,r1)
549 # define ldi_i(r0,i0) _ldi_i(_jit,r0,i0)
550 static void _ldi_i(jit_state_t*,jit_int32_t,jit_word_t);
551 # if __WORDSIZE == 64
552 # define ldr_ui(r0,r1) LWU(r0,0,r1)
553 # define ldi_ui(r0,i0) _ldi_ui(_jit,r0,i0)
554 static void _ldi_ui(jit_state_t*,jit_int32_t,jit_word_t);
555 # define ldr_l(r0,r1) LD(r0,0,r1)
556 # define ldi_l(r0,i0) _ldi_l(_jit,r0,i0)
557 static void _ldi_l(jit_state_t*,jit_int32_t,jit_word_t);
559 # define ldxr_c(r0,r1,r2) _ldxr_c(_jit,r0,r1,r2)
560 static void _ldxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
561 # define ldxi_c(r0,r1,i0) _ldxi_c(_jit,r0,r1,i0)
562 static void _ldxi_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
563 # define ldxr_uc(r0,r1,r2) _ldxr_uc(_jit,r0,r1,r2)
564 static void _ldxr_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
565 # define ldxi_uc(r0,r1,i0) _ldxi_uc(_jit,r0,r1,i0)
566 static void _ldxi_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
567 # define ldxr_s(r0,r1,r2) _ldxr_s(_jit,r0,r1,r2)
568 static void _ldxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
569 # define ldxi_s(r0,r1,i0) _ldxi_s(_jit,r0,r1,i0)
570 static void _ldxi_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
571 # define ldxr_us(r0,r1,r2) _ldxr_us(_jit,r0,r1,r2)
572 static void _ldxr_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
573 # define ldxi_us(r0,r1,i0) _ldxi_us(_jit,r0,r1,i0)
574 static void _ldxi_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
575 # define ldxr_i(r0,r1,r2) _ldxr_i(_jit,r0,r1,r2)
576 static void _ldxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
577 # define ldxi_i(r0,r1,i0) _ldxi_i(_jit,r0,r1,i0)
578 static void _ldxi_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
579 # if __WORDSIZE == 64
580 # define ldxr_ui(r0,r1,r2) _ldxr_ui(_jit,r0,r1,r2)
581 static void _ldxr_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
582 # define ldxi_ui(r0,r1,i0) _ldxi_ui(_jit,r0,r1,i0)
583 static void _ldxi_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
584 # define ldxr_l(r0,r1,r2) _ldxr_l(_jit,r0,r1,r2)
585 static void _ldxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
586 # define ldxi_l(r0,r1,i0) _ldxi_l(_jit,r0,r1,i0)
587 static void _ldxi_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
589 # define str_c(r0,r1) SB(r1,0,r0)
590 # define sti_c(i0,r0) _sti_c(_jit,i0,r0)
591 static void _sti_c(jit_state_t*,jit_word_t,jit_int32_t);
592 # define str_s(r0,r1) SH(r1,0,r0)
593 # define sti_s(i0,r0) _sti_s(_jit,i0,r0)
594 static void _sti_s(jit_state_t*,jit_word_t,jit_int32_t);
595 # define str_i(r0,r1) SW(r1,0,r0)
596 # define sti_i(i0,r0) _sti_i(_jit,i0,r0)
597 static void _sti_i(jit_state_t*,jit_word_t,jit_int32_t);
598 # if __WORDSIZE == 64
599 # define str_l(r0,r1) SD(r1,0,r0)
600 # define sti_l(i0,r0) _sti_l(_jit,i0,r0)
601 static void _sti_l(jit_state_t*,jit_word_t,jit_int32_t);
603 # define stxr_c(r0,r1,r2) _stxr_c(_jit,r0,r1,r2)
604 static void _stxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
605 # define stxi_c(i0,r0,r1) _stxi_c(_jit,i0,r0,r1)
606 static void _stxi_c(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
607 # define stxr_s(r0,r1,r2) _stxr_s(_jit,r0,r1,r2)
608 static void _stxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
609 # define stxi_s(i0,r0,r1) _stxi_s(_jit,i0,r0,r1)
610 static void _stxi_s(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
611 # define stxr_i(r0,r1,r2) _stxr_i(_jit,r0,r1,r2)
612 static void _stxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
613 # define stxi_i(i0,r0,r1) _stxi_i(_jit,i0,r0,r1)
614 static void _stxi_i(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
615 # if __WORDSIZE == 64
616 # define stxr_l(r0,r1,r2) _stxr_l(_jit,r0,r1,r2)
617 static void _stxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
618 # define stxi_l(i0,r0,r1) _stxi_l(_jit,i0,r0,r1)
619 static void _stxi_l(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
621 # define bswapr_us(r0,r1) _bswapr_us(_jit,r0,r1)
622 static void _bswapr_us(jit_state_t*,jit_int32_t,jit_int32_t);
623 # define bswapr_ui(r0,r1) _bswapr_ui(_jit,r0,r1)
624 static void _bswapr_ui(jit_state_t*,jit_int32_t,jit_int32_t);
625 # if __WORDSIZE == 64
626 # define bswapr_ul(r0,r1) generic_bswapr_ul(_jit,r0,r1)
628 # define extr_c(r0,r1) _extr_c(_jit,r0,r1)
629 static void _extr_c(jit_state_t*,jit_int32_t,jit_int32_t);
630 # define extr_uc(r0,r1) ANDI(r0,r1,0xff)
631 # define extr_s(r0,r1) _extr_s(_jit,r0,r1)
632 static void _extr_s(jit_state_t*,jit_int32_t,jit_int32_t);
633 # define extr_us(r0,r1) ANDI(r0,r1,0xffff)
634 # if __WORDSIZE == 64
635 # define extr_i(r0,r1) SLL(r0,r1,0)
636 # define extr_ui(r0,r1) _extr_ui(_jit,r0,r1)
637 static void _extr_ui(jit_state_t*,jit_int32_t,jit_int32_t);
639 # define ltr(r0,r1,r2) SLT(r0,r1,r2)
640 # define lti(r0,r1,i0) _lti(_jit,r0,r1,i0)
641 static void _lti(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
642 # define ltr_u(r0,r1,r2) SLTU(r0,r1,r2)
643 # define lti_u(r0,r1,i0) _lti_u(_jit,r0,r1,i0)
644 static void _lti_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
645 #define ler(r0,r1,r2) _ler(_jit,r0,r1,r2)
646 static void _ler(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
647 #define lei(r0,r1,i0) _lei(_jit,r0,r1,i0)
648 static void _lei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
649 #define ler_u(r0,r1,r2) _ler_u(_jit,r0,r1,r2)
650 static void _ler_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
651 #define lei_u(r0,r1,i0) _lei_u(_jit,r0,r1,i0)
652 static void _lei_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
653 #define eqr(r0,r1,r2) _eqr(_jit,r0,r1,r2)
654 static void _eqr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
655 #define eqi(r0,r1,i0) _eqi(_jit,r0,r1,i0)
656 static void _eqi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
657 #define ger(r0,r1,r2) _ger(_jit,r0,r1,r2)
658 static void _ger(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
659 #define gei(r0,r1,i0) _gei(_jit,r0,r1,i0)
660 static void _gei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
661 #define ger_u(r0,r1,i0) _ger_u(_jit,r0,r1,i0)
662 static void _ger_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
663 #define gei_u(r0,r1,i0) _gei_u(_jit,r0,r1,i0)
664 static void _gei_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
665 # define gtr(r0,r1,r2) SLT(r0,r2,r1)
666 #define gti(r0,r1,i0) _gti(_jit,r0,r1,i0)
667 static void _gti(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
668 # define gtr_u(r0,r1,r2) SLTU(r0,r2,r1)
669 # define gti_u(r0,r1,i0) _gti_u(_jit,r0,r1,i0)
670 static void _gti_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
671 #define ner(r0,r1,r2) _ner(_jit,r0,r1,r2)
672 static void _ner(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
673 #define nei(r0,r1,i0) _nei(_jit,r0,r1,i0)
674 static void _nei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
675 #define bltr(i0,r0,r1) _bltr(_jit,i0,r0,r1)
676 static jit_word_t _bltr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
677 #define bltr_u(i0,r0,r1) _bltr_u(_jit,i0,r0,r1)
678 static jit_word_t _bltr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
679 #define blti(i0,r0,i1) _blti(_jit,i0,r0,i1)
680 static jit_word_t _blti(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
681 #define blti_u(i0,r0,i1) _blti_u(_jit,i0,r0,i1)
682 static jit_word_t _blti_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
683 #define bler(i0,r0,r1) _bler(_jit,i0,r0,r1)
684 static jit_word_t _bler(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
685 #define bler_u(i0,r0,r1) _bler_u(_jit,i0,r0,r1)
686 static jit_word_t _bler_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
687 #define blei(i0,r0,i1) _blei(_jit,i0,r0,i1)
688 static jit_word_t _blei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
689 #define blei_u(i0,r0,i1) _blei_u(_jit,i0,r0,i1)
690 static jit_word_t _blei_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
691 #define beqr(i0,r0,r1) _beqr(_jit,i0,r0,r1)
692 static jit_word_t _beqr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
693 #define beqi(i0,r0,i1) _beqi(_jit,i0,r0,i1)
694 static jit_word_t _beqi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
695 #define bger(i0,r0,r1) _bger(_jit,i0,r0,r1)
696 static jit_word_t _bger(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
697 #define bger_u(i0,r0,r1) _bger_u(_jit,i0,r0,r1)
698 static jit_word_t _bger_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
699 #define bgei(i0,r0,i1) _bgei(_jit,i0,r0,i1)
700 static jit_word_t _bgei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
701 #define bgei_u(i0,r0,i1) _bgei_u(_jit,i0,r0,i1)
702 static jit_word_t _bgei_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
703 #define bgtr(i0,r0,r1) _bgtr(_jit,i0,r0,r1)
704 static jit_word_t _bgtr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
705 #define bgtr_u(i0,r0,r1) _bgtr_u(_jit,i0,r0,r1)
706 static jit_word_t _bgtr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
707 #define bgti(i0,r0,i1) _bgti(_jit,i0,r0,i1)
708 static jit_word_t _bgti(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
709 #define bgti_u(i0,r0,i1) _bgti_u(_jit,i0,r0,i1)
710 static jit_word_t _bgti_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
711 #define bner(i0,r0,r1) _bner(_jit,i0,r0,r1)
712 static jit_word_t _bner(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
713 #define bnei(i0,r0,i1) _bnei(_jit,i0,r0,i1)
714 static jit_word_t _bnei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
715 # define jmpr(r0) _jmpr(_jit,r0)
716 static void _jmpr(jit_state_t*,jit_int32_t);
717 # define jmpi(i0) _jmpi(_jit,i0)
718 static jit_word_t _jmpi(jit_state_t*,jit_word_t);
719 # define boaddr(i0,r0,r1) _boaddr(_jit,i0,r0,r1)
720 static jit_word_t _boaddr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
721 # define boaddi(i0,r0,i1) _boaddi(_jit,i0,r0,i1)
722 static jit_word_t _boaddi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
723 # define boaddr_u(i0,r0,r1) _boaddr_u(_jit,i0,r0,r1)
724 static jit_word_t _boaddr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
725 # define boaddi_u(i0,r0,i1) _boaddi_u(_jit,i0,r0,i1)
726 static jit_word_t _boaddi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
727 # define bxaddr(i0,r0,r1) _bxaddr(_jit,i0,r0,r1)
728 static jit_word_t _bxaddr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
729 # define bxaddi(i0,r0,i1) _bxaddi(_jit,i0,r0,i1)
730 static jit_word_t _bxaddi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
731 # define bxaddr_u(i0,r0,r1) _bxaddr_u(_jit,i0,r0,r1)
732 static jit_word_t _bxaddr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
733 # define bxaddi_u(i0,r0,i1) _bxaddi_u(_jit,i0,r0,i1)
734 static jit_word_t _bxaddi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
735 # define bosubr(i0,r0,r1) _bosubr(_jit,i0,r0,r1)
736 static jit_word_t _bosubr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
737 # define bosubi(i0,r0,i1) _bosubi(_jit,i0,r0,i1)
738 static jit_word_t _bosubi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
739 # define bosubr_u(i0,r0,r1) _bosubr_u(_jit,i0,r0,r1)
740 static jit_word_t _bosubr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
741 # define bosubi_u(i0,r0,i1) _bosubi_u(_jit,i0,r0,i1)
742 static jit_word_t _bosubi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
743 # define bxsubr(i0,r0,r1) _bxsubr(_jit,i0,r0,r1)
744 static jit_word_t _bxsubr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
745 # define bxsubi(i0,r0,i1) _bxsubi(_jit,i0,r0,i1)
746 static jit_word_t _bxsubi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
747 # define bxsubr_u(i0,r0,r1) _bxsubr_u(_jit,i0,r0,r1)
748 static jit_word_t _bxsubr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
749 # define bxsubi_u(i0,r0,i1) _bxsubi_u(_jit,i0,r0,i1)
750 static jit_word_t _bxsubi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
751 # define bmsr(i0,r0,r1) _bmsr(_jit,i0,r0,r1)
752 static jit_word_t _bmsr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
753 # define bmsi(i0,r0,i1) _bmsi(_jit,i0,r0,i1)
754 static jit_word_t _bmsi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
755 # define bmcr(i0,r0,r1) _bmcr(_jit,i0,r0,r1)
756 static jit_word_t _bmcr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
757 # define bmci(i0,r0,i1) _bmci(_jit,i0,r0,i1)
758 static jit_word_t _bmci(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
759 # define callr(r0) _callr(_jit,r0)
760 static void _callr(jit_state_t*,jit_int32_t);
761 # define calli(i0) _calli(_jit,i0)
762 static void _calli(jit_state_t*,jit_word_t);
763 # define calli_p(i0) _calli_p(_jit,i0)
764 static jit_word_t _calli_p(jit_state_t*,jit_word_t);
765 # define prolog(node) _prolog(_jit,node)
766 static void _prolog(jit_state_t*,jit_node_t*);
767 # define epilog(node) _epilog(_jit,node)
768 static void _epilog(jit_state_t*,jit_node_t*);
769 # define vastart(r0) _vastart(_jit, r0)
770 static void _vastart(jit_state_t*, jit_int32_t);
771 # define vaarg(r0, r1) _vaarg(_jit, r0, r1)
772 static void _vaarg(jit_state_t*, jit_int32_t, jit_int32_t);
773 #define patch_abs(instr,label) _patch_abs(_jit,instr,label)
774 static void _patch_abs(jit_state_t*,jit_word_t,jit_word_t);
775 #define patch_at(jump,label) _patch_at(_jit,jump,label)
776 static void _patch_at(jit_state_t*,jit_word_t,jit_word_t);
781 _hrrrit(jit_state_t *_jit,jit_int32_t hc,
782 jit_int32_t rs, jit_int32_t rt, jit_int32_t rd,
783 jit_int32_t ic, jit_int32_t tc)
796 _hrri(jit_state_t *_jit, jit_int32_t hc,
797 jit_int32_t rs, jit_int32_t rt, jit_int32_t im)
809 _hi(jit_state_t *_jit, jit_int32_t hc, jit_int32_t im)
818 _nop(jit_state_t *_jit, jit_int32_t i0)
820 for (; i0 > 0; i0 -= 4)
826 _extr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
827 jit_int32_t pos, jit_int32_t size)
831 if (__WORDSIZE == 32)
832 EXT(r0, r1, pos, size);
834 DEXTU(r0, r1, pos, size);
836 DEXTM(r0, r1, pos, size);
838 DEXT(r0, r1, pos, size);
842 _insr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
843 jit_int32_t pos, jit_int32_t size)
847 if (__WORDSIZE == 32)
848 INS(r0, r1, pos, size);
850 DINSU(r0, r1, pos, size);
852 DINSM(r0, r1, pos, size);
854 DINS(r0, r1, pos, size);
858 _addi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
863 else if (can_sign_extend_short_p(i0))
866 reg = jit_get_reg(jit_class_gpr);
868 addr(r0, r1, rn(reg));
874 _addcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
878 if (jit_carry == _NOREG)
879 jit_carry = jit_get_reg(jit_class_gpr);
881 t0 = jit_get_reg(jit_class_gpr);
882 addr(rn(t0), r1, r2);
883 SLTU(rn(jit_carry), rn(t0), r1);
889 SLTU(rn(jit_carry), r0, r1);
894 _addci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
898 if (jit_carry == _NOREG)
899 jit_carry = jit_get_reg(jit_class_gpr);
900 t0 = jit_get_reg(jit_class_gpr);
902 if (can_sign_extend_short_p(i0))
903 addiu(rn(t0), r1, i0);
906 addr(rn(t0), r1, rn(t0));
908 SLTU(rn(jit_carry), rn(t0), r1);
912 if (can_sign_extend_short_p(i0))
916 addr(r0, r1, rn(t0));
918 SLTU(rn(jit_carry), r0, r1);
924 _addxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
928 assert(jit_carry != _NOREG);
929 t0 = jit_get_reg(jit_class_gpr);
930 movr(rn(t0), rn(jit_carry));
932 addcr(r0, r0, rn(t0));
937 _addxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
941 assert(jit_carry != _NOREG);
942 t0 = jit_get_reg(jit_class_gpr);
943 movr(rn(t0), rn(jit_carry));
945 addcr(r0, r0, rn(t0));
950 _subi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
955 else if (can_sign_extend_short_p(i0) && (i0 & 0xffff) != 0x8000)
958 reg = jit_get_reg(jit_class_gpr);
960 subr(r0, r1, rn(reg));
966 _subcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
970 if (jit_carry == _NOREG)
971 jit_carry = jit_get_reg(jit_class_gpr);
973 t0 = jit_get_reg(jit_class_gpr);
974 subr(rn(t0), r1, r2);
975 SLTU(rn(jit_carry), r1, rn(t0));
981 SLTU(rn(jit_carry), r1, r0);
986 _subci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
990 if (jit_carry == _NOREG)
991 jit_carry = jit_get_reg(jit_class_gpr);
992 t0 = jit_get_reg(jit_class_gpr);
994 if (can_sign_extend_short_p(i0) && (i0 & 0xffff) != 0x8000)
995 addiu(rn(t0), r1, -i0);
998 subr(rn(t0), r1, rn(t0));
1000 SLTU(rn(jit_carry), r1, rn(t0));
1004 if (can_sign_extend_short_p(i0) && (i0 & 0xffff) != 0x8000)
1008 subr(r0, r1, rn(t0));
1010 SLTU(rn(jit_carry), r1, r0);
1016 _subxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1020 assert(jit_carry != _NOREG);
1021 t0 = jit_get_reg(jit_class_gpr);
1022 movr(rn(t0), rn(jit_carry));
1024 subcr(r0, r0, rn(t0));
1029 _subxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1033 assert(jit_carry != _NOREG);
1034 t0 = jit_get_reg(jit_class_gpr);
1035 movr(rn(t0), rn(jit_carry));
1037 subcr(r0, r0, rn(t0));
1042 _rsbi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1049 _mulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1051 if (jit_mips2_p() && __WORDSIZE == 32)
1060 _muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1064 reg = jit_get_reg(jit_class_gpr);
1066 mulr(r0, r1, rn(reg));
1071 _iqmulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1072 jit_int32_t r2, jit_int32_t r3, jit_bool_t sign)
1083 _iqmuli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1084 jit_int32_t r2, jit_word_t i0, jit_bool_t sign)
1087 reg = jit_get_reg(jit_class_gpr);
1089 iqmulr(r0, r1, r2, rn(reg), sign);
1094 _divr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1101 _divi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1104 reg = jit_get_reg(jit_class_gpr);
1106 divr(r0, r1, rn(reg));
1111 _divr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1118 _divi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1121 reg = jit_get_reg(jit_class_gpr);
1123 divr_u(r0, r1, rn(reg));
1128 _iqdivr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1129 jit_int32_t r2, jit_int32_t r3, jit_bool_t sign)
1140 _iqdivi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1141 jit_int32_t r2, jit_word_t i0, jit_bool_t sign)
1144 reg = jit_get_reg(jit_class_gpr);
1146 iqdivr(r0, r1, r2, rn(reg), sign);
1151 _remr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1158 _remi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1161 reg = jit_get_reg(jit_class_gpr);
1163 remr(r0, r1, rn(reg));
1168 _remr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1175 _remi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1178 reg = jit_get_reg(jit_class_gpr);
1180 remr_u(r0, r1, rn(reg));
1184 #if __WORDSIZE == 64
1186 _lshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1188 assert(i0 >= 0 && i0 <= 63);
1192 DSLL32(r0, r1, i0 - 32);
1196 _rshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1198 assert(i0 >= 0 && i0 <= 63);
1202 DSRA32(r0, r1, i0 - 32);
1206 _rshi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1208 assert(i0 >= 0 && i0 <= 63);
1212 DSRL32(r0, r1, i0 - 32);
1217 _andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1220 if (can_zero_extend_short_p(i0))
1222 else if (is_low_mask(i0)) {
1224 extr(r0, r1, 0, masked_bits_count(i0));
1226 lshi(r0, r1, unmasked_bits_count(i0));
1227 rshi_u(r0, r0, unmasked_bits_count(i0));
1229 } else if (is_high_mask(i0)) {
1230 if (jit_mips2_p() && r0 == r1)
1231 insr(r0, _ZERO_REGNO, 0, unmasked_bits_count(i0));
1233 rshi(r0, r1, unmasked_bits_count(i0));
1234 lshi(r0, r0, unmasked_bits_count(i0));
1236 } else if (jit_mips2_p() && is_middle_mask(i0)) {
1237 extr(r0, r1, __builtin_ctzl(i0), masked_bits_count(i0));
1238 lshi(r0, r0, __builtin_ctzl(i0));
1239 } else if (jit_mips2_p() && is_middle_mask(~i0)) {
1242 insr(r0, _ZERO_REGNO, __builtin_ctzl(~i0), masked_bits_count(~i0));
1244 reg = jit_get_reg(jit_class_gpr);
1246 AND(r0, r1, rn(reg));
1252 _ori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1255 if (can_zero_extend_short_p(i0))
1258 reg = jit_get_reg(jit_class_gpr);
1260 OR(r0, r1, rn(reg));
1266 _xori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1269 if (can_zero_extend_short_p(i0))
1272 reg = jit_get_reg(jit_class_gpr);
1274 XOR(r0, r1, rn(reg));
1280 _movr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1283 orr(r0, r1, _ZERO_REGNO);
1287 _movi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1290 OR(r0, _ZERO_REGNO, _ZERO_REGNO);
1291 else if (can_sign_extend_short_p(i0))
1292 addiu(r0, _ZERO_REGNO, i0);
1293 else if (can_zero_extend_short_p(i0))
1294 ORI(r0, _ZERO_REGNO, i0);
1296 if (can_sign_extend_int_p(i0))
1298 else if (can_zero_extend_int_p(i0)) {
1299 if (i0 & 0xffff0000) {
1300 ORI(r0, _ZERO_REGNO, i0 >> 16);
1304 # if __WORDSIZE == 64
1306 movi(r0, (jit_uword_t)i0 >> 32);
1307 if (i0 & 0xffff0000) {
1309 ORI(r0, r0, i0 >> 16);
1322 _movi_p(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1327 # if __WORDSIZE == 32
1332 ORI(r0, r0, i0 >> 32);
1334 ORI(r0, r0, i0 >> 16);
1343 _casx(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1344 jit_int32_t r2, jit_int32_t r3, jit_word_t i0)
1346 jit_int32_t r1_reg, iscasi;
1347 jit_word_t retry, done, jump0, jump1;
1348 if ((iscasi = (r1 == _NOREG))) {
1349 r1_reg = jit_get_reg(jit_class_gpr);
1356 # if __WORDSIZE == 32
1362 BNE(r0, r2, 1); /* bne done r0 r2 */
1363 movi(r0, 0); /* set to 0 in delay slot */
1364 movr(r0, r3); /* after jump and delay slot */
1365 /* store new value */
1366 # if __WORDSIZE == 32
1372 BEQ(r0, _ZERO_REGNO, 0); /* beqi retry r0 0 */
1373 movi(r0, 1); /* set to 1 in delay slot */
1377 patch_at(jump0, done);
1378 patch_at(jump1, retry);
1380 jit_unget_reg(r1_reg);
1384 _ldi_c(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1387 if (can_sign_extend_short_p(i0))
1388 LB(r0, i0, _ZERO_REGNO);
1390 reg = jit_get_reg(jit_class_gpr);
1398 _ldi_uc(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1401 if (can_sign_extend_short_p(i0))
1402 LBU(r0, i0, _ZERO_REGNO);
1404 reg = jit_get_reg(jit_class_gpr);
1406 ldr_uc(r0, rn(reg));
1412 _ldi_s(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1415 if (can_sign_extend_short_p(i0))
1416 LH(r0, i0, _ZERO_REGNO);
1418 reg = jit_get_reg(jit_class_gpr);
1426 _ldi_us(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1429 if (can_sign_extend_short_p(i0))
1430 LHU(r0, i0, _ZERO_REGNO);
1432 reg = jit_get_reg(jit_class_gpr);
1434 ldr_us(r0, rn(reg));
1440 _ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1443 if (can_sign_extend_short_p(i0))
1444 LW(r0, i0, _ZERO_REGNO);
1446 reg = jit_get_reg(jit_class_gpr);
1453 #if __WORDSIZE == 64
1455 _ldi_ui(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1458 if (can_sign_extend_short_p(i0))
1459 LWU(r0, i0, _ZERO_REGNO);
1461 reg = jit_get_reg(jit_class_gpr);
1463 ldr_ui(r0, rn(reg));
1469 _ldi_l(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1472 if (can_sign_extend_short_p(i0))
1473 LD(r0, i0, _ZERO_REGNO);
1475 reg = jit_get_reg(jit_class_gpr);
1484 _ldxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
1487 reg = jit_get_reg(jit_class_gpr);
1488 addr(rn(reg), r1, r2);
1494 _ldxi_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1497 if (can_sign_extend_short_p(i0))
1500 reg = jit_get_reg(jit_class_gpr);
1501 addi(rn(reg), r1, i0);
1508 _ldxr_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
1511 reg = jit_get_reg(jit_class_gpr);
1512 addr(rn(reg), r1, r2);
1513 ldr_uc(r0, rn(reg));
1518 _ldxi_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1521 if (can_sign_extend_short_p(i0))
1524 reg = jit_get_reg(jit_class_gpr);
1525 addi(rn(reg), r1, i0);
1526 ldr_uc(r0, rn(reg));
1532 _ldxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
1535 reg = jit_get_reg(jit_class_gpr);
1536 addr(rn(reg), r1, r2);
1542 _ldxi_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1545 if (can_sign_extend_short_p(i0))
1548 reg = jit_get_reg(jit_class_gpr);
1549 addi(rn(reg), r1, i0);
1556 _ldxr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
1559 reg = jit_get_reg(jit_class_gpr);
1560 addr(rn(reg), r1, r2);
1561 ldr_us(r0, rn(reg));
1566 _ldxi_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1569 if (can_sign_extend_short_p(i0))
1572 reg = jit_get_reg(jit_class_gpr);
1573 addi(rn(reg), r1, i0);
1574 ldr_us(r0, rn(reg));
1580 _ldxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
1583 reg = jit_get_reg(jit_class_gpr);
1584 addr(rn(reg), r1, r2);
1590 _ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1593 if (can_sign_extend_short_p(i0))
1596 reg = jit_get_reg(jit_class_gpr);
1597 addi(rn(reg), r1, i0);
1603 #if __WORDSIZE == 64
1605 _ldxr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
1608 reg = jit_get_reg(jit_class_gpr);
1609 addr(rn(reg), r1, r2);
1610 ldr_ui(r0, rn(reg));
1615 _ldxi_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1618 if (can_sign_extend_short_p(i0))
1621 reg = jit_get_reg(jit_class_gpr);
1622 addi(rn(reg), r1, i0);
1623 ldr_ui(r0, rn(reg));
1629 _ldxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
1632 reg = jit_get_reg(jit_class_gpr);
1633 addr(rn(reg), r1, r2);
1639 _ldxi_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1642 if (can_sign_extend_short_p(i0))
1645 reg = jit_get_reg(jit_class_gpr);
1646 addi(rn(reg), r1, i0);
1654 _sti_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
1657 if (can_sign_extend_short_p(i0))
1658 SB(r0, i0, _ZERO_REGNO);
1660 reg = jit_get_reg(jit_class_gpr);
1668 _sti_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
1671 if (can_sign_extend_short_p(i0))
1672 SH(r0, i0, _ZERO_REGNO);
1674 reg = jit_get_reg(jit_class_gpr);
1682 _sti_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
1685 if (can_sign_extend_short_p(i0))
1686 SW(r0, i0, _ZERO_REGNO);
1688 reg = jit_get_reg(jit_class_gpr);
1695 #if __WORDSIZE == 64
1697 _sti_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
1700 if (can_sign_extend_short_p(i0))
1701 SD(r0, i0, _ZERO_REGNO);
1703 reg = jit_get_reg(jit_class_gpr);
1712 _stxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1715 reg = jit_get_reg(jit_class_gpr);
1716 addr(rn(reg), r0, r1);
1722 _stxi_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1725 if (can_sign_extend_short_p(i0))
1728 reg = jit_get_reg(jit_class_gpr);
1729 addi(rn(reg), r0, i0);
1736 _stxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
1739 reg = jit_get_reg(jit_class_gpr);
1740 addr(rn(reg), r0, r1);
1746 _stxi_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1749 if (can_sign_extend_short_p(i0))
1752 reg = jit_get_reg(jit_class_gpr);
1753 addi(rn(reg), r0, i0);
1760 _stxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
1763 reg = jit_get_reg(jit_class_gpr);
1764 addr(rn(reg), r0, r1);
1770 _stxi_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1773 if (can_sign_extend_short_p(i0))
1776 reg = jit_get_reg(jit_class_gpr);
1777 addi(rn(reg), r0, i0);
1783 #if __WORDSIZE == 64
1785 _stxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
1788 reg = jit_get_reg(jit_class_gpr);
1789 addr(rn(reg), r0, r1);
1795 _stxi_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1798 if (can_sign_extend_short_p(i0))
1801 reg = jit_get_reg(jit_class_gpr);
1802 addi(rn(reg), r0, i0);
1810 _bswapr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1812 if (jit_mips2_p()) {
1816 generic_bswapr_us(_jit, r0, r1);
1821 _bswapr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1823 if (jit_mips2_p()) {
1824 if (__WORDSIZE == 64) {
1828 extr(r0, r0, 0, 32);
1834 generic_bswapr_ui(_jit, r0, r1);
1839 _extr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1844 lshi(r0, r1, __WORDSIZE - 8);
1845 rshi(r0, r0, __WORDSIZE - 8);
1850 _extr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1855 lshi(r0, r1, __WORDSIZE - 16);
1856 rshi(r0, r0, __WORDSIZE - 16);
1860 # if __WORDSIZE == 64
1862 _extr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1865 DEXT(r0, r1, 0, 32);
1874 _lti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1878 if (can_sign_extend_short_p(i0))
1881 reg = jit_get_reg(jit_class_gpr);
1883 ltr(r0, r1, rn(reg));
1889 _lti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1893 if (can_sign_extend_short_p(i0))
1896 reg = jit_get_reg(jit_class_gpr);
1898 ltr_u(r0, r1, rn(reg));
1904 _ler(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1911 _lei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1915 if (can_sign_extend_short_p(i0 + 1))
1916 SLTI(r0, r1, i0 + 1);
1918 reg = jit_get_reg(jit_class_gpr);
1920 ler(r0, r1, rn(reg));
1926 _ler_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1933 _lei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1937 if (can_sign_extend_short_p(i0 + 1))
1938 SLTIU(r0, r1, i0 + 1);
1940 reg = jit_get_reg(jit_class_gpr);
1942 ler_u(r0, r1, rn(reg));
1948 _eqr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1951 SLTU(r0, _ZERO_REGNO, r0);
1956 _eqi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1960 SLTU(r0, _ZERO_REGNO, r0);
1963 SLTU(r0, _ZERO_REGNO, r1);
1968 _ger(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1975 _gei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1979 if (can_sign_extend_short_p(i0)) {
1983 reg = jit_get_reg(jit_class_gpr);
1985 ger(r0, r1, rn(reg));
1991 _ger_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1998 _gei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2002 if (can_sign_extend_short_p(i0)) {
2006 reg = jit_get_reg(jit_class_gpr);
2008 ger_u(r0, r1, rn(reg));
2014 _gti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2019 SLT(r0, _ZERO_REGNO, r1);
2021 reg = jit_get_reg(jit_class_gpr);
2023 SLT(r0, rn(reg), r1);
2029 _gti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2034 SLTU(r0, _ZERO_REGNO, r1);
2036 reg = jit_get_reg(jit_class_gpr);
2038 SLTU(r0, rn(reg), r1);
2044 _ner(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2047 SLTU(r0, _ZERO_REGNO, r0);
2051 _nei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2055 SLTU(r0, _ZERO_REGNO, r0);
2058 SLTU(r0, _ZERO_REGNO, r1);
2062 _bltr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2067 reg = jit_get_reg(jit_class_gpr);
2068 SLT(rn(reg), r0, r1);
2070 BNE(rn(reg), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2078 _bltr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2083 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2084 SLTU(rn(reg), r0, r1);
2086 BNE(rn(reg), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2094 _blti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2101 if (!(zero_p = i1 == 0))
2102 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2103 if (can_sign_extend_short_p(i1)) {
2105 SLTI(rn(reg), r0, i1);
2107 d = ((i0 - w) >> 2) - 1;
2109 BNE(rn(reg), _ZERO_REGNO, d);
2116 w = bltr(i0, r0, rn(reg));
2125 _blti_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2130 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2131 if (can_sign_extend_short_p(i1)) {
2132 SLTIU(rn(reg), r0, i1);
2134 BNE(rn(reg), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2139 w = bltr_u(i0, r0, rn(reg));
2147 _bler(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2152 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2153 SLT(rn(reg), r1, r0);
2155 BEQ(rn(reg), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2163 _bler_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2168 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2169 SLTU(rn(reg), r1, r0);
2171 BEQ(rn(reg), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2179 _blei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2186 BLEZ(r0, ((i0 - w) >> 2) - 1);
2190 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2192 w = bler(i0, r0, rn(reg));
2200 _blei_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2207 BEQ(r0, _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2211 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2213 w = bler_u(i0, r0, rn(reg));
2221 _beqr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2226 BEQ(r0, r1, ((i0 - w) >> 2) - 1);
2233 _beqi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2240 BEQ(r0, _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2244 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2246 w = beqr(i0, r0, rn(reg));
2254 _bger(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2259 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2260 SLT(rn(reg), r0, r1);
2262 BEQ(rn(reg), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2270 _bger_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2275 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2276 SLTU(rn(reg), r0, r1);
2278 BEQ(rn(reg), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2286 _bgei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2293 if (!(zero_p = i1 == 0))
2294 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2295 if (can_sign_extend_short_p(i1)) {
2297 SLTI(rn(reg), r0, i1);
2299 d = ((i0 - w) >> 2) - 1;
2301 BEQ(rn(reg), _ZERO_REGNO, d);
2308 w = bger(i0, r0, rn(reg));
2317 _bgei_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2322 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2323 if (can_sign_extend_short_p(i1)) {
2324 SLTIU(rn(reg), r0, i1);
2326 BEQ(rn(reg), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2331 w = bger_u(i0, r0, rn(reg));
2339 _bgtr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2344 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2345 SLT(rn(reg), r1, r0);
2347 BNE(rn(reg), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2355 _bgtr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2360 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2361 SLTU(rn(reg), r1, r0);
2363 BNE(rn(reg), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2371 _bgti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2378 BGTZ(r0, ((i0 - w) >> 2) - 1);
2382 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2384 w = bgtr(i0, r0, rn(reg));
2392 _bgti_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2399 BNE(r0, _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2403 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2405 w = bgtr_u(i0, r0, rn(reg));
2413 _bner(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2418 BNE(r0, r1, ((i0 - w) >> 2) - 1);
2425 _bnei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2432 BNE(r0, _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2436 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2438 w = bner(i0, r0, rn(reg));
2446 _jmpr(jit_state_t *_jit, jit_int32_t r0)
2453 _jmpi(jit_state_t *_jit, jit_word_t i0)
2459 if (((w + sizeof(jit_int32_t)) & 0xf0000000) == (i0 & 0xf0000000)) {
2460 J((i0 & ~0xf0000000) >> 2);
2464 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2465 movi_p(rn(reg), i0);
2474 _boaddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2481 /* t1 = r0 + r1; overflow = r1 < 0 ? r0 < t1 : t1 < r0 */
2482 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2483 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2484 t2 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2485 SLT(rn(t0), r1, _ZERO_REGNO); /* t0 = r1 < 0 */
2486 addr(rn(t1), r0, r1); /* t1 = r0 + r1 */
2487 SLT(rn(t2), rn(t1), r0); /* t2 = t1 < r0 */
2488 SLT(rn(t1), r0, rn(t1)); /* t1 = r0 < t1 */
2489 MOVZ(rn(t1), rn(t2), rn(t0)); /* if (r0 == 0) t1 = t2 */
2491 BNE(rn(t1), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2502 _boaddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2509 if (can_sign_extend_short_p(i1)) {
2510 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2511 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2512 t2 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2513 SLTI(rn(t0), _ZERO_REGNO, i1);
2514 addiu(rn(t1), r0, i1);
2515 SLT(rn(t2), r0, rn(t1));
2516 SLT(rn(t1), rn(t1), r0);
2517 MOVZ(rn(t1), rn(t2), rn(t0));
2519 BNE(rn(t1), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2527 t0 = jit_get_reg(jit_class_gpr);
2529 w = boaddr(i0, r0, rn(t0));
2536 _boaddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2542 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2543 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2544 addr(rn(t0), r0, r1);
2545 SLTU(rn(t1), rn(t0), r0);
2547 BNE(_ZERO_REGNO, rn(t1), ((i0 - w) >> 2) - 1);
2556 _boaddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2562 if (can_sign_extend_short_p(i0)) {
2563 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2564 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2565 addiu(rn(t0), r0, i1);
2566 SLTU(rn(t1), rn(t0), r0);
2568 BNE(_ZERO_REGNO, rn(t1), ((i0 - w) >> 2) - 1);
2575 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2577 w = boaddr_u(i0, r0, rn(t0));
2584 _bxaddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2591 /* t1 = r0 + r1; overflow = r1 < 0 ? r0 < t1 : t1 < r0 */
2592 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2593 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2594 t2 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2595 SLT(rn(t0), r1, _ZERO_REGNO); /* t0 = r1 < 0 */
2596 addr(rn(t1), r0, r1); /* t1 = r0 + r1 */
2597 SLT(rn(t2), rn(t1), r0); /* t2 = t1 < r0 */
2598 SLT(rn(t1), r0, rn(t1)); /* t1 = r0 < t1 */
2599 MOVZ(rn(t1), rn(t2), rn(t0)); /* if (r0 == 0) t1 = t2 */
2601 BEQ(rn(t1), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2612 _bxaddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2619 if (can_sign_extend_short_p(i1)) {
2620 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2621 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2622 t2 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2623 SLTI(rn(t0), _ZERO_REGNO, i1);
2624 addiu(rn(t1), r0, i1);
2625 SLT(rn(t2), r0, rn(t1));
2626 SLT(rn(t1), rn(t1), r0);
2627 MOVZ(rn(t1), rn(t2), rn(t0));
2629 BEQ(rn(t1), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2637 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2639 w = bxaddr(i0, r0, rn(t0));
2646 _bxaddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2652 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2653 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2654 addr(rn(t0), r0, r1);
2655 SLTU(rn(t1), rn(t0), r0);
2657 BEQ(_ZERO_REGNO, rn(t1), ((i0 - w) >> 2) - 1);
2666 _bxaddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2672 if (can_sign_extend_short_p(i0)) {
2673 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2674 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2675 addiu(rn(t0), r0, i1);
2676 SLTU(rn(t1), rn(t0), r0);
2678 BEQ(_ZERO_REGNO, rn(t1), ((i0 - w) >> 2) - 1);
2685 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2687 w = bxaddr_u(i0, r0, rn(t0));
2694 _bosubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2701 /* t1 = r0 - r1; overflow = 0 < r1 ? r0 < t1 : t1 < r0 */
2702 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2703 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2704 t2 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2705 SLT(rn(t0), _ZERO_REGNO, r1); /* t0 = 0 < r1 */
2706 subr(rn(t1), r0, r1); /* t1 = r0 - r1 */
2707 SLT(rn(t2), rn(t1), r0); /* t2 = t1 < r0 */
2708 SLT(rn(t1), r0, rn(t1)); /* t1 = r0 < t1 */
2709 MOVZ(rn(t1), rn(t2), rn(t0)); /* if (r0 == 0) t1 = t2 */
2711 BNE(rn(t1), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2722 _bosubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2729 if (can_sign_extend_short_p(i1) && (i1 & 0xffff) != 0x8000) {
2730 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2731 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2732 t2 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2733 SLTI(rn(t0), _ZERO_REGNO, i1);
2734 addiu(rn(t1), r0, -i1);
2735 SLT(rn(t2), rn(t1), r0);
2736 SLT(rn(t1), r0, rn(t1));
2737 MOVZ(rn(t1), rn(t2), rn(t0));
2739 BNE(rn(t1), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2747 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2749 w = bosubr(i0, r0, rn(t0));
2756 _bosubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2762 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2763 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2764 subr(rn(t0), r0, r1);
2765 SLTU(rn(t1), r0, rn(t0));
2767 BNE(_ZERO_REGNO, rn(t1), ((i0 - w) >> 2) - 1);
2776 _bosubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2782 if (can_sign_extend_short_p(i0) && (i0 & 0xffff) != 0x8000) {
2783 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2784 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2785 addiu(rn(t0), r0, -i1);
2786 SLTU(rn(t1), r0, rn(t0));
2788 BNE(_ZERO_REGNO, rn(t1), ((i0 - w) >> 2) - 1);
2795 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2797 w = bosubr_u(i0, r0, rn(t0));
2804 _bxsubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2811 /* t1 = r0 - r1; overflow = 0 < r1 ? r0 < t1 : t1 < r0 */
2812 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2813 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2814 t2 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2815 SLT(rn(t0), _ZERO_REGNO, r1); /* t0 = 0 < r1 */
2816 subr(rn(t1), r0, r1); /* t1 = r0 - r1 */
2817 SLT(rn(t2), rn(t1), r0); /* t2 = t1 < r0 */
2818 SLT(rn(t1), r0, rn(t1)); /* t1 = r0 < t1 */
2819 MOVZ(rn(t1), rn(t2), rn(t0)); /* if (t0 == 0) t1 = t2 */
2821 BEQ(rn(t1), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2832 _bxsubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2839 if (can_sign_extend_short_p(i1) && (i1 & 0xffff) != 0x8000) {
2840 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2841 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2842 t2 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2843 SLTI(rn(t0), _ZERO_REGNO, i1);
2844 addiu(rn(t1), r0, -i1);
2845 SLT(rn(t2), rn(t1), r0);
2846 SLT(rn(t1), r0, rn(t1));
2847 MOVZ(rn(t1), rn(t2), rn(t0));
2849 BEQ(rn(t1), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2857 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2859 w = bxsubr(i0, r0, rn(t0));
2866 _bxsubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2872 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2873 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2874 subr(rn(t0), r0, r1);
2875 SLTU(rn(t1), r0, rn(t0));
2877 BEQ(_ZERO_REGNO, rn(t1), ((i0 - w) >> 2) - 1);
2886 _bxsubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2892 if (can_sign_extend_short_p(i0) && (i0 & 0xffff) != 0x8000) {
2893 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2894 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2895 addiu(rn(t0), r0, -i1);
2896 SLTU(rn(t1), r0, rn(t0));
2898 BEQ(_ZERO_REGNO, rn(t1), ((i0 - w) >> 2) - 1);
2905 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2907 w = bxsubr_u(i0, r0, rn(t0));
2914 _bmsr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2918 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2919 AND(rn(t0), r0, r1);
2921 BNE(_ZERO_REGNO, rn(t0), ((i0 - w) >> 2) - 1);
2928 _bmsi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2932 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2934 andi(rn(t0), r0, i1);
2936 BNE(_ZERO_REGNO, rn(t0), ((i0 - w) >> 2) - 1);
2944 _bmcr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2948 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2949 AND(rn(t0), r0, r1);
2951 BEQ(_ZERO_REGNO, rn(t0), ((i0 - w) >> 2) - 1);
2958 _bmci(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2962 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2964 andi(rn(t0), r0, i1);
2966 BEQ(_ZERO_REGNO, rn(t0), ((i0 - w) >> 2) - 1);
2974 _callr(jit_state_t *_jit, jit_int32_t r0)
2977 if (r0 != _T9_REGNO)
2978 movr(_T9_REGNO, r0);
2984 _calli(jit_state_t *_jit, jit_word_t i0)
2986 if (((_jit->pc.w + sizeof(jit_int32_t)) & 0xf0000000) == (i0 & 0xf0000000)) {
2987 if (can_sign_extend_short_p(i0)) {
2988 JAL((i0 & ~0xf0000000) >> 2);
2989 addiu(_T9_REGNO, _ZERO_REGNO, i0);
2993 if (can_zero_extend_short_p(i0)) {
2994 JAL((i0 & ~0xf0000000) >> 2);
2995 ORI(_T9_REGNO, _ZERO_REGNO, i0);
2999 if (can_sign_extend_int_p(i0)) {
3001 LUI(_T9_REGNO, i0 >> 16);
3002 JAL((i0 & ~0xf0000000) >> 2);
3003 ORI(_T9_REGNO, _T9_REGNO, i0);
3005 JAL((i0 & ~0xf0000000) >> 2);
3006 LUI(_T9_REGNO, i0 >> 16);
3012 movi(_T9_REGNO, i0);
3018 _calli_p(jit_state_t *_jit, jit_word_t i0)
3023 movi_p(_T9_REGNO, i0);
3030 static jit_int32_t fregs[] = {
3031 _F30, _F28, _F26, _F24, _F22, _F20,
3037 static jit_int32_t iregs[] = {
3038 _S7, _S6, _S5, _S4, _S3, _S2, _S1, _S0,
3042 _prolog(jit_state_t *_jit, jit_node_t *node)
3046 if (_jitc->function->define_frame || _jitc->function->assume_frame) {
3047 jit_int32_t frame = -_jitc->function->frame;
3048 assert(_jitc->function->self.aoff >= frame);
3049 if (_jitc->function->assume_frame)
3051 _jitc->function->self.aoff = frame;
3053 if (_jitc->function->allocar)
3054 _jitc->function->self.aoff &= -8;
3056 _jitc->function->stack = ((_jitc->function->self.alen -
3057 /* align stack at 16 bytes */
3058 _jitc->function->self.aoff) + 15) & -16;
3060 _jitc->function->stack = ((/* first 16 bytes must be allocated */
3061 (_jitc->function->self.alen > 16 ?
3062 _jitc->function->self.alen : 16) -
3063 /* align stack at 8 bytes */
3064 _jitc->function->self.aoff) + 7) & -8;
3066 /* callee save registers */
3068 if ((_jitc->function->self.call & jit_call_varargs) &&
3069 jit_arg_reg_p(_jitc->function->vagp))
3070 subi(_SP_REGNO, _SP_REGNO, stack_framesize + 64);
3073 subi(_SP_REGNO, _SP_REGNO, stack_framesize);
3074 offset = stack_framesize - (sizeof(jit_word_t) << 1);
3075 for (index = 0; index < jit_size(fregs); index++, offset -= 8) {
3076 if (jit_regset_tstbit(&_jitc->function->regset, fregs[index]))
3077 stxi_d(offset, _SP_REGNO, rn(fregs[index]));
3079 for (index = 0; index < jit_size(iregs);
3080 index++, offset -= sizeof(jit_word_t)) {
3081 if (jit_regset_tstbit(&_jitc->function->regset, iregs[index]))
3082 stxi(offset, _SP_REGNO, rn(iregs[index]));
3084 assert(offset >= sizeof(jit_word_t));
3085 stxi(offset, _SP_REGNO, _RA_REGNO);
3086 stxi(0, _SP_REGNO, _BP_REGNO);
3087 movr(_BP_REGNO, _SP_REGNO);
3090 if (_jitc->function->stack)
3091 subi(_SP_REGNO, _SP_REGNO, _jitc->function->stack);
3092 if (_jitc->function->allocar) {
3093 index = jit_get_reg(jit_class_gpr);
3094 movi(rn(index), _jitc->function->self.aoff);
3095 stxi_i(_jitc->function->aoffoff, _BP_REGNO, rn(index));
3096 jit_unget_reg(index);
3099 if (_jitc->function->self.call & jit_call_varargs) {
3101 index = _jitc->function->vagp;
3103 index = (_jitc->function->self.size - stack_framesize) >> STACK_SHIFT;
3105 offset = stack_framesize + index * STACK_SLOT;
3106 for (; jit_arg_reg_p(index); ++index, offset += STACK_SLOT) {
3108 SD(rn(_A0 - index), offset, _BP_REGNO);
3110 stxi(offset + WORD_ADJUST, _BP_REGNO, rn(_A0 - index));
3117 _epilog(jit_state_t *_jit, jit_node_t *node)
3121 if (_jitc->function->assume_frame)
3123 /* callee save registers */
3124 movr(_SP_REGNO, _BP_REGNO);
3125 offset = stack_framesize - (sizeof(jit_word_t) << 1);
3126 for (index = 0; index < jit_size(fregs); index++, offset -= 8) {
3127 if (jit_regset_tstbit(&_jitc->function->regset, fregs[index]))
3128 ldxi_d(rn(fregs[index]), _SP_REGNO, offset);
3130 for (index = 0; index < jit_size(iregs);
3131 index++, offset -= sizeof(jit_word_t)) {
3132 if (jit_regset_tstbit(&_jitc->function->regset, iregs[index]))
3133 ldxi(rn(iregs[index]), _SP_REGNO, offset);
3135 assert(offset >= sizeof(jit_word_t));
3136 ldxi(_RA_REGNO, _SP_REGNO, offset);
3137 ldxi(_BP_REGNO, _SP_REGNO, 0);
3141 if ((_jitc->function->self.call & jit_call_varargs) &&
3142 jit_arg_reg_p(_jitc->function->vagp))
3143 addi(_SP_REGNO, _SP_REGNO, stack_framesize + 64);
3146 addi(_SP_REGNO, _SP_REGNO, stack_framesize);
3150 _vastart(jit_state_t *_jit, jit_int32_t r0)
3152 assert(_jitc->function->self.call & jit_call_varargs);
3153 /* Initialize va_list to the first stack argument. */
3155 if (jit_arg_reg_p(_jitc->function->vagp))
3156 addi(r0, _BP_REGNO, stack_framesize + _jitc->function->vagp *
3157 sizeof(jit_int64_t));
3160 addi(r0, _BP_REGNO, _jitc->function->self.size);
3164 _vaarg(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3166 /* Load argument. */
3168 ldxi(r0, r1, WORD_ADJUST);
3173 /* Update va_list. */
3174 addi(r1, r1, STACK_SLOT);
3178 _patch_abs(jit_state_t *_jit, jit_word_t instr, jit_word_t label)
3187 #if __WORDSIZE == 32
3189 assert(i.hc.b == MIPS_LUI);
3190 i.is.b = label >> 16;
3193 assert(i.hc.b == MIPS_ORI);
3198 assert(i.hc.b == MIPS_LUI);
3199 i.is.b = label >> 48;
3202 assert(i.hc.b == MIPS_ORI);
3203 i.is.b = label >> 32;
3207 assert(i.hc.b == MIPS_ORI);
3208 i.is.b = label >> 16;
3212 assert(i.hc.b == MIPS_ORI);
3219 _patch_at(jit_state_t *_jit, jit_word_t instr, jit_word_t label)
3230 /* 16 bit immediate opcodes */
3233 case MIPS_BLTZ: case MIPS_BLTZL:
3234 case MIPS_BLTZAL: case MIPS_BLTZALL:
3235 case MIPS_BGEZ: case MIPS_BGEZAL:
3236 case MIPS_BGEZALL: case MIPS_BGEZL:
3237 case MIPS_TEQI: case MIPS_TGEI:
3238 case MIPS_TGEIU: case MIPS_TLTI:
3239 case MIPS_TLTIU: case MIPS_TNEI:
3240 i.is.b = ((label - instr) >> 2) - 1;
3244 assert(!"unhandled branch opcode");
3249 case MIPS_COP1: case MIPS_COP2:
3250 assert(i.rs.b == MIPS_BC);
3252 case MIPS_BCF: case MIPS_BCFL:
3253 case MIPS_BCT: case MIPS_BCTL:
3254 i.is.b = ((label - instr) >> 2) - 1;
3258 assert(!"unhandled branch opcode");
3263 case MIPS_BLEZ: case MIPS_BLEZL:
3264 case MIPS_BEQ: case MIPS_BEQL:
3265 case MIPS_BGTZ: case MIPS_BGTZL:
3266 case MIPS_BNE: case MIPS_BNEL:
3267 i.is.b = ((label - instr) >> 2) - 1;
3272 patch_abs(instr, label);
3275 case MIPS_J: case MIPS_JAL:
3277 assert(((instr + sizeof(jit_int32_t)) & 0xf0000000) ==
3278 (label & 0xf0000000));
3279 i.ii.b = (label & ~0xf0000000) >> 2;
3284 assert(!"unhandled branch opcode");