90c3767b00ebb269ef3395dabc623ce3bed8dcd3
[pcsx_rearmed.git] / deps / lightning / lib / jit_sparc-cpu.c
1 /*
2  * Copyright (C) 2013-2019  Free Software Foundation, Inc.
3  *
4  * This file is part of GNU lightning.
5  *
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)
9  * any later version.
10  *
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.
15  *
16  * Authors:
17  *      Paulo Cesar Pereira de Andrade
18  */
19
20 #if PROTO
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
38 /*
39  *                                      - previous stack frame
40  * fp   ----
41  * fp-  local variables (in lightning, 8 bytes space for float conversion)
42  * fp-  alloca
43  * sp+  stack arguments
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
47  * sp   ----
48  *      decreasing memory address       - next stack frame (not yet allocated)
49  */
50 #  define stack_framesize                       ((16 + (__WORDSIZE == 32) + 6) * sizeof(jit_word_t))
51 typedef union {
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;
77     jit_int32_t                                                   v;
78 } jit_instr_t;
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)
90 static void
91 _f2b(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
92 #  if __WORDSIZE == 64
93 #    define f2bp(op,a,cond,op2,cc1,cc0,p,disp19)                                \
94         _f2bp(_jit,op,a,cond,op2,cc1,cc0,p,disp19)
95 static void
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);
98 #  endif
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 f3rx(op, rd, op3, rs1, rs2)   _f3rx(_jit, op, rd, op3, rs1, rs2)
104 static void _f3rx(jit_state_t*,
105                   jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
106 #  endif
107 #  define f3i(op, rd, op3, rs1, simm13) _f3i(_jit, op, rd, op3, rs1, simm13)
108 static void _f3i(jit_state_t*,
109                  jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
110 #  define f3s(op, rd, op3, rs1, simm13) _f3s(_jit, op, rd, op3, rs1, simm13)
111 static void _f3s(jit_state_t*,
112                  jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
113 #  define f3t(cond, rs1, i, ri)         _f3t(_jit, cond, rs1, i, ri)
114 static void _f3t(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t)
115     maybe_unused;
116 #  define f3a(op, rd, op3, rs1, rs2)    _f3a(_jit, op, rd, op3, rs1, asi, rs2)
117 static void _f3a(jit_state_t*,jit_int32_t,
118                  jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t)
119     maybe_unused;
120 #  define LDSB(rs1, rs2, rd)            f3r(3, rd, 9, rs1, rs2)
121 #  define LDSBI(rs1, imm, rd)           f3i(3, rd, 9, rs1, imm)
122 #  define LDSH(rs1, rs2, rd)            f3r(3, rd, 10, rs1, rs2)
123 #  define LDSHI(rs1, imm, rd)           f3i(3, rd, 10, rs1, imm)
124 #  define LDUB(rs1, rs2, rd)            f3r(3, rd, 1, rs1, rs2)
125 #  define LDUBI(rs1, imm, rd)           f3i(3, rd, 1, rs1, imm)
126 #  define LDUH(rs1, rs2, rd)            f3r(3, rd, 2, rs1, rs2)
127 #  define LDUHI(rs1, imm, rd)           f3i(3, rd, 2, rs1, imm)
128 #  if __WORDSIZE == 32
129 #    define LD(rs1, rs2, rd)            f3r(3, rd, 0, rs1, rs2)
130 #    define LDI(rs1, imm, rd)           f3i(3, rd, 0, rs1, imm)
131 #    define LDD(rs1, rs2, rd)           f3r(3, rd, 3, rs1, rs2)
132 #    define LDDI(rs1, imm, rd)          f3i(3, rd, 3, rs1, imm)
133 #  else
134 #    define LDSW(rs1, rs2, rd)          f3r(3, rd, 8, rs1, rs2)
135 #    define LDSWI(rs1, imm, rd)         f3i(3, rd, 8, rs1, imm)
136 #    define LDUW(rs1, rs2, rd)          f3r(3, rd, 0, rs1, rs2)
137 #    define LDUWI(rs1, imm, rd)         f3i(3, rd, 0, rs1, imm)
138 #    define LDX(rs1, rs2, rd)           f3r(3, rd, 11, rs1, rs2)
139 #    define LDXI(rs1, imm, rd)          f3i(3, rd, 11, rs1, imm)
140 #  endif
141 #  define LDSBA(rs1, rs2, asi, rd)      f3a(3, rd, 25, rs1, asi, rs2)
142 #  define LDSHA(rs1, rs2, asi, rd)      f3a(3, rd, 26, rs1, asi, rs2)
143 #  define LDUBA(rs1, rs2, asi, rd)      f3a(3, rd, 17, rs1, asi, rs2)
144 #  define LDUHA(rs1, rs2, asi, rd)      f3a(3, rd, 18, rs1, asi, rs2)
145 #  if __WORDSIZE == 32
146 #    define LDA(rs1, rs2, asi, rd)      f3a(3, rd, 16, rs1, asi, rs2)
147 #    define LDDA(rs1, rs2, asi, rd)     f3a(3, rd, 19, rs1, asi, rs2)
148 #  else
149 #    define LDSWA(rs1, rs2, asi, rd)    f3a(3, rd, 24, rs1, asi, rs2)
150 #    define LDUWA(rs1, rs2, asi, rd)    f3a(3, rd, 16, rs1, asi, rs2)
151 #    define LDXA(rs1, rs2, asi, rd)     f3a(3, rd, 27, rs1, asi, rs2)
152 #  endif
153 #  define LDC(rs1, rs2, rd)             f3r(3, rd, 48, rs1, rs2)
154 #  define LDCI(rs1, imm, rd)            f3i(3, rd, 48, rs1, imm)
155 #  define LDDC(rs1, rs2, rd)            f3r(3, rd, 51, rs1, rs2)
156 #  define LDDCI(rs1, imm, rd)           f3i(3, rd, 51, rs1, imm)
157 #  define LDCSR(rs1, rs2, rd)           f3r(3, rd, 49, rs1, rs2)
158 #  define LDCSRI(rs1, imm, rd)          f3i(3, rd, 49, rs1, imm)
159 #  define STB(rd, rs1, rs2)             f3r(3, rd, 5, rs1, rs2)
160 #  define STBI(rd, rs1, imm)            f3i(3, rd, 5, rs1, imm)
161 #  define STH(rd, rs1, rs2)             f3r(3, rd, 6, rs1, rs2)
162 #  define STHI(rd, rs1, imm)            f3i(3, rd, 6, rs1, imm)
163 #  if __WORDSIZE == 32
164 #    define ST(rd, rs1, rs2)            f3r(3, rd, 4, rs1, rs2)
165 #    define STI(rd, rs1, imm)           f3i(3, rd, 4, rs1, imm)
166 #    define STD(rrd, s1, rs2)           f3r(3, rd, 7, rs1, rs2)
167 #    define STDI(rd, rs1, imm)          f3i(3, rd, 7, rs1, imm)
168 #  else
169 #    define STW(rd, rs1, rs2)           f3r(3, rd, 4, rs1, rs2)
170 #    define STWI(rd, rs1, imm)          f3i(3, rd, 4, rs1, imm)
171 #    define STX(rd, rs1, rs2)           f3r(3, rd, 14, rs1, rs2)
172 #    define STXI(rd, rs1, imm)          f3i(3, rd, 14, rs1, imm)
173 #  endif
174 #  define STBA(rd, rs1, rs2)            f3a(3, rd, 21, rs1, asi, rs2)
175 #  define STHA(rd, rs1, rs2)            f3a(3, rd, 22, rs1, asi, rs2)
176 #  if __WORDSIZE == 32
177 #    define STA(rd, rs1, rs2)           f3a(3, rd, 20, rs1, asi, rs2)
178 #    define STDA(rd, rs1, rs2)          f3a(3, rd, 23, rs1, asi, rs2)
179 #  else
180 #    define STWA(rd, rs1, rs2)          f3a(3, rd, 20, rs1, asi, rs2)
181 #    define STXA(rd, rs1, rs2)          f3a(3, rd, 30, rs1, asi, rs2)
182 #  endif
183 #  define STC(rd, rs1, rs2)             f3r(3, rd, 52, rs1, rs2)
184 #  define STCI(rd, rs1, imm)            f3i(3, rd, 52, rs1, imm)
185 #  define STDC(rd, rs1, rs2)            f3r(3, rd, 55, rs1, rs2)
186 #  define STDCI(rd, rs1, imm)           f3i(3, rd, 55, rs1, imm)
187 #  define STCSR(rd, rs1, rs2)           f3r(3, rd, 53, rs1, rs2)
188 #  define STCSRI(rd, rs1, imm)          f3i(3, rd, 53, rs1, imm)
189 #  define STDCQ(rd, rs1, rs2)           f3r(3, rd, 54, rs1, rs2)
190 #  define STDCQI(rd, rs1, imm)          f3i(3, rd, 54, rs1, imm)
191 #  define LDSTUB(rs1, rs2, rd)          f3r(3, rd, 13, rs1, rs2)
192 #  define LDSTUBI(rs1, imm, rd)         f3r(3, rd, 13, rs1, imm)
193 #  define LDSTUBA(rs1, rs2, asi, rd)    f3a(3, rd, 21, rs1, asi, rs2)
194 #  define SWAP(rs1, rs2, rd)            f3r(3, rd, 15, rs1, rs2)
195 #  define SWAPI(rs1, imm, rd)           f3r(3, rd, 15, rs1, imm)
196 #  define SWAPA(rs1, rs2, asi, rd)      f3a(3, rd, 23, rs1, asi, rs2)
197 #  define NOP()                         SETHI(0, 0)
198 #  define HI(im)                        ((im) >> 10)
199 #  define LO(im)                        ((im) & 0x3ff)
200 #  define SETHI(im, rd)                 f2r(0, rd, 4, im)
201 #  define AND(rs1, rs2, rd)             f3r(2, rd, 1, rs1, rs2)
202 #  define ANDI(rs1, imm, rd)            f3i(2, rd, 1, rs1, imm)
203 #  define ANDcc(rs1, rs2, rd)           f3r(2, rd, 17, rs1, rs2)
204 #  define ANDIcc(rs1, imm, rd)          f3i(2, rd, 17, rs1, imm)
205 #  define BTST(rs1, rs2)                ANDcc(rs1, rs2, 0)
206 #  define BTSTI(rs1, imm)               ANDIcc(rs1, imm, 0)
207 #  define ANDN(rs1, rs2, rd)            f3r(2, rd, 5, rs1, rs2)
208 #  define ANDNI(rs1, imm, rd)           f3i(2, rd, 5, rs1, imm)
209 #  define ANDNcc(rs1, rs2, rd)          f3r(2, rd, 21, rs1, rs2)
210 #  define ANDNIcc(rs1, imm, rd)         f3i(2, rd, 21, rs1, imm)
211 #  define OR(rs1, rs2, rd)              f3r(2, rd, 2, rs1, rs2)
212 #  define ORI(rs1, imm, rd)             f3i(2, rd, 2, rs1, imm)
213 #  define ORcc(rs1, rs2, rd)            f3r(2, rd, 18, rs1, rs2)
214 #  define ORIcc(rs1, imm, rd)           f3i(2, rd, 18, rs1, imm)
215 #  define ORN(rs1, rs2, rd)             f3r(2, rd, 6, rs1, rs2)
216 #  define ORNI(rs1, imm, rd)            f3i(2, rd, 6, rs1, imm)
217 #  define ORNcc(rs1, rs2, rd)           f3r(2, rd, 22, rs1, rs2)
218 #  define ORNIcc(rs1, imm, rd)          f3i(2, rd, 22, rs1, imm)
219 #  define XOR(rs1, rs2, rd)             f3r(2, rd, 3, rs1, rs2)
220 #  define XORI(rs1, imm, rd)            f3i(2, rd, 3, rs1, imm)
221 #  define XORcc(rs1, rs2, rd)           f3r(2, rd, 19, rs1, rs2)
222 #  define XORIcc(rs1, imm, rd)          f3i(2, rd, 19, rs1, imm)
223 #  define XNOR(rs1, rs2, rd)            f3r(2, rd, 7, rs1, rs2)
224 #  define XNORI(rs1, imm, rd)           f3i(2, rd, 7, rs1, imm)
225 #  define XNORcc(rs1, rs2, rd)          f3r(2, rd, 23, rs1, rs2)
226 #  define XNORIcc(rs1, imm, rd)         f3i(2, rd, 23, rs1, imm)
227 #  define SLL(rs1, rs2, rd)             f3r(2, rd, 37, rs1, rs2)
228 #  define SLLI(rs1, imm, rd)            f3i(2, rd, 37, rs1, imm)
229 #  define SRL(rs1, rs2, rd)             f3r(2, rd, 38, rs1, rs2)
230 #  define SRLI(rs1, imm, rd)            f3i(2, rd, 38, rs1, imm)
231 #  define SRA(rs1, rs2, rd)             f3r(2, rd, 39, rs1, rs2)
232 #  define SRAI(rs1, imm, rd)            f3i(2, rd, 39, rs1, imm)
233 #  if __WORDSIZE == 64
234 #    define SLLX(rs1, rs2, rd)          f3rx(2, rd, 37, rs1, rs2)
235 #    define SLLXI(rs1, imm, rd)         f3s(2, rd, 37, rs1, imm)
236 #    define SRLX(rs1, rs2, rd)          f3rx(2, rd, 38, rs1, rs2)
237 #    define SRLXI(rs1, imm, rd)         f3s(2, rd, 38, rs1, imm)
238 #    define SRAX(rs1, rs2, rd)          f3rx(2, rd, 39, rs1, rs2)
239 #    define SRAXI(rs1, imm, rd)         f3s(2, rd, 39, rs1, imm)
240 #  endif
241 #  define ADD(rs1, rs2, rd)             f3r(2, rd, 0, rs1, rs2)
242 #  define ADDI(rs1, imm, rd)            f3i(2, rd, 0, rs1, imm)
243 #  define ADDcc(rs1, rs2, rd)           f3r(2, rd, 16, rs1, rs2)
244 #  define ADDIcc(rs1, imm, rd)          f3i(2, rd, 16, rs1, imm)
245 #  define ADDX(rs1, rs2, rd)            f3r(2, rd, 8, rs1, rs2)
246 #  define ADDXI(rs1, imm, rd)           f3i(2, rd, 8, rs1, imm)
247 #  define ADDXcc(rs1, rs2, rd)          f3r(2, rd, 24, rs1, rs2)
248 #  define ADDXIcc(rs1, imm, rd)         f3i(2, rd, 24, rs1, imm)
249 #  define TADDcc(rs1, rs2, rd)          f3r(2, rd, 32, rs1, rs2)
250 #  define TADDIcc(rs1, imm, rd)         f3i(2, rd, 32, rs1, imm)
251 #  define TADDccTV(rs1, rs2, rd)        f3r(2, rd, 34, rs1, rs2)
252 #  define TADDIccTV(rs1, imm, rd)       f3i(2, rd, 34, rs1, imm)
253 #  define SUB(rs1, rs2, rd)             f3r(2, rd, 4, rs1, rs2)
254 #  define NEG(rs1, rd)                  SUB(0, rs1, rd)
255 #  define SUBI(rs1, imm, rd)            f3i(2, rd, 4, rs1, imm)
256 #  define SUBcc(rs1, rs2, rd)           f3r(2, rd, 20, rs1, rs2)
257 #  define SUBIcc(rs1, imm, rd)          f3i(2, rd, 20, rs1, imm)
258 #  define CMP(rs1, rs2)                 SUBcc(rs1, rs2, 0)
259 #  define CMPI(rs1, imm)                SUBIcc(rs1, imm, 0)
260 #  define SUBX(rs1, rs2, rd)            f3r(2, rd, 12, rs1, rs2)
261 #  define SUBXI(rs1, imm, rd)           f3i(2, rd, 12, rs1, imm)
262 #  define SUBXcc(rs1, rs2, rd)          f3r(2, rd, 28, rs1, rs2)
263 #  define SUBXIcc(rs1, imm, rd)         f3i(2, rd, 28, rs1, imm)
264 #  define TSUBcc(rs1, rs2, rd)          f3r(2, rd, 33, rs1, rs2)
265 #  define TDADDIcc(rs1, imm, rd)        f3i(2, rd, 33, rs1, imm)
266 #  define TSUBccTV(rs1, rs2, rd)        f3r(2, rd, 35, rs1, rs2)
267 #  define TSUBIccTV(rs1, imm, rd)       f3i(2, rd, 35, rs1, imm)
268 #  define MULScc(rs1, rs2, rd)          f3r(2, rd, 36, rs1, rs2)
269 #  define MULSIcc(rs1, imm, rd)         f3i(2, rd, 36, rs1, imm)
270 #  define UMUL(rs1, rs2, rd)            f3r(2, rd, 10, rs1, rs2)
271 #  define UMULI(rs1, imm, rd)           f3i(2, rd, 10, rs1, imm)
272 #  define SMUL(rs1, rs2, rd)            f3r(2, rd, 11, rs1, rs2)
273 #  define SMULI(rs1, imm, rd)           f3i(2, rd, 11, rs1, imm)
274 #  define UMULcc(rs1, rs2, rd)          f3r(2, rd, 26, rs1, rs2)
275 #  define UMULIcc(rs1, imm, rd)         f3i(2, rd, 26, rs1, imm)
276 #  define SMULcc(rs1, rs2, rd)          f3r(2, rd, 27, rs1, rs2)
277 #  define SMULIcc(rs1, imm, rd)         f3i(2, rd, 27, rs1, imm)
278 #  define UDIV(rs1, rs2, rd)            f3r(2, rd, 14, rs1, rs2)
279 #  define UDIVI(rs1, imm, rd)           f3i(2, rd, 14, rs1, imm)
280 #  define SDIV(rs1, rs2, rd)            f3r(2, rd, 15, rs1, rs2)
281 #  define SDIVI(rs1, imm, rd)           f3i(2, rd, 15, rs1, imm)
282 #  define UDIVcc(rs1, rs2, rd)          f3r(2, rd, 30, rs1, rs2)
283 #  define UDIVIcc(rs1, imm, rd)         f3i(2, rd, 30, rs1, imm)
284 #  define SDIVcc(rs1, rs2, rd)          f3r(2, rd, 31, rs1, rs2)
285 #  define SDIVIcc(rs1, imm, rd)         f3i(2, rd, 31, rs1, imm)
286 #  if __WORDSIZE == 64
287 #    define MULX(rs1, rs2, rd)          f3r(2, rd, 9, rs1, rs2)
288 #    define MULXI(rs1, imm, rd)         f3i(2, rd, 9, rs1, imm)
289 #    define SDIVX(rs1, rs2, rd)         f3r(2, rd, 45, rs1, rs2)
290 #    define SDIVXI(rs1, imm, rd)        f3i(2, rd, 45, rs1, imm)
291 #    define UDIVX(rs1, rs2, rd)         f3r(2, rd, 13, rs1, rs2)
292 #    define UDIVXI(rs1, imm, rd)        f3i(2, rd, 13, rs1, imm)
293 #  endif
294 #  define SAVE(rs1, rs2, rd)            f3r(2, rd, 60, rs1, rs2)
295 #  define SAVEI(rs1, imm, rd)           f3i(2, rd, 60, rs1, imm)
296 #  define RESTORE(rs1, rs2, rd)         f3r(2, rd, 61, rs1, rs2)
297 #  define RESTOREI(rs1, imm, rd)        f3i(2, rd, 61, rs1, imm)
298 #  define SPARC_BA                      8       /* always */
299 #  define SPARC_BN                      0       /* never */
300 #  define SPARC_BNE                     9       /* not equal - not Z */
301 #  define SPARC_BNZ                     SPARC_BNE
302 #  define SPARC_BE                      1       /* equal - Z */
303 #  define SPARC_BZ                      SPARC_BE
304 #  define SPARC_BG                      10      /* greater - not (Z or (N xor V)) */
305 #  define SPARC_BLE                     2       /* less or equal - Z or (N xor V) */
306 #  define SPARC_BGE                     11      /* greater or equal - not (N xor V) */
307 #  define SPARC_BL                      3       /* less - N xor V */
308 #  define SPARC_BGU                     12      /* greater unsigned - not (C or Z) */
309 #  define SPARC_BLEU                    4       /* less or equal unsigned - C or Z */
310 #  define SPARC_BCC                     13      /* carry clear - not C */
311 #  define SPARC_BGEU                    SPARC_BCC
312 #  define SPARC_BCS                     5       /* carry set - C */
313 #  define SPARC_BLU                     SPARC_BCS
314 #  define SPARC_BPOS                    14      /* positive - not N */
315 #  define SPARC_BNEG                    6       /* negative - N */
316 #  define SPARC_BVC                     15      /* overflow clear - not V */
317 #  define SPARC_BVS                     7       /* overflow set - V */
318 /* Preferred BPcc integer branch opcodes */
319 #  if __WORDSIZE == 64
320 #    define SPARC_BPA                   8       /* always - 1 */
321 #    define SPARC_BPN                   0       /* never - 0 */
322 #    define SPARC_BPNE                  9       /* not equal - not Z */
323 #    define SPARC_BPE                   1       /* equal - Z */
324 #    define SPARC_BPG                   10      /* greater - not (Z or (N xor V)) */
325 #    define SPARC_BPLE                  2       /* less or equal - Z or (N xor V) */
326 #    define SPARC_BPGE                  11      /* greater or equal - not (N xor V) */
327 #    define SPARC_BPL                   3       /* less - N xor V */
328 #    define SPARC_BPGU                  12      /* greater unsigned - not (C or V) */
329 #    define SPARC_BPLEU                 4       /* less or equal unsigned  - C or Z */
330 #    define SPARC_BPCC                  13      /* carry clear (greater than or equal, unsigned) - not C */
331 #    define SPARC_BPCS                  5       /* carry set (less than, unsigned) - C */
332 #    define SPARC_BPPOS                 14      /* positive - not N */
333 #    define SPARC_BPNEG                 6       /* negative - N */
334 #    define SPARC_BPVC                  15      /* overflow clear - not V */
335 #    define SPARC_BPVS                  7       /* overflow set - V */
336 #  endif
337 #  define B(cc, imm)                    f2b(0, 0, cc, 2, imm)
338 #  define Ba(cc, imm)                   f2b(0, 1, cc, 2, imm)
339 #  define BA(imm)                       B(SPARC_BA, imm)
340 #  define BAa(imm)                      Ba(SPARC_BA, imm)
341 #  define BN(imm)                       B(SPARC_BN, imm)
342 #  define BNa(imm)                      Ba(SPARC_BN, imm)
343 #  define BNE(imm)                      B(SPARC_BNE, imm)
344 #  define BNEa(imm)                     Ba(SPARC_BNE, imm)
345 #  define BNZ(imm)                      BNE(imm)
346 #  define BNZa(imm)                     BNEa(imm)
347 #  define BE(imm)                       B(SPARC_BE, imm)
348 #  define BEa(imm)                      Ba(SPARC_BE, imm)
349 #  define BZ(imm)                       BE(imm)
350 #  define BZa(imm)                      BEa(imm)
351 #  define BG(imm)                       B(SPARC_BG, imm)
352 #  define BGa(imm)                      Ba(SPARC_BG, imm)
353 #  define BLE(imm)                      B(SPARC_BLE, imm)
354 #  define BLEa(imm)                     Ba(SPARC_BLE, imm)
355 #  define BGE(imm)                      B(SPARC_BGE, imm)
356 #  define BGEa(imm)                     Ba(SPARC_BGE, imm)
357 #  define BL(imm)                       B(SPARC_BL, imm)
358 #  define BLa(imm)                      Ba(SPARC_BL, imm)
359 #  define BGU(imm)                      B(SPARC_BGU, imm)
360 #  define BGUa(imm)                     Ba(SPARC_BGU, imm)
361 #  define BLEU(imm)                     B(SPARC_BLEU, imm)
362 #  define BLEUa(imm)                    Ba(SPARC_BLEU, imm)
363 #  define BCC(imm)                      B(SPARC_BCC, imm)
364 #  define BCCa(imm)                     Ba(SPARC_BCC, imm)
365 #  define BGEU(imm)                     BCC(imm)
366 #  define BGEUa(imm)                    BCCa(imm)
367 #  define BCS(imm)                      B(SPARC_BCS, imm)
368 #  define BCSa(imm)                     Ba(SPARC_BCS, imm)
369 #  define BLU(imm)                      BCS(imm)
370 #  define BLUa(imm)                     BCSa(imm)
371 #  define BPOS(imm)                     B(SPARC_BPOS, imm)
372 #  define BPOSa(imm)                    Ba(SPARC_BPOS, imm)
373 #  define BNEG(imm)                     B(SPARC_BNEG, imm)
374 #  define BNEGa(imm)                    Ba(SPARC_BNEG, imm)
375 #  define BVC(imm)                      B(SPARC_BVC, imm)
376 #  define BVCa(imm)                     Ba(SPARC_BVC, imm)
377 #  define BVS(imm)                      B(SPARC_BVS, imm)
378 #  define BVSa(imm)                     Ba(SPARC_BVS, imm)
379 #  if __WORDSIZE == 64
380 #    define BPccap(cc,a,cc1, cc2,p,imm) f2bp(0, a, cc, 1, cc1, cc0, p, imm)
381 #    define BPap(cc, imm)               f2bp(0, 1, cc, 1, 1, 0, p, imm)
382 #    define BPa(cc, imm)                f2bp(0, 1, cc, 1, 1, 0, 1, imm)
383 #    define BP(cc, imm)                 f2bp(0, 0, cc, 1, 1, 0, 1, imm)
384 #    define BPA(imm)                    BP(SPARC_BPA, imm)
385 #    define BPN(imm)                    BP(SPARC_BPN, imm)
386 #    define BNPE(imm)                   BP(SPARC_BPNE, imm)
387 #    define BPE(imm)                    BP(SPARC_BPE, imm)
388 #    define BPG(imm)                    BP(SPARC_BPG, imm)
389 #    define BPLE(imm)                   BP(SPARC_BPLE, imm)
390 #    define BPGE(imm)                   BP(SPARC_BPGE, imm)
391 #    define BPL(imm)                    BP(SPARC_BPL, imm)
392 #    define BPGU(imm)                   BP(SPARC_BPGU, imm)
393 #    define BPLEU(imm)                  BP(SPARC_BPLEU, imm)
394 #    define BPCC(imm)                   BP(SPARC_BPCC, imm)
395 #    define BPCS(imm)                   BP(SPARC_BPCS, imm)
396 #    define BPPOS(imm)                  BP(SPARC_BPPOS, imm)
397 #    define BPNEG(imm)                  BP(SPARC_BPNEG, imm)
398 #    define BPVC(imm)                   BP(SPARC_BPVC, imm)
399 #    define BPVS(imm)                   BP(SPARC_BPVS, imm)
400 #  endif
401 #  define SPARC_CBA                     8       /* always */
402 #  define SPARC_CBN                     0       /* never */
403 #  define SPARC_CB3                     7       /* 3 */
404 #  define SPARC_CB2                     6       /* 2 */
405 #  define SPARC_CB23                    5       /* 2 or 3 */
406 #  define SPARC_CB1                     4       /* 1 */
407 #  define SPARC_CB13                    3       /* 1 or 3 */
408 #  define SPARC_CB12                    2       /* 1 or 2 */
409 #  define SPARC_CB123                   1       /* 1 or 2 or 3 */
410 #  define SPARC_CB0                     9       /* 0 */
411 #  define SPARC_CB03                    10      /* 0 or 3 */
412 #  define SPARC_CB02                    11      /* 0 or 2 */
413 #  define SPARC_CB023                   12      /* 0 or 2 or 3 */
414 #  define SPARC_CB01                    13      /* 0 or 1 */
415 #  define SPARC_CB013                   14      /* 0 or 1 or 3 */
416 #  define SPARC_CB012                   15      /* 0 or 1 or 2 */
417 #  define CB(cc, imm)                   f2b(0, 0, cc, 7, imm)
418 #  define CBa(cc, imm)                  f2b(0, 1, cc, 7, imm)
419 #  define CBA(imm)                      CB(SPARC_CBA, imm)
420 #  define CBAa(imm)                     CBa(SPARC_CBA, imm)
421 #  define CBN(imm)                      CB(SPARC_CBN, imm)
422 #  define CBNa(imm)                     CBa(SPARC_CBN, imm)
423 #  define CB3(imm)                      CB(SPARC_CB3, imm)
424 #  define CB3a(imm)                     CBa(SPARC_CB3, imm)
425 #  define CB2(imm)                      CB(SPARC_CB2, imm)
426 #  define CB2a(imm)                     CBa(SPARC_CB2, imm)
427 #  define CB23(imm)                     CB(SPARC_CB23, imm)
428 #  define CB23a(imm)                    CBa(SPARC_CB23, imm)
429 #  define CB1(imm)                      CB(SPARC_CB1, imm)
430 #  define CB1a(imm)                     CBa(SPARC_CB1, imm)
431 #  define CB13(imm)                     CB(SPARC_CB13, imm)
432 #  define CB13a(imm)                    CBa(SPARC_CB13, imm)
433 #  define CB12(imm)                     CB(SPARC_CB12, imm)
434 #  define CB12a(imm)                    CBa(SPARC_CB12, imm)
435 #  define CB123(imm)                    CB(SPARC_CB123, imm)
436 #  define CB123a(imm)                   CBa(SPARC_CB123, imm)
437 #  define CB0(imm)                      CB(SPARC_CB0, imm)
438 #  define CB0a(imm)                     CBa(SPARC_CB0, imm)
439 #  define CB03(imm)                     CB(SPARC_CB03, imm)
440 #  define CB03a(imm)                    CBa(SPARC_CB03, imm)
441 #  define CB02(imm)                     CB(SPARC_CB02, imm)
442 #  define CB02a(imm)                    CBa(SPARC_CB02, imm)
443 #  define CB023(imm)                    CB(SPARC_CB103, imm)
444 #  define CB023a(imm)                   CBa(SPARC_CB023, imm)
445 #  define CB01(imm)                     CB(SPARC_CB01, imm)
446 #  define CB01a(imm)                    CBa(SPARC_CB01, imm)
447 #  define CB013(imm)                    CB(SPARC_CB013, imm)
448 #  define CB013a(imm)                   CBa(SPARC_CB013, imm)
449 #  define CB012(imm)                    CB(SPARC_CB012, imm)
450 #  define CB012a(imm)                   CBa(SPARC_CB012, imm)
451 #  define CALLI(imm)                    f1(1, imm)
452 #  define CALL(r0)                      JMPL(_O7_REGNO, r0, 0)
453 #  define RETL()                        JMPLI(0, _O7_REGNO, 8)
454 #  define RET()                         JMPLI(0, _I7_REGNO, 8)
455 #  define JMPL(rd, rs1, rs2)            f3r(2, rd, 56, rs1, rs2)
456 #  define JMPLI(rd, rs1, imm)           f3i(2, rd, 56, rs1, imm)
457 #  define RETT(rs1, rs2)                f3r(2, 0, 57, rs1, rs2)
458 #  define RETTI(rs1, imm)               f3i(2, 0, 57, rs1, imm)
459 #  define SPARC_TA                      8       /* always */
460 #  define SPARC_TN                      0       /* never */
461 #  define SPARC_TNE                     9       /* not equal - not Z */
462 #  define SPARC_TNZ                     SPARC_BNE
463 #  define SPARC_TE                      1       /* equal - Z */
464 #  define SPARC_TZ                      SPARC_BE
465 #  define SPARC_TG                      10      /* greater - not (Z or (N xor V)) */
466 #  define SPARC_TLE                     2       /* less or equal - Z or (N xor V) */
467 #  define SPARC_TGE                     11      /* greater or equal - not (N xor V) */
468 #  define SPARC_TL                      3       /* less - N xor V */
469 #  define SPARC_TGU                     12      /* greater unsigned - not (C or Z) */
470 #  define SPARC_TLEU                    4       /* less or equal unsigned - C or Z */
471 #  define SPARC_TCC                     13      /* carry clear - not C */
472 #  define SPARC_TGEU                    SPARC_BCC
473 #  define SPARC_TCS                     5       /* carry set - C */
474 #  define SPARC_TLU                     SPARC_BCS
475 #  define SPARC_TPOS                    14      /* positive - not N */
476 #  define SPARC_TNEG                    6       /* negative - N */
477 #  define SPARC_TVC                     15      /* overflow clear - not V */
478 #  define SPARC_TVS                     7       /* overflow set - V */
479 #  define T(cc, rs1, rs2)               f3t(cc, rs1, 0, rs2)
480 #  define TI(cc, rs1, imm)              f3t(cc, rs1, 1, imm)
481 #  define TA(rs1, rs2)                  T(SPARC_TA, rs1, rs2)
482 #  define TAI(rs1, imm)                 TI(SPARC_TA, rs1, imm)
483 #  define TN(rs1, rs2)                  T(SPARC_TN, rs1, rs2)
484 #  define TNI(rs1, imm)                 TI(SPARC_TN, rs1, imm)
485 #  define TNE(rs1, rs2)                 T(SPARC_TNE, rs1, rs2)
486 #  define TNEI(rs1, imm)                TI(SPARC_TNE, rs1, imm)
487 #  define TNZ(rs1, rs2)                 TNE(rs1, rs2)
488 #  define TNZI(rs1, imm)                TNEI(rs1, imm)
489 #  define TE(rs1, rs2)                  T(SPARC_TE, rs1, rs2)
490 #  define TEI(rs1, imm)                 TI(SPARC_TE, rs1, imm)
491 #  define TZ(rs1, rs2)                  TE(rs1, rs2)
492 #  define TZI(rs1, imm)                 TEI(rs1, imm)
493 #  define TG(rs1, rs2)                  T(SPARC_TG, rs1, rs2)
494 #  define TGI(rs1, imm)                 TI(SPARC_TG, rs1, imm)
495 #  define TLE(rs1, rs2)                 T(SPARC_TLE, rs1, rs2)
496 #  define TLEI(rs1, imm)                TI(SPARC_TLE, rs1, imm)
497 #  define TGE(rs1, rs2)                 T(SPARC_TGE, rs1, rs2)
498 #  define TGEI(rs1, imm)                TI(SPARC_TGE, rs1, imm)
499 #  define TL(rs1, rs2)                  T(SPARC_TL, rs1, rs2)
500 #  define TLI(rs1, imm)                 TI(SPARC_TL, rs1, imm)
501 #  define TGU(rs1, rs2)                 T(SPARC_TGU, rs1, rs2)
502 #  define TGUI(rs1, imm)                TI(SPARC_TGU, rs1, imm)
503 #  define TLEU(rs1, rs2)                T(SPARC_TLEU, rs1, rs2)
504 #  define TLEUI(rs1, imm)               TI(SPARC_TLEU, rs1, imm)
505 #  define TCC(rs1, rs2)                 T(SPARC_TCC, rs1, rs2)
506 #  define TCCI(rs1, imm)                TI(SPARC_TCC, rs1, imm)
507 #  define TGEU(rs1, rs2)                TCC(rs1, rs2)
508 #  define TGEUI(rs1, imm)               TCCI(rs1, imm)
509 #  define TCS(rs1, rs2)                 T(SPARC_TCC, rs1, rs2)
510 #  define TCSI(rs1, imm)                TI(SPARC_TCC, rs1, imm)
511 #  define TLU(rs1, rs2)                 TCS(rs1, rs2)
512 #  define TLUI(rs1, imm)                TCSI(rs1, imm)
513 #  define TPOS(rs1, rs2)                T(SPARC_TPOS, rs1, rs2)
514 #  define TPOSI(rs1, imm)               TI(SPARC_TPOS, rs1, imm)
515 #  define TNEG(rs1, rs2)                T(SPARC_TNEG, rs1, rs2)
516 #  define TNEGI(rs1, imm)               TI(SPARC_TNEG, rs1, imm)
517 #  define TVC(rs1, rs2)                 T(SPARC_TVC, rs1, rs2)
518 #  define TVCI(rs1, imm)                TI(SPARC_TVC, rs1, imm)
519 #  define TVS(rs1, rs2)                 T(SPARC_TVS, rs1, rs2)
520 #  define TVSI(rs1, imm)                TI(SPARC_TVS, rs1, imm)
521 #  define RDY(rd)                       f3r(2, rd, 40, 0, 0)
522 #  define RDASR(rs1, rd)                f3r(2, rd, 40, rs1, 0)
523 #  define RDPSR(rd)                     f3r(2, rd, 41, 0, 0)
524 #  define RDWIM(rd)                     f3r(2, rd, 42, 0, 0)
525 #  define RDTBR(rd)                     f3r(2, rd, 43, 0, 0)
526 #  define WRY(rs1, rs2)                 f3r(2, 0, 48, rs1, rs2)
527 #  define WRYI(rs1, imm)                f3i(2, 0, 48, rs1, imm)
528 #  define WRASR(rs1, rs2, rd)           f3r(2, rd, 48, rs1, rs2)
529 #  define WRASRI(rs1, imm, rd)          f3i(2, rd, 48, rs1, imm)
530 #  define WRPSR(rs1, rs2, rd)           f3r(2, rd, 49, rs1, rs2)
531 #  define WRPSRI(rs1, imm, rd)          f3i(2, rd, 49, rs1, imm)
532 #  define WRWIM(rs1, rs2, rd)           f3r(2, rd, 50, rs1, rs2)
533 #  define WRWIMI(rs1, imm, rd)          f3i(2, rd, 50, rs1, imm)
534 #  define WRTBR(rs1, rs2, rd)           f3r(2, rd, 51, rs1, rs2)
535 #  define WRTBRI(rs1, imm, rd)          f3i(2, rd, 51, rs1, imm)
536 #  define STBAR()                       f3i(2, 0, 40, 15, 0)
537 #  define UNIMP(imm)                    f2r(0, 0, 0, imm)
538 #  define FLUSH(rs1, rs2)               f3r(2, 0, 59, rs1, rs2)
539 #  define FLUSHI(rs1, im)               f3i(2, 0, 59, rs1, imm)
540 #  define nop(i0)                       _nop(_jit, i0)
541 static void _nop(jit_state_t*, jit_int32_t);
542 #  define movr(r0, r1)                  _movr(_jit, r0, r1)
543 static void _movr(jit_state_t*, jit_int32_t, jit_int32_t);
544 #  define movi(r0, i0)                  _movi(_jit, r0, i0)
545 static void _movi(jit_state_t*, jit_int32_t, jit_word_t);
546 #  define movi_p(r0, i0)                _movi_p(_jit, r0, i0)
547 static jit_word_t _movi_p(jit_state_t*, jit_int32_t, jit_word_t);
548 #  define bswapr_us(r0, r1)             generic_bswapr_us(_jit, r0, r1)
549 #  define bswapr_ui(r0, r1)             generic_bswapr_ui(_jit, r0, r1)
550 #  define bswapr_ul(r0, r1)             generic_bswapr_ul(_jit, r0, r1)
551 #  define movnr(r0,r1,r2)               _movnr(_jit,r0,r1,r2)
552 static void _movnr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
553 #  define movzr(r0,r1,r2)               _movzr(_jit,r0,r1,r2)
554 static void _movzr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
555 #  define comr(r0, r1)                  XNOR(r1, 0, r0)
556 #  define negr(r0, r1)                  NEG(r1, r0)
557 #  define addr(r0, r1, r2)              ADD(r1, r2, r0)
558 #  define addi(r0, r1, i0)              _addi(_jit, r0, r1, i0)
559 static void _addi(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
560 #  if __WORDSIZE == 32
561 #    define addcr(r0, r1, r2)           ADDcc(r1, r2, r0)
562 #  else
563 #    define addcr(r0, r1, r2)           _addcr(_jit, r0, r1, r2)
564 static void _addcr(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
565 #  endif
566 #  define addci(r0, r1, i0)             _addci(_jit, r0, r1, i0)
567 static void _addci(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
568 #  if __WORDSIZE == 32
569 #    define addxr(r0, r1, r2)           ADDXcc(r1, r2, r0)
570 #  else
571 #    define addxr(r0, r1, r2)           _addxr(_jit, r0, r1, r2)
572 static void _addxr(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
573 #  endif
574 #  define addxi(r0, r1, i0)             _addxi(_jit, r0, r1, i0)
575 static void _addxi(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
576 #  define subr(r0, r1, r2)              SUB(r1, r2, r0)
577 #  define subi(r0, r1, i0)              _subi(_jit, r0, r1, i0)
578 static void _subi(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
579 #  if __WORDSIZE == 32
580 #    define subcr(r0, r1, r2)           SUBcc(r1, r2, r0)
581 #  else
582 #    define subcr(r0, r1, r2)           _subcr(_jit, r0, r1, r2)
583 static void _subcr(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
584 #  endif
585 #  define subci(r0, r1, i0)             _subci(_jit, r0, r1, i0)
586 static void _subci(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
587 #  if __WORDSIZE == 32
588 #    define subxr(r0, r1, r2)           SUBXcc(r1, r2, r0)
589 #  else
590 #    define subxr(r0, r1, r2)           _subxr(_jit, r0, r1, r2)
591 static void _subxr(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
592 #  endif
593 #  define subxi(r0, r1, i0)             _subxi(_jit, r0, r1, i0)
594 static void _subxi(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
595 #  define rsbi(r0, r1, i0)              _rsbi(_jit, r0, r1, i0)
596 static void _rsbi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
597 #  if __WORDSIZE == 32
598 #    define mulr(r0, r1, r2)            UMUL(r1, r2, r0)
599 #  else
600 #    define mulr(r0, r1, r2)            MULX(r1, r2, r0)
601 #  endif
602 #  define muli(r0, r1, i0)              _muli(_jit, r0, r1, i0)
603 static void _muli(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
604 #  if __WORDSIZE == 32
605 #    define qmulr(r0,r1,r2,r3)          iqmulr(r0,r1,r2,r3,1)
606 #    define qmulr_u(r0,r1,r2,r3)        iqmulr(r0,r1,r2,r3,0)
607 #    define iqmulr(r0,r1,r2,r3,cc)      _iqmulr(_jit,r0,r1,r2,r3,cc)
608 static void _iqmulr(jit_state_t*,jit_int32_t,jit_int32_t,
609                     jit_int32_t,jit_int32_t,jit_bool_t);
610 #  define qmuli(r0,r1,r2,i0)            iqmuli(r0,r1,r2,i0,1)
611 #  define qmuli_u(r0,r1,r2,i0)          iqmuli(r0,r1,r2,i0,0)
612 #  define iqmuli(r0,r1,r2,i0,cc)        _iqmuli(_jit,r0,r1,r2,i0,cc)
613 static void _iqmuli(jit_state_t*,jit_int32_t,jit_int32_t,
614                     jit_int32_t,jit_word_t,jit_bool_t);
615 #  else
616 #    define qmulr(r0,r1,r2,r3)          _qmulr(_jit,r0,r1,r2,r3)
617 static void _qmulr(jit_state_t*,jit_int32_t,jit_int32_t,
618                    jit_int32_t,jit_int32_t);
619 #  define qmuli(r0,r1,r2,i0)            _qmuli(_jit,r0,r1,r2,i0)
620 static void _qmuli(jit_state_t*,jit_int32_t,jit_int32_t,
621                    jit_int32_t,jit_word_t);
622 #    define qmulr_u(r0,r1,r2,r3)        _qmulr_u(_jit,r0,r1,r2,r3)
623 static void _qmulr_u(jit_state_t*,jit_int32_t,jit_int32_t,
624                      jit_int32_t,jit_int32_t);
625 #  define qmuli_u(r0,r1,r2,i0)          _qmuli_u(_jit,r0,r1,r2,i0)
626 static void _qmuli_u(jit_state_t*,jit_int32_t,jit_int32_t,
627                      jit_int32_t,jit_word_t);
628 #  endif
629 #  define divr(r0, r1, r2)              _divr(_jit, r0, r1, r2)
630 static void _divr(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
631 #  define divi(r0, r1, i0)              _divi(_jit, r0, r1, i0)
632 static void _divi(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
633 #  define divr_u(r0, r1, r2)            _divr_u(_jit, r0, r1, r2)
634 static void _divr_u(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
635 #  define divi_u(r0, r1, i0)            _divi_u(_jit, r0, r1, i0)
636 static void _divi_u(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
637 #  define qdivr(r0,r1,r2,r3)            iqdivr(r0,r1,r2,r3,1)
638 #  define qdivr_u(r0,r1,r2,r3)          iqdivr(r0,r1,r2,r3,0)
639 #  define iqdivr(r0,r1,r2,r3,cc)        _iqdivr(_jit,r0,r1,r2,r3,cc)
640 static void _iqdivr(jit_state_t*,jit_int32_t,jit_int32_t,
641                     jit_int32_t,jit_int32_t,jit_bool_t);
642 #  define qdivi(r0,r1,r2,i0)            iqdivi(r0,r1,r2,i0,1)
643 #  define qdivi_u(r0,r1,r2,i0)          iqdivi(r0,r1,r2,i0,0)
644 #  define iqdivi(r0,r1,r2,i0,cc)        _iqdivi(_jit,r0,r1,r2,i0,cc)
645 static void _iqdivi(jit_state_t*,jit_int32_t,jit_int32_t,
646                     jit_int32_t,jit_word_t,jit_bool_t);
647 #  define remr(r0, r1, r2)              _remr(_jit, r0, r1, r2)
648 static void _remr(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
649 #  define remi(r0, r1, i0)              _remi(_jit, r0, r1, i0)
650 static void _remi(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
651 #  define remr_u(r0, r1, r2)            _remr_u(_jit, r0, r1, r2)
652 static void _remr_u(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
653 #  define remi_u(r0, r1, i0)            _remi_u(_jit, r0, r1, i0)
654 static void _remi_u(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
655 #  define andr(r0, r1, r2)              AND(r1, r2, r0)
656 #  define andi(r0, r1, i0)              _andi(_jit, r0, r1, i0)
657 static void _andi(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
658 #  define orr(r0, r1, r2)               OR(r1, r2, r0)
659 #  define ori(r0, r1, i0)               _ori(_jit, r0, r1, i0)
660 static void _ori(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
661 #  define xorr(r0, r1, r2)              XOR(r1, r2, r0)
662 #  define xori(r0, r1, i0)              _xori(_jit, r0, r1, i0)
663 static void _xori(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
664 #  if __WORDSIZE == 32
665 #    define lshr(r0, r1, r2)            SLL(r1, r2, r0)
666 #    define lshi(r0, r1, i0)            SLLI(r1, i0, r0)
667 #    define rshr(r0, r1, r2)            SRA(r1, r2, r0)
668 #    define rshi(r0, r1, i0)            SRAI(r1, i0, r0)
669 #    define rshr_u(r0, r1, r2)          SRL(r1, r2, r0)
670 #    define rshi_u(r0, r1, i0)          SRLI(r1, i0, r0)
671 #  else
672 #    define lshr(r0, r1, r2)            SLLX(r1, r2, r0)
673 #    define lshi(r0, r1, i0)            SLLXI(r1, i0, r0)
674 #    define rshr(r0, r1, r2)            SRAX(r1, r2, r0)
675 #    define rshi(r0, r1, i0)            SRAXI(r1, i0, r0)
676 #    define rshr_u(r0, r1, r2)          SRLX(r1, r2, r0)
677 #    define rshi_u(r0, r1, i0)          SRLXI(r1, i0, r0)
678 #  endif
679 #  define extr_c(r0,r1)                 _extr_c(_jit,r0,r1)
680 static void _extr_c(jit_state_t*,jit_int32_t,jit_int32_t);
681 #  define extr_uc(r0,r1)                andi(r0, r1, 0xff)
682 #  define extr_s(r0,r1)                 _extr_s(_jit,r0,r1)
683 static void _extr_s(jit_state_t*,jit_int32_t,jit_int32_t);
684 #  define extr_us(r0,r1)                _extr_us(_jit,r0,r1)
685 static void _extr_us(jit_state_t*,jit_int32_t,jit_int32_t);
686 #  if __WORDSIZE == 64
687 #    define extr_i(r0,r1)               _extr_i(_jit,r0,r1)
688 static void _extr_i(jit_state_t*,jit_int32_t,jit_int32_t);
689 #    define extr_ui(r0,r1)              _extr_ui(_jit,r0,r1)
690 static void _extr_ui(jit_state_t*,jit_int32_t,jit_int32_t);
691 #  endif
692 #  define cr(cc, r0, r1, r2)            _cr(_jit, cc, r0, r1, r2)
693 static void _cr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
694 #  define cw(cc, r0, r1, i0)            _cw(_jit, cc, r0, r1, i0)
695 static void _cw(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
696 #  if __WORDSIZE == 32
697 #    define ltr(r0, r1, r2)             cr(SPARC_BL, r0, r1, r2)
698 #    define lti(r0, r1, i0)             cw(SPARC_BL, r0, r1, i0)
699 #    define ltr_u(r0, r1, r2)           cr(SPARC_BLU, r0, r1, r2)
700 #    define lti_u(r0, r1, i0)           cw(SPARC_BLU, r0, r1, i0)
701 #    define ler(r0, r1, r2)             cr(SPARC_BLE, r0, r1, r2)
702 #    define lei(r0, r1, i0)             cw(SPARC_BLE, r0, r1, i0)
703 #    define ler_u(r0, r1, r2)           cr(SPARC_BLEU, r0, r1, r2)
704 #    define lei_u(r0, r1, i0)           cw(SPARC_BLEU, r0, r1, i0)
705 #    define eqr(r0, r1, r2)             cr(SPARC_BE, r0, r1, r2)
706 #    define eqi(r0, r1, i0)             cw(SPARC_BE, r0, r1, i0)
707 #    define ger(r0, r1, r2)             cr(SPARC_BGE, r0, r1, r2)
708 #    define gei(r0, r1, i0)             cw(SPARC_BGE, r0, r1, i0)
709 #    define ger_u(r0, r1, r2)           cr(SPARC_BGEU, r0, r1, r2)
710 #    define gei_u(r0, r1, i0)           cw(SPARC_BGEU, r0, r1, i0)
711 #    define gtr(r0, r1, r2)             cr(SPARC_BG, r0, r1, r2)
712 #    define gti(r0, r1, i0)             cw(SPARC_BG, r0, r1, i0)
713 #    define gtr_u(r0, r1, r2)           cr(SPARC_BGU, r0, r1, r2)
714 #    define gti_u(r0, r1, i0)           cw(SPARC_BGU, r0, r1, i0)
715 #    define ner(r0, r1, r2)             cr(SPARC_BNE, r0, r1, r2)
716 #    define nei(r0, r1, i0)             cw(SPARC_BNE, r0, r1, i0)
717 #  else
718 #  define ltr(r0, r1, r2)               cr(SPARC_BPL, r0, r1, r2)
719 #  define lti(r0, r1, i0)               cw(SPARC_BPL, r0, r1, i0)
720 #  define ltr_u(r0, r1, r2)             cr(SPARC_BPCS, r0, r1, r2)
721 #  define lti_u(r0, r1, i0)             cw(SPARC_BPCS, r0, r1, i0)
722 #  define ler(r0, r1, r2)               cr(SPARC_BPLE, r0, r1, r2)
723 #  define lei(r0, r1, i0)               cw(SPARC_BPLE, r0, r1, i0)
724 #  define ler_u(r0, r1, r2)             cr(SPARC_BPLEU, r0, r1, r2)
725 #  define lei_u(r0, r1, i0)             cw(SPARC_BPLEU, r0, r1, i0)
726 #  define eqr(r0, r1, r2)               cr(SPARC_BPE, r0, r1, r2)
727 #  define eqi(r0, r1, i0)               cw(SPARC_BPE, r0, r1, i0)
728 #  define ger(r0, r1, r2)               cr(SPARC_BPGE, r0, r1, r2)
729 #  define gei(r0, r1, i0)               cw(SPARC_BPGE, r0, r1, i0)
730 #  define ger_u(r0, r1, r2)             cr(SPARC_BPCC, r0, r1, r2)
731 #  define gei_u(r0, r1, i0)             cw(SPARC_BPCC, r0, r1, i0)
732 #  define gtr(r0, r1, r2)               cr(SPARC_BPG, r0, r1, r2)
733 #  define gti(r0, r1, i0)               cw(SPARC_BPG, r0, r1, i0)
734 #  define gtr_u(r0, r1, r2)             cr(SPARC_BPGU, r0, r1, r2)
735 #  define gti_u(r0, r1, i0)             cw(SPARC_BPGU, r0, r1, i0)
736 #  define ner(r0, r1, r2)               cr(SPARC_BPNE, r0, r1, r2)
737 #  define nei(r0, r1, i0)               cw(SPARC_BPNE, r0, r1, i0)
738 #  endif
739 #  define ldr_c(r0, r1)                 LDSB(r1, 0, r0)
740 #  define ldi_c(r0, i0)                 _ldi_c(_jit, r0, i0)
741 static void _ldi_c(jit_state_t*,jit_int32_t,jit_word_t);
742 #  define ldr_uc(r0, r1)                LDUB(r1, 0, r0)
743 #  define ldi_uc(r0, i0)                _ldi_uc(_jit, r0, i0)
744 static void _ldi_uc(jit_state_t*,jit_int32_t,jit_word_t);
745 #  define ldr_s(r0, r1)                 LDSH(r1, 0, r0)
746 #  define ldi_s(r0, i0)                 _ldi_s(_jit, r0, i0)
747 static void _ldi_s(jit_state_t*,jit_int32_t,jit_word_t);
748 #  define ldr_us(r0, r1)                LDUH(r1, 0, r0)
749 #  define ldi_us(r0, i0)                _ldi_us(_jit, r0, i0)
750 static void _ldi_us(jit_state_t*,jit_int32_t,jit_word_t);
751 #  if __WORDSIZE == 32
752 #    define ldr_i(r0, r1)               LD(r1, 0, r0)
753 #    define ldr(u, v)                   ldr_i(u, v)
754 #    define ldi(u, v)                   ldi_i(u, v)
755 #  else
756 #    define ldr_i(r0, r1)               LDSW(r1, 0, r0)
757 #    define ldr_ui(r0, r1)              LDUW(r1, 0, r0)
758 #    define ldr_l(r0, r1)               LDX(r1, 0, r0)
759 #    define ldr(u, v)                   ldr_l(u, v)
760 #    define ldi(u, v)                   ldi_l(u, v)
761 #  endif
762 #  define ldi_i(r0, i0)                 _ldi_i(_jit, r0, i0)
763 static void _ldi_i(jit_state_t*,jit_int32_t,jit_word_t);
764 #  if __WORDSIZE == 64
765 #    define ldi_ui(r0, i0)              _ldi_ui(_jit, r0, i0)
766 static void _ldi_ui(jit_state_t*,jit_int32_t,jit_word_t);
767 #    define ldi_l(r0, i0)               _ldi_l(_jit, r0, i0)
768 static void _ldi_l(jit_state_t*,jit_int32_t,jit_word_t);
769 #  endif
770 #  define ldxr_c(r0, r1, r2)            LDSB(r1, r2, r0)
771 #  define ldxi_c(r0, r1, i0)            _ldxi_c(_jit, r0, r1, i0)
772 static void _ldxi_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
773 #  define ldxr_uc(r0, r1, r2)           LDUB(r1, r2, r0)
774 #  define ldxi_uc(r0, r1, i0)           _ldxi_uc(_jit, r0, r1, i0)
775 static void _ldxi_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
776 #  define ldxr_s(r0, r1, r2)            LDSH(r1, r2, r0)
777 #  define ldxi_s(r0, r1, i0)            _ldxi_s(_jit, r0, r1, i0)
778 static void _ldxi_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
779 #  define ldxr_us(r0, r1, r2)           LDUH(r1, r2, r0)
780 #  define ldxi_us(r0, r1, i0)           _ldxi_us(_jit, r0, r1, i0)
781 static void _ldxi_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
782 #  if __WORDSIZE == 32
783 #    define ldxr(u, v, w)               ldxr_i(u, v, w)
784 #    define ldxr_i(r0, r1, r2)          LD(r1, r2, r0)
785 #    define ldxi(u, v, w)               ldxi_i(u, v, w)
786 #  else
787 #    define ldxr(u, v, w)               ldxr_l(u, v, w)
788 #    define ldxr_i(r0, r1, r2)          LDSW(r1, r2, r0)
789 #    define ldxr_ui(r0, r1, r2)         LDUW(r1, r2, r0)
790 #    define ldxr_l(r0, r1, r2)          LDX(r1, r2, r0)
791 #    define ldxi(u, v, w)               ldxi_l(u, v, w)
792 #  endif
793 #  define ldxi_i(r0, r1, i0)            _ldxi_i(_jit, r0, r1, i0)
794 static void _ldxi_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
795 #  if __WORDSIZE == 64
796 #    define ldxi_ui(r0, r1, i0)         _ldxi_ui(_jit, r0, r1, i0)
797 static void _ldxi_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
798 #    define ldxi_l(r0, r1, i0)          _ldxi_l(_jit, r0, r1, i0)
799 static void _ldxi_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
800 #  endif
801 #  define str_c(r0, r1)                 STB(r1, r0, 0)
802 #  define sti_c(i0, r0)                 _sti_c(_jit, i0, r0)
803 static void _sti_c(jit_state_t*,jit_word_t,jit_int32_t);
804 #  define str_s(r0, r1)                 STH(r1, r0, 0)
805 #  define sti_s(i0, r0)                 _sti_s(_jit, i0, r0)
806 static void _sti_s(jit_state_t*,jit_word_t,jit_int32_t);
807 #  if __WORDSIZE == 32
808 #    define str(u, v)                   str_i(u, v)
809 #    define str_i(r0, r1)               STI(r1, r0, 0)
810 #    define sti(u, v)                   sti_i(u, v)
811 #  else
812 #    define str(u, v)                   str_l(u, v)
813 #    define str_i(r0, r1)               STW(r1, r0, 0)
814 #    define str_l(r0, r1)               STX(r1, r0, 0)
815 #    define sti(u, v)                   sti_l(u, v)
816 #  endif
817 #  define sti_i(i0, r0)                 _sti_i(_jit, i0, r0)
818 static void _sti_i(jit_state_t*,jit_word_t,jit_int32_t);
819 #  if __WORDSIZE == 64
820 #    define sti_l(i0, r0)               _sti_l(_jit, i0, r0)
821 static void _sti_l(jit_state_t*,jit_word_t,jit_int32_t);
822 #  endif
823 #  define stxr_c(r0, r1, r2)            STB(r2, r1, r0)
824 #  define stxi_c(i0, r0, r1)            _stxi_c(_jit, i0, r0, r1)
825 static void _stxi_c(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
826 #  define stxr_s(r0, r1, r2)            STH(r2, r1, r0)
827 #  define stxi_s(i0, r0, r1)            _stxi_s(_jit, i0, r0, r1)
828 static void _stxi_s(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
829 #  if __WORDSIZE == 32
830 #    define stxr(u, v, w)               stxr_i(u, v, w)
831 #    define stxr_i(r0, r1, r2)          ST(r2, r1, r0)
832 #    define stxi(u, v, w)               stxi_i(u, v, w)
833 #  else
834 #    define stxr(u, v, w)               stxr_l(u, v, w)
835 #    define stxr_i(r0, r1, r2)          STW(r2, r1, r0)
836 #    define stxi(u, v, w)               stxi_l(u, v, w)
837 #    define stxr_l(r0, r1, r2)          STX(r2, r1, r0)
838 #  endif
839 #  define stxi_i(i0, r0, r1)            _stxi_i(_jit, i0, r0, r1)
840 static void _stxi_i(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
841 #  if __WORDSIZE == 64
842 #    define stxi_l(i0, r0, r1)          _stxi_l(_jit, i0, r0, r1)
843 static void _stxi_l(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
844 #  endif
845 #  define br(cc, i0, r0, r1)            _br(_jit, cc, i0, r0, r1)
846 static jit_word_t
847 _br(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_int32_t);
848 #  define bw(cc, i0, r0, i1)            _bw(_jit, cc, i0, r0, i1)
849 static jit_word_t
850 _bw(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_word_t);
851 #  if __WORDSIZE == 32
852 #    define bltr(i0, r0, r1)            br(SPARC_BL, i0, r0, r1)
853 #    define blti(i0, r0, i1)            bw(SPARC_BL, i0, r0, i1)
854 #    define bltr_u(i0, r0, r1)          br(SPARC_BLU, i0, r0, r1)
855 #    define blti_u(i0, r0, i1)          bw(SPARC_BLU, i0, r0, i1)
856 #    define bler(i0, r0, r1)            br(SPARC_BLE, i0, r0, r1)
857 #    define blei(i0, r0, i1)            bw(SPARC_BLE, i0, r0, i1)
858 #    define bler_u(i0, r0, r1)          br(SPARC_BLEU, i0, r0, r1)
859 #    define blei_u(i0, r0, i1)          bw(SPARC_BLEU, i0, r0, i1)
860 #    define beqr(i0, r0, r1)            br(SPARC_BE, i0, r0, r1)
861 #    define beqi(i0, r0, i1)            bw(SPARC_BE, i0, r0, i1)
862 #    define bger(i0, r0, r1)            br(SPARC_BGE, i0, r0, r1)
863 #    define bgei(i0, r0, i1)            bw(SPARC_BGE, i0, r0, i1)
864 #    define bger_u(i0, r0, r1)          br(SPARC_BGEU, i0, r0, r1)
865 #    define bgei_u(i0, r0, i1)          bw(SPARC_BGEU, i0, r0, i1)
866 #    define bgtr(i0, r0, r1)            br(SPARC_BG, i0, r0, r1)
867 #    define bgti(i0, r0, i1)            bw(SPARC_BG, i0, r0, i1)
868 #    define bgtr_u(i0, r0, r1)          br(SPARC_BGU, i0, r0, r1)
869 #    define bgti_u(i0, r0, i1)          bw(SPARC_BGU, i0, r0, i1)
870 #    define bner(i0, r0, r1)            br(SPARC_BNE, i0, r0, r1)
871 #    define bnei(i0, r0, i1)            bw(SPARC_BNE, i0, r0, i1)
872 #  else
873 #    define bltr(i0, r0, r1)            br(SPARC_BPL, i0, r0, r1)
874 #    define blti(i0, r0, i1)            bw(SPARC_BPL, i0, r0, i1)
875 #    define bltr_u(i0, r0, r1)          br(SPARC_BPCS, i0, r0, r1)
876 #    define blti_u(i0, r0, i1)          bw(SPARC_BPCS, i0, r0, i1)
877 #    define bler(i0, r0, r1)            br(SPARC_BPLE, i0, r0, r1)
878 #    define blei(i0, r0, i1)            bw(SPARC_BPLE, i0, r0, i1)
879 #    define bler_u(i0, r0, r1)          br(SPARC_BPLEU, i0, r0, r1)
880 #    define blei_u(i0, r0, i1)          bw(SPARC_BPLEU, i0, r0, i1)
881 #    define beqr(i0, r0, r1)            br(SPARC_BPE, i0, r0, r1)
882 #    define beqi(i0, r0, i1)            bw(SPARC_BPE, i0, r0, i1)
883 #    define bger(i0, r0, r1)            br(SPARC_BPGE, i0, r0, r1)
884 #    define bgei(i0, r0, i1)            bw(SPARC_BPGE, i0, r0, i1)
885 #    define bger_u(i0, r0, r1)          br(SPARC_BPCC, i0, r0, r1)
886 #    define bgei_u(i0, r0, i1)          bw(SPARC_BPCC, i0, r0, i1)
887 #    define bgtr(i0, r0, r1)            br(SPARC_BPG, i0, r0, r1)
888 #    define bgti(i0, r0, i1)            bw(SPARC_BPG, i0, r0, i1)
889 #    define bgtr_u(i0, r0, r1)          br(SPARC_BPGU, i0, r0, r1)
890 #    define bgti_u(i0, r0, i1)          bw(SPARC_BPGU, i0, r0, i1)
891 #    define bner(i0, r0, r1)            br(SPARC_BPNE, i0, r0, r1)
892 #    define bnei(i0, r0, i1)            bw(SPARC_BPNE, i0, r0, i1)
893 #  endif
894 #  define b_asr(jif,add,sgn,i0,r0,r1)   _b_asr(_jit,jif,add,sgn,i0,r0,r1)
895 static jit_word_t
896 _b_asr(jit_state_t*,jit_bool_t,jit_bool_t,jit_bool_t,
897        jit_word_t,jit_int32_t,jit_int32_t);
898 #  define b_asw(jif,add,sgn,i0,r0,i1)   _b_asw(_jit,jif,add,sgn,i0,r0,i1)
899 static jit_word_t
900 _b_asw(jit_state_t*,jit_bool_t,jit_bool_t,jit_bool_t,
901        jit_word_t,jit_int32_t,jit_word_t);
902 #  define boaddr(i0, r0, r1)            b_asr(1, 1, 1, i0, r0, r1)
903 #  define boaddi(i0, r0, i1)            b_asw(1, 1, 1, i0, r0, i1)
904 #  define boaddr_u(i0, r0, r1)          b_asr(1, 1, 0, i0, r0, r1)
905 #  define boaddi_u(i0, r0, i1)          b_asw(1, 1, 0, i0, r0, i1)
906 #  define bxaddr(i0, r0, r1)            b_asr(0, 1, 1, i0, r0, r1)
907 #  define bxaddi(i0, r0, i1)            b_asw(0, 1, 1, i0, r0, i1)
908 #  define bxaddr_u(i0, r0, r1)          b_asr(0, 1, 0, i0, r0, r1)
909 #  define bxaddi_u(i0, r0, i1)          b_asw(0, 1, 0, i0, r0, i1)
910 #  define bosubr(i0, r0, r1)            b_asr(1, 0, 1, i0, r0, r1)
911 #  define bosubi(i0, r0, i1)            b_asw(1, 0, 1, i0, r0, i1)
912 #  define bosubr_u(i0, r0, r1)          b_asr(1, 0, 0, i0, r0, r1)
913 #  define bosubi_u(i0, r0, i1)          b_asw(1, 0, 0, i0, r0, i1)
914 #  define bxsubr(i0, r0, r1)            b_asr(0, 0, 1, i0, r0, r1)
915 #  define bxsubi(i0, r0, i1)            b_asw(0, 0, 1, i0, r0, i1)
916 #  define bxsubr_u(i0, r0, r1)          b_asr(0, 0, 0, i0, r0, r1)
917 #  define bxsubi_u(i0, r0, i1)          b_asw(0, 0, 0, i0, r0, i1)
918 #  define bm_r(set, i0, r0, r1)         _bm_r(_jit,set,i0,r0,r1)
919 static jit_word_t
920 _bm_r(jit_state_t*,jit_bool_t,jit_word_t,jit_int32_t,jit_int32_t);
921 #  define bm_w(set,i0,r0,i1)            _bm_w(_jit,set,i0,r0,i1)
922 static jit_word_t
923 _bm_w(jit_state_t*,jit_bool_t,jit_word_t,jit_int32_t,jit_word_t);
924 #  define bmsr(i0, r0, r1)              bm_r(1, i0, r0, r1)
925 #  define bmsi(i0, r0, i1)              bm_w(1, i0, r0, i1)
926 #  define bmcr(i0, r0, r1)              bm_r(0, i0, r0, r1)
927 #  define bmci(i0, r0, i1)              bm_w(0, i0, r0, i1)
928 #  define jmpr(r0)                      _jmpr(_jit, r0)
929 static void _jmpr(jit_state_t*,jit_int32_t);
930 #  define jmpi(i0)                      _jmpi(_jit, i0)
931 static void _jmpi(jit_state_t*,jit_word_t);
932 #  define jmpi_p(i0)                    _jmpi_p(_jit, i0)
933 static jit_word_t _jmpi_p(jit_state_t*,jit_word_t);
934 #  define callr(r0)                     _callr(_jit, r0)
935 static void _callr(jit_state_t*,jit_int32_t);
936 #  define calli(i0)                     _calli(_jit, i0)
937 static void _calli(jit_state_t*,jit_word_t);
938 #  define calli_p(i0)                   _calli_p(_jit, i0)
939 static jit_word_t _calli_p(jit_state_t*,jit_word_t);
940 #  define prolog(node)                  _prolog(_jit, node)
941 static void _prolog(jit_state_t*,jit_node_t*);
942 #  define epilog(node)                  _epilog(_jit, node)
943 static void _epilog(jit_state_t*,jit_node_t*);
944 #define vastart(r0)                     _vastart(_jit, r0)
945 static void _vastart(jit_state_t*, jit_int32_t);
946 #define vaarg(r0, r1)                   _vaarg(_jit, r0, r1)
947 static void _vaarg(jit_state_t*, jit_int32_t, jit_int32_t);
948 #define patch_at(jump, label)           _patch_at(_jit, jump, label)
949 static void _patch_at(jit_state_t*,jit_word_t,jit_word_t);
950 #endif
951
952 #if CODE
953 static void
954 _f2r(jit_state_t *_jit,
955      jit_int32_t op, jit_int32_t rd, jit_int32_t op2, jit_int32_t imm22)
956 {
957     jit_instr_t         v;
958     assert(!(op  & 0xfffffffc));
959     assert(!(rd  & 0xffffffe0));
960     assert(!(op2 & 0xfffffff8));
961     assert(s22_p(imm22));
962     v.op.b    = op;
963     v.rd.b    = rd;
964     v.op2.b   = op2;
965     v.imm22.b = imm22;
966     ii(v.v);
967 }
968
969 static void
970 _f2b(jit_state_t *_jit,
971      jit_int32_t op, jit_int32_t a, jit_int32_t cond, jit_int32_t op2,
972      jit_int32_t disp22)
973 {
974     jit_instr_t         v;
975     assert(!(op   & 0xfffffffc));
976     assert(!(a    & 0xfffffffe));
977     assert(!(cond & 0xfffffff0));
978     assert(!(op2  & 0xfffffff8));
979     assert(s22_p(disp22));
980     v.op.b     = op;
981     v.a.b      = a;
982     v.cond.b   = cond;
983     v.op2.b    = op2;
984     v.disp22.b = disp22;
985     ii(v.v);
986 }
987
988 #  if __WORDSIZE == 64
989 static void
990 _f2bp(jit_state_t *_jit,
991       jit_int32_t op, jit_int32_t a, jit_int32_t cond, jit_int32_t op2,
992       jit_int32_t cc1, jit_int32_t cc0, jit_int32_t p, jit_int32_t disp19)
993 {
994     jit_instr_t         v;
995     assert(!(op   & 0xfffffffc));
996     assert(!(a    & 0xfffffffe));
997     assert(!(cond & 0xfffffff0));
998     assert(!(op2  & 0xfffffff8));
999     assert(s19_p(disp19));
1000     v.op.b     = op;
1001     v.a.b      = a;
1002     v.cond.b   = cond;
1003     v.op2.b    = op2;
1004     v.cc1.b    = cc1;
1005     v.cc0.b    = cc0;
1006     v.p.b      = p;
1007     v.disp19.b = disp19;
1008     ii(v.v);
1009 }
1010 #  endif
1011
1012 static void
1013 _f3r(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd,
1014      jit_int32_t op3, jit_int32_t rs1, jit_int32_t rs2)
1015 {
1016     jit_instr_t         v;
1017     assert(!(op  & 0xfffffffc));
1018     assert(!(rd  & 0xffffffe0));
1019     assert(!(op3 & 0xffffffc0));
1020     assert(!(rs1 & 0xffffffe0));
1021     assert(!(rs2 & 0xffffffe0));
1022     v.op.b  = op;
1023     v.rd.b  = rd;
1024     v.op3.b = op3;
1025     v.rs1.b = rs1;
1026     v.i.b   = 0;
1027     v.asi.b = 0;
1028     v.rs2.b = rs2;
1029     ii(v.v);
1030 }
1031
1032 #  if __WORDSIZE == 64
1033 static void
1034 _f3rx(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd,
1035       jit_int32_t op3, jit_int32_t rs1, jit_int32_t rs2)
1036 {
1037     jit_instr_t         v;
1038     assert(!(op  & 0xfffffffc));
1039     assert(!(rd  & 0xffffffe0));
1040     assert(!(op3 & 0xffffffc0));
1041     assert(!(rs1 & 0xffffffe0));
1042     assert(!(rs2 & 0xffffffe0));
1043     v.op.b   = op;
1044     v.rd.b   = rd;
1045     v.op3.b  = op3;
1046     v.rs1.b  = rs1;
1047     v.i.b    = 0;
1048     v.x.b    = 1;
1049     v.asix.b = 0;
1050     v.rs2.b  = rs2;
1051     ii(v.v);
1052 }
1053
1054 static void
1055 _f3s(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd,
1056       jit_int32_t op3, jit_int32_t rs1, jit_int32_t shim)
1057 {
1058     jit_instr_t         v;
1059     assert(!(op   & 0xfffffffc));
1060     assert(!(rd   & 0xffffffe0));
1061     assert(!(op3  & 0xffffffc0));
1062     assert(!(rs1  & 0xffffffe0));
1063     assert(!(shim & 0xffffffc0));
1064     v.op.b   = op;
1065     v.rd.b   = rd;
1066     v.op3.b  = op3;
1067     v.rs1.b  = rs1;
1068     v.i.b    = 1;
1069     v.x.b    = 1;
1070     v.asis.b = 0;
1071     v.shim.b = shim;
1072     ii(v.v);
1073 }
1074 #  endif
1075
1076 static void
1077 _f3i(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd,
1078      jit_int32_t op3, jit_int32_t rs1, jit_int32_t simm13)
1079 {
1080     jit_instr_t         v;
1081     assert(!(op  & 0xfffffffc));
1082     assert(!(rd  & 0xffffffe0));
1083     assert(!(op3 & 0xffffffc0));
1084     assert(!(rs1 & 0xffffffe0));
1085     assert(s13_p(simm13));
1086     v.op.b     = op;
1087     v.rd.b     = rd;
1088     v.op3.b    = op3;
1089     v.rs1.b    = rs1;
1090     v.i.b      = 1;
1091     v.simm13.b = simm13;
1092     ii(v.v);
1093 }
1094
1095 static void
1096 _f3t(jit_state_t *_jit, jit_int32_t cond,
1097      jit_int32_t rs1, jit_int32_t i, jit_int32_t rs2_imm7)
1098 {
1099     jit_instr_t         v;
1100     assert(!(cond & 0xfffffff0));
1101     assert(!(i    & 0xfffffffe));
1102     assert(!(rs1 & 0xffffffe0));
1103     v.op.b     = 2;
1104     v.rd.b     = cond;
1105     v.op3.b    = 58;
1106     v.i.b      = i;
1107     if (i) {
1108         assert(s7_p(rs2_imm7));
1109         v.res.b  = 0;
1110         v.imm7.b = rs2_imm7;
1111     }
1112     else {
1113         assert(!(rs2_imm7 & 0xffffffe0));
1114         v.asi.b = 0;
1115         v.rs2.b = rs2_imm7;
1116     }
1117     ii(v.v);
1118 }
1119
1120 static void
1121 _f3a(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd,
1122      jit_int32_t op3, jit_int32_t rs1, jit_int32_t asi, jit_int32_t rs2)
1123 {
1124     jit_instr_t         v;
1125     assert(!(op  & 0xfffffffc));
1126     assert(!(rd  & 0xffffffe0));
1127     assert(!(op3 & 0xffffffc0));
1128     assert(!(rs1 & 0xffffffe0));
1129     assert(!(asi & 0xffffff00));
1130     assert(!(rs2 & 0xffffffe0));
1131     v.op.b    = op;
1132     v.rd.b    = rd;
1133     v.op3.b   = op3;
1134     v.rs1.b   = rs1;
1135     v.i.b     = 0;
1136     v.asi.b   = asi;
1137     v.rs2.b   = rs2;
1138     ii(v.v);
1139 }
1140
1141 static void
1142 _f1(jit_state_t *_jit, jit_int32_t op, jit_int32_t disp30)
1143 {
1144     jit_instr_t         v;
1145     assert(!(op  & 0xfffffffc));
1146     assert(s30_p(disp30));
1147     v.op.b     = op;
1148     v.disp30.b = disp30;
1149     ii(v.v);
1150 }
1151
1152 static void
1153 _nop(jit_state_t *_jit, jit_int32_t i0)
1154 {
1155     for (; i0 > 0; i0 -= 4)
1156         NOP();
1157     assert(i0 == 0);
1158 }
1159
1160 static void
1161 _movr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1162 {
1163     if (r0 != r1)
1164         ORI(r1, 0, r0);
1165 }
1166
1167 static void
1168 _movi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1169 {
1170     if (s13_p(i0))
1171         ORI(0, i0, r0);
1172     else {
1173 #  if __WORDSIZE == 64
1174         if (i0 & 0xffffffff00000000) {
1175             jit_int32_t reg = jit_get_reg(jit_class_gpr);
1176             movi(rn(reg), (i0 >> 32) & 0xffffffff);
1177             movi(r0, i0 & 0xffffffff);
1178             lshi(rn(reg), rn(reg), 32);
1179             OR(rn(reg), r0, r0);
1180             jit_unget_reg(reg);
1181         }
1182         else {
1183 #  endif
1184             SETHI(HI((int)i0), r0);
1185             if (LO(i0))
1186                 ORI(r0, LO(i0), r0);
1187 #  if __WORDSIZE == 64
1188         }
1189 #  endif
1190     }
1191 }
1192
1193 static jit_word_t
1194 _movi_p(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1195 {
1196     jit_word_t          w;
1197 #  if __WORDSIZE == 64
1198     jit_int32_t         reg;
1199 #  endif
1200     w = _jit->pc.w;
1201 #  if __WORDSIZE == 64
1202     reg = jit_get_reg(jit_class_gpr);
1203     SETHI(HI((int)i0), r0);
1204     ORI(r0, LO(i0), r0);
1205     i0 = (int)(i0 >> 32);
1206     SETHI(HI(i0), rn(reg));
1207     ORI(rn(reg), LO(i0), rn(reg));
1208     SLLXI(rn(reg), 32, rn(reg));
1209     OR(rn(reg), r0, r0);
1210     jit_unget_reg(reg);
1211 #  else
1212     SETHI(HI(i0), r0);
1213     ORI(r0, LO(i0), r0);
1214 #  endif
1215     return (w);
1216 }
1217
1218 static void
1219 _movnr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1220 {
1221     jit_word_t  w;
1222     w = beqi(_jit->pc.w, r2, 0);
1223     ORI(r1, 0, r0);
1224     patch_at(w, _jit->pc.w);
1225 }
1226
1227 static void
1228 _movzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1229 {
1230     jit_word_t  w;
1231     w = bnei(_jit->pc.w, r2, 0);
1232     ORI(r1, 0, r0);
1233     patch_at(w, _jit->pc.w);
1234 }
1235
1236 static void
1237 _addi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1238 {
1239     jit_int32_t         reg;
1240     if (s13_p(i0))
1241         ADDI(r1, i0, r0);
1242     else {
1243         reg = jit_get_reg(jit_class_gpr);
1244         movi(rn(reg), i0);
1245         addr(r0, r1, rn(reg));
1246         jit_unget_reg(reg);
1247     }
1248 }
1249
1250 #  if __WORDSIZE == 64
1251 static void
1252 _addcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1253 {
1254     jit_int32_t         reg;
1255     if (jit_carry == _NOREG)
1256         jit_carry = jit_get_reg(jit_class_gpr);
1257     if (r0 == r1) {
1258         reg = jit_get_reg(jit_class_gpr);
1259         addr(rn(reg), r1, r2);
1260         ltr_u(rn(jit_carry), rn(reg), r1);
1261         movr(r0, rn(reg));
1262         jit_unget_reg(reg);
1263     }
1264     else {
1265         addr(r0, r1, r2);
1266         ltr_u(rn(jit_carry), r0, r1);
1267     }
1268 }
1269 #  endif
1270
1271 static void
1272 _addci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1273 {
1274 #  if __WORDSIZE == 32
1275     jit_int32_t         reg;
1276     if (s13_p(i0))
1277         ADDIcc(r1, i0, r0);
1278     else {
1279         reg = jit_get_reg(jit_class_gpr);
1280         movi(rn(reg), i0);
1281         addcr(r0, r1, rn(reg));
1282         jit_unget_reg(reg);
1283     }
1284 #  else
1285     jit_int32_t         reg;
1286     if (jit_carry == _NOREG)
1287         jit_carry = jit_get_reg(jit_class_gpr);
1288     if (r0 == r1) {
1289         reg = jit_get_reg(jit_class_gpr);
1290         addi(rn(reg), r1, i0);
1291         ltr_u(rn(jit_carry), rn(reg), r1);
1292         movr(r0, rn(reg));
1293         jit_unget_reg(reg);
1294     }
1295     else {
1296         addi(r0, r1, i0);
1297         ltr_u(rn(jit_carry), r0, r1);
1298     }
1299 #  endif
1300 }
1301
1302 #  if __WORDSIZE == 64
1303 static void
1304 _addxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1305 {
1306     jit_int32_t         reg;
1307     assert(jit_carry != _NOREG);
1308     reg = jit_get_reg(jit_class_gpr);
1309     movr(rn(reg), rn(jit_carry));
1310     addcr(r0, r1, r2);
1311     addcr(r0, r0, rn(reg));
1312     jit_unget_reg(reg);
1313 }
1314 #  endif
1315
1316 static void
1317 _addxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1318 {
1319 #  if __WORDSIZE == 32
1320     jit_int32_t         reg;
1321     if (s13_p(i0))
1322         ADDXIcc(r1, i0, r0);
1323     else {
1324         reg = jit_get_reg(jit_class_gpr);
1325         movi(rn(reg), i0);
1326         addxr(r0, r1, rn(reg));
1327         jit_unget_reg(reg);
1328     }
1329 #  else
1330     jit_int32_t         reg;
1331     assert(jit_carry != _NOREG);
1332     reg = jit_get_reg(jit_class_gpr);
1333     movr(rn(reg), rn(jit_carry));
1334     addci(r0, r1, i0);
1335     addcr(r0, r0, rn(reg));
1336     jit_unget_reg(reg);
1337 #  endif
1338 }
1339
1340 static void
1341 _subi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1342 {
1343     jit_int32_t         reg;
1344     if (s13_p(i0))
1345         SUBI(r1, i0, r0);
1346     else {
1347         reg = jit_get_reg(jit_class_gpr);
1348         movi(rn(reg), i0);
1349         subr(r0, r1, rn(reg));
1350         jit_unget_reg(reg);
1351     }
1352 }
1353
1354 #  if __WORDSIZE == 64
1355 static void
1356 _subcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1357 {
1358     jit_int32_t         reg;
1359     if (jit_carry == _NOREG)
1360         jit_carry = jit_get_reg(jit_class_gpr);
1361     if (r0 == r1) {
1362         reg = jit_get_reg(jit_class_gpr);
1363         subr(rn(reg), r1, r2);
1364         ltr_u(rn(jit_carry), r1, rn(reg));
1365         movr(r0, rn(reg));
1366         jit_unget_reg(reg);
1367     }
1368     else {
1369         subr(r0, r1, r2);
1370         ltr_u(rn(jit_carry), r1, r0);
1371     }
1372 }
1373 #  endif
1374
1375 static void
1376 _subci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1377 {
1378 #  if __WORDSIZE == 32
1379     jit_int32_t         reg;
1380     if (s13_p(i0))
1381         SUBIcc(r1, i0, r0);
1382     else {
1383         reg = jit_get_reg(jit_class_gpr);
1384         movi(rn(reg), i0);
1385         subcr(r0, r1, rn(reg));
1386         jit_unget_reg(reg);
1387     }
1388 #  else
1389     jit_int32_t         reg;
1390     if (jit_carry == _NOREG)
1391         jit_carry = jit_get_reg(jit_class_gpr);
1392     if (r0 == r1) {
1393         reg = jit_get_reg(jit_class_gpr);
1394         addi(rn(reg), r1, -i0);
1395         ltr_u(rn(jit_carry), r1, rn(reg));
1396         movr(r0, rn(reg));
1397         jit_unget_reg(reg);
1398     }
1399     else {
1400         addi(r0, r1, -i0);
1401         ltr_u(rn(jit_carry), r1, r0);
1402     }
1403 #  endif
1404 }
1405
1406 #  if __WORDSIZE == 64
1407 static void
1408 _subxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1409 {
1410     jit_int32_t         reg;
1411     assert(jit_carry != _NOREG);
1412     reg = jit_get_reg(jit_class_gpr);
1413     movr(rn(reg), rn(jit_carry));
1414     subcr(r0, r1, r2);
1415     subcr(r0, r0, rn(reg));
1416     jit_unget_reg(reg);
1417 }
1418 #endif
1419
1420 static void
1421 _subxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1422 {
1423 #  if __WORDSIZE == 32
1424     jit_int32_t         reg;
1425     if (s13_p(i0))
1426         SUBXIcc(r1, i0, r0);
1427     else {
1428         reg = jit_get_reg(jit_class_gpr);
1429         movi(rn(reg), i0);
1430         subxr(r0, r1, rn(reg));
1431         jit_unget_reg(reg);
1432     }
1433 #  else
1434     jit_int32_t         reg;
1435     assert(jit_carry != _NOREG);
1436     reg = jit_get_reg(jit_class_gpr);
1437     movr(rn(reg), rn(jit_carry));
1438     subci(r0, r1, i0);
1439     subcr(r0, r0, rn(reg));
1440     jit_unget_reg(reg);
1441 #  endif
1442 }
1443
1444 static void
1445 _rsbi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1446 {
1447     subi(r0, r1, i0);
1448     negr(r0, r0);
1449 }
1450
1451 static void
1452 _muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1453 {
1454     jit_int32_t         reg;
1455     if (s13_p(i0)) {
1456 #  if __WORDSIZE == 32
1457         UMULI(r1, i0, r0);
1458 #  else
1459         MULXI(r1, i0, r0);
1460 #  endif
1461     }
1462     else {
1463         reg = jit_get_reg(jit_class_gpr);
1464         movi(rn(reg), i0);
1465         mulr(r0, r1, rn(reg));
1466         jit_unget_reg(reg);
1467     }
1468 }
1469
1470 #  if __WORDSIZE == 32
1471 static void
1472 _iqmulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1473         jit_int32_t r2, jit_int32_t r3, jit_bool_t sign)
1474 {
1475     if (sign)
1476         SMUL(r2, r3, r0);
1477     else
1478         UMUL(r2, r3, r0);
1479     RDY(r1);
1480 }
1481
1482 static void
1483 _iqmuli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1484         jit_int32_t r2, jit_word_t i0, jit_bool_t sign)
1485 {
1486     jit_int32_t         reg;
1487     if (s13_p(i0)) {
1488         if (sign)
1489             SMULI(r2, i0, r0);
1490         else
1491             UMULI(r2, i0, r0);
1492         RDY(r1);
1493     }
1494     else {
1495         reg = jit_get_reg(jit_class_gpr);
1496         movi(rn(reg), i0);
1497         iqmulr(r0, r1, r2, rn(reg), sign);
1498         jit_unget_reg(reg);
1499     }
1500 }
1501
1502 #  else
1503 static __int128_t __llmul(jit_word_t a, jit_word_t b)
1504 {
1505     return (__int128_t)a * (__int128_t)b;
1506 }
1507
1508 #  define QMUL_PROLOG()                                         \
1509     do {                                                        \
1510         (void)jit_get_reg(_O0|jit_class_gpr|jit_class_named);   \
1511         (void)jit_get_reg(_O1|jit_class_gpr|jit_class_named);   \
1512         if (r0 != _G2_REGNO && r1 != _G2_REGNO)                 \
1513             stxi(BIAS(-8), _FP_REGNO, _G2_REGNO);               \
1514         if (r0 != _G3_REGNO && r1 != _G3_REGNO)                 \
1515             stxi(BIAS(-16), _FP_REGNO, _G3_REGNO);              \
1516         if (r0 != _G4_REGNO && r1 != _G4_REGNO)                 \
1517             stxi(BIAS(-24), _FP_REGNO, _G4_REGNO);              \
1518     } while (0)
1519
1520 #  define QMUL_EPILOG()                                         \
1521     do {                                                        \
1522         if (r0 != _G2_REGNO && r1 != _G2_REGNO)                 \
1523             ldxi(_G2_REGNO, _FP_REGNO, BIAS(-8));               \
1524         if (r0 != _G3_REGNO && r1 != _G3_REGNO)                 \
1525             ldxi(_G3_REGNO, _FP_REGNO, BIAS(-16));              \
1526         if (r0 != _G4_REGNO && r1 != _G4_REGNO)                 \
1527             ldxi(_G4_REGNO, _FP_REGNO, BIAS(-24));              \
1528         (void)jit_unget_reg(_O0);                               \
1529         (void)jit_unget_reg(_O1);                               \
1530     } while (0)
1531
1532 static void
1533 _qmulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1534        jit_int32_t r2, jit_int32_t r3)
1535 {
1536     QMUL_PROLOG();
1537     movr(_O0_REGNO, r3);
1538     movr(_O1_REGNO, r2);
1539     calli((jit_word_t)__llmul);
1540     movr(r0, _O1_REGNO);
1541     movr(r1, _O0_REGNO);
1542     QMUL_EPILOG();
1543 }
1544
1545 static void
1546 _qmuli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1547        jit_int32_t r2, jit_word_t i0)
1548 {
1549     QMUL_PROLOG();
1550     movi(_O0_REGNO, i0);
1551     movr(_O1_REGNO, r2);
1552     calli((jit_word_t)__llmul);
1553     movr(r0, _O1_REGNO);
1554     movr(r1, _O0_REGNO);
1555     QMUL_EPILOG();
1556 }
1557
1558 static __uint128_t __ullmul(jit_uword_t a, jit_uword_t b)
1559 {
1560     return (__uint128_t)a * (__uint128_t)b;
1561 }
1562
1563 static void
1564 _qmulr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1565          jit_int32_t r2, jit_int32_t r3)
1566 {
1567     QMUL_PROLOG();
1568     movr(_O0_REGNO, r3);
1569     movr(_O1_REGNO, r2);
1570     calli((jit_word_t)__ullmul);
1571     movr(r0, _O1_REGNO);
1572     movr(r1, _O0_REGNO);
1573     QMUL_EPILOG();
1574 }
1575
1576 static void
1577 _qmuli_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1578          jit_int32_t r2, jit_word_t i0)
1579 {
1580     QMUL_PROLOG();
1581     movi(_O0_REGNO, i0);
1582     movr(_O1_REGNO, r2);
1583     calli((jit_word_t)__ullmul);
1584     movr(r0, _O1_REGNO);
1585     movr(r1, _O0_REGNO);
1586     QMUL_EPILOG();
1587 }
1588 #  endif
1589
1590 static void
1591 _divr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1592 {
1593 #  if __WORDSIZE == 32
1594     jit_int32_t         reg;
1595     reg = jit_get_reg(jit_class_gpr);
1596     rshi(rn(reg), r1, 31);
1597     WRY(rn(reg), 0);
1598     SDIV(r1, r2, r0);
1599     jit_unget_reg(reg);
1600 #  else
1601     SDIVX(r1, r2, r0);
1602 #  endif
1603 }
1604
1605 static void
1606 _divi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1607 {
1608     jit_int32_t         reg;
1609 #  if __WORDSIZE == 32
1610     reg = jit_get_reg(jit_class_gpr);
1611 #  endif
1612     if (s13_p(i0)) {
1613 #  if __WORDSIZE == 32
1614         rshi(rn(reg), r1, 31);
1615         WRY(rn(reg), 0);
1616         SDIVI(r1, i0, r0);
1617 #  else
1618         SDIVXI(r1, i0, r0);
1619 #  endif
1620     }
1621     else {
1622 #  if __WORDSIZE == 64
1623         reg = jit_get_reg(jit_class_gpr);
1624 #  endif
1625         movi(rn(reg), i0);
1626         divr(r0, r1, rn(reg));
1627 #  if __WORDSIZE == 64
1628         jit_unget_reg(reg);
1629 #  endif
1630     }
1631 #  if __WORDSIZE == 32
1632     jit_unget_reg(reg);
1633 #  endif
1634 }
1635
1636 static void
1637 _divr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1638 {
1639 #  if __WORDSIZE == 32
1640     WRYI(0, 0);
1641     UDIV(r1, r2, r0);
1642 #  else
1643     UDIVX(r1, r2, r0);
1644 #  endif
1645 }
1646
1647 static void
1648 _divi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1649 {
1650     jit_int32_t         reg;
1651     if (s13_p(i0)) {
1652 #  if __WORDSIZE == 32
1653         WRYI(0, 0);
1654         UDIVI(r1, i0, r0);
1655 #  else
1656         UDIVXI(r1, i0, r0);
1657 #  endif
1658     }
1659     else {
1660         reg = jit_get_reg(jit_class_gpr);
1661         movi(rn(reg), i0);
1662         divr_u(r0, r1, rn(reg));
1663         jit_unget_reg(reg);
1664     }
1665 }
1666
1667 static void
1668 _iqdivr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1669         jit_int32_t r2, jit_int32_t r3, jit_bool_t sign)
1670 {
1671     jit_int32_t         sv0, rg0;
1672     jit_int32_t         sv1, rg1;
1673
1674     if (r0 == r2 || r0 == r3) {
1675         sv0 = jit_get_reg(jit_class_gpr);
1676         rg0 = rn(sv0);
1677     }
1678     else
1679         rg0 = r0;
1680     if (r1 == r2 || r1 == r3) {
1681         sv1 = jit_get_reg(jit_class_gpr);
1682         rg1 = rn(sv1);
1683     }
1684     else
1685         rg1 = r1;
1686
1687     if (sign)
1688         divr(rg0, r2, r3);
1689     else
1690         divr_u(rg0, r2, r3);
1691     mulr(rg1, r3, rg0);
1692     subr(rg1, r2, rg1);
1693     if (rg0 != r0) {
1694         movr(r0, rg0);
1695         jit_unget_reg(sv0);
1696     }
1697     if (rg1 != r1) {
1698         movr(r1, rg1);
1699         jit_unget_reg(sv1);
1700     }
1701 }
1702
1703 static void
1704 _iqdivi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1705         jit_int32_t r2, jit_word_t i0, jit_bool_t sign)
1706 {
1707     jit_int32_t         reg;
1708     reg = jit_get_reg(jit_class_gpr);
1709     movi(rn(reg), i0);
1710     iqdivr(r0, r1, r2, rn(reg), sign);
1711     jit_unget_reg(reg);
1712 }
1713
1714 static void
1715 _remr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1716 {
1717     jit_int32_t         reg;
1718     if (r0 == r1 || r0 == r2) {
1719         reg = jit_get_reg(jit_class_gpr);
1720         divr(rn(reg), r1, r2);
1721         mulr(rn(reg), r2, rn(reg));
1722         subr(r0, r1, rn(reg));
1723         jit_unget_reg(reg);
1724     }
1725     else {
1726         divr(r0, r1, r2);
1727         mulr(r0, r2, r0);
1728         subr(r0, r1, r0);
1729     }
1730 }
1731
1732 static void
1733 _remi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1734 {
1735     jit_int32_t         reg;
1736     reg = jit_get_reg(jit_class_gpr);
1737     movi(rn(reg), i0);
1738     remr(r0, r1, rn(reg));
1739     jit_unget_reg(reg);
1740 }
1741
1742 static void
1743 _remr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1744 {
1745     jit_int32_t         reg;
1746     if (r0 == r1 || r0 == r2) {
1747         reg = jit_get_reg(jit_class_gpr);
1748         divr_u(rn(reg), r1, r2);
1749         mulr(rn(reg), r2, rn(reg));
1750         subr(r0, r1, rn(reg));
1751         jit_unget_reg(reg);
1752     }
1753     else {
1754         divr_u(r0, r1, r2);
1755         mulr(r0, r2, r0);
1756         subr(r0, r1, r0);
1757     }
1758 }
1759
1760 static void
1761 _remi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1762 {
1763     jit_int32_t         reg;
1764     reg = jit_get_reg(jit_class_gpr);
1765     movi(rn(reg), i0);
1766     remr_u(r0, r1, rn(reg));
1767     jit_unget_reg(reg);
1768 }
1769
1770 static void
1771 _andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1772 {
1773     jit_int32_t         reg;
1774     if (s13_p(i0))
1775         ANDI(r1, i0, r0);
1776     else {
1777         reg = jit_get_reg(jit_class_gpr);
1778         movi(rn(reg), i0);
1779         andr(r0, r1, rn(reg));
1780         jit_unget_reg(reg);
1781     }
1782 }
1783
1784 static void
1785 _ori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1786 {
1787     jit_int32_t         reg;
1788     if (s13_p(i0))
1789         ORI(r1, i0, r0);
1790     else {
1791         reg = jit_get_reg(jit_class_gpr);
1792         movi(rn(reg), i0);
1793         orr(r0, r1, rn(reg));
1794         jit_unget_reg(reg);
1795     }
1796 }
1797
1798 static void
1799 _xori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1800 {
1801     jit_int32_t         reg;
1802     if (s13_p(i0))
1803         XORI(r1, i0, r0);
1804     else {
1805         reg = jit_get_reg(jit_class_gpr);
1806         movi(rn(reg), i0);
1807         xorr(r0, r1, rn(reg));
1808         jit_unget_reg(reg);
1809     }
1810 }
1811
1812 static void
1813 _extr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1814 {
1815     lshi(r0, r1, __WORDSIZE - 8);
1816     rshi(r0, r0, __WORDSIZE - 8);
1817 }
1818
1819 static void
1820 _extr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1821 {
1822     lshi(r0, r1, __WORDSIZE - 16);
1823     rshi(r0, r0, __WORDSIZE - 16);
1824 }
1825
1826 static void
1827 _extr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1828 {
1829     lshi(r0, r1, __WORDSIZE - 16);
1830     rshi_u(r0, r0, __WORDSIZE - 16);
1831 }
1832
1833 #if __WORDSIZE == 64
1834 static void
1835 _extr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1836 {
1837     lshi(r0, r1, __WORDSIZE - 32);
1838     rshi(r0, r0, __WORDSIZE - 32);
1839 }
1840
1841 static void
1842 _extr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1843 {
1844     lshi(r0, r1, __WORDSIZE - 32);
1845     rshi_u(r0, r0, __WORDSIZE - 32);
1846 }
1847 #endif
1848
1849 static void
1850 _cr(jit_state_t *_jit, jit_int32_t cc,
1851     jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1852 {
1853     CMP(r1, r2);
1854 #  if __WORDSIZE == 32
1855     Ba(cc, 3);
1856 #  else
1857     BPa(cc, 3);
1858 #  endif
1859     movi(r0, 1);
1860     movi(r0, 0);
1861 }
1862
1863 static void
1864 _cw(jit_state_t *_jit, jit_int32_t cc,
1865     jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1866 {
1867     jit_int32_t         reg;
1868     if (s13_p(i0)) {
1869         CMPI(r1, i0);
1870 #  if __WORDSIZE == 32
1871         Ba(cc, 3);
1872 #  else
1873         BPa(cc, 3);
1874 #  endif
1875         movi(r0, 1);
1876         movi(r0, 0);
1877     }
1878     else {
1879         reg = jit_get_reg(jit_class_gpr);
1880         movi(rn(reg), i0);
1881         cr(cc, r0, r1, rn(reg));
1882         jit_unget_reg(reg);
1883     }
1884 }
1885
1886 static void
1887 _ldi_c(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1888 {
1889     jit_int32_t         reg;
1890     if (s13_p(i0))
1891         LDSBI(0, i0, r0);
1892     else {
1893         reg = jit_get_reg(jit_class_gpr);
1894         movi(rn(reg), i0);
1895         ldr_c(r0, rn(reg));
1896         jit_unget_reg(reg);
1897     }
1898 }
1899
1900 static void
1901 _ldi_uc(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1902 {
1903     jit_int32_t         reg;
1904     if (s13_p(i0))
1905         LDUBI(0, i0, r0);
1906     else {
1907         reg = jit_get_reg(jit_class_gpr);
1908         movi(rn(reg), i0);
1909         ldr_uc(r0, rn(reg));
1910         jit_unget_reg(reg);
1911     }
1912 }
1913
1914 static void
1915 _ldi_s(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1916 {
1917     jit_int32_t         reg;
1918     if (s13_p(i0))
1919         LDSHI(0, i0, r0);
1920     else {
1921         reg = jit_get_reg(jit_class_gpr);
1922         movi(rn(reg), i0);
1923         ldr_s(r0, rn(reg));
1924         jit_unget_reg(reg);
1925     }
1926 }
1927
1928 static void
1929 _ldi_us(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1930 {
1931     jit_int32_t         reg;
1932     if (s13_p(i0))
1933         LDUHI(0, i0, r0);
1934     else {
1935         reg = jit_get_reg(jit_class_gpr);
1936         movi(rn(reg), i0);
1937         ldr_us(r0, rn(reg));
1938         jit_unget_reg(reg);
1939     }
1940 }
1941
1942 static void
1943 _ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1944 {
1945     jit_int32_t         reg;
1946     if (s13_p(i0)) {
1947 #  if __WORDSIZE == 32
1948         LDI(0, i0, r0);
1949 #  else
1950         LDSWI(0, i0, r0);
1951 #  endif
1952     }
1953     else {
1954         reg = jit_get_reg(jit_class_gpr);
1955         movi(rn(reg), i0);
1956         ldr_i(r0, rn(reg));
1957         jit_unget_reg(reg);
1958     }
1959 }
1960
1961 #  if __WORDSIZE == 64
1962 static void
1963 _ldi_ui(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1964 {
1965     jit_int32_t         reg;
1966     if (s13_p(i0))
1967         LDUWI(0, i0, r0);
1968     else {
1969         reg = jit_get_reg(jit_class_gpr);
1970         movi(rn(reg), i0);
1971         ldr_ui(r0, rn(reg));
1972         jit_unget_reg(reg);
1973     }
1974 }
1975
1976 static void
1977 _ldi_l(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1978 {
1979     jit_int32_t         reg;
1980     if (s13_p(i0))
1981         LDXI(0, i0, r0);
1982     else {
1983         reg = jit_get_reg(jit_class_gpr);
1984         movi(rn(reg), i0);
1985         ldr_l(r0, rn(reg));
1986         jit_unget_reg(reg);
1987     }
1988 }
1989 #  endif
1990
1991 static void
1992 _ldxi_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1993 {
1994     jit_int32_t         reg;
1995     if (s13_p(i0))
1996         LDSBI(r1, i0, r0);
1997     else {
1998         reg = jit_get_reg(jit_class_gpr);
1999         movi(rn(reg), i0);
2000         ldxr_c(r0, r1, rn(reg));
2001         jit_unget_reg(reg);
2002     }
2003 }
2004
2005 static void
2006 _ldxi_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2007 {
2008     jit_int32_t         reg;
2009     if (s13_p(i0))
2010         LDUBI(r1, i0, r0);
2011     else {
2012         reg = jit_get_reg(jit_class_gpr);
2013         movi(rn(reg), i0);
2014         ldxr_uc(r0, r1, rn(reg));
2015         jit_unget_reg(reg);
2016     }
2017 }
2018
2019 static void
2020 _ldxi_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2021 {
2022     jit_int32_t         reg;
2023     if (s13_p(i0))
2024         LDSHI(r1, i0, r0);
2025     else {
2026         reg = jit_get_reg(jit_class_gpr);
2027         movi(rn(reg), i0);
2028         ldxr_s(r0, r1, rn(reg));
2029         jit_unget_reg(reg);
2030     }
2031 }
2032
2033 static void
2034 _ldxi_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2035 {
2036     jit_int32_t         reg;
2037     if (s13_p(i0))
2038         LDUHI(r1, i0, r0);
2039     else {
2040         reg = jit_get_reg(jit_class_gpr);
2041         movi(rn(reg), i0);
2042         ldxr_us(r0, r1, rn(reg));
2043         jit_unget_reg(reg);
2044     }
2045 }
2046
2047 static void
2048 _ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2049 {
2050     jit_int32_t         reg;
2051     if (s13_p(i0)) {
2052 #  if __WORDSIZE == 32
2053         LDI(r1, i0, r0);
2054 #  else
2055         LDSWI(r1, i0, r0);
2056 #  endif
2057     }
2058     else {
2059         reg = jit_get_reg(jit_class_gpr);
2060         movi(rn(reg), i0);
2061         ldxr_i(r0, r1, rn(reg));
2062         jit_unget_reg(reg);
2063     }
2064 }
2065
2066 #  if __WORDSIZE == 64
2067 static void
2068 _ldxi_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2069 {
2070     jit_int32_t         reg;
2071     if (s13_p(i0))
2072         LDUWI(r1, i0, r0);
2073     else {
2074         reg = jit_get_reg(jit_class_gpr);
2075         movi(rn(reg), i0);
2076         ldxr_ui(r0, r1, rn(reg));
2077         jit_unget_reg(reg);
2078     }
2079 }
2080
2081 static void
2082 _ldxi_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2083 {
2084     jit_int32_t         reg;
2085     if (s13_p(i0))
2086         LDXI(r1, i0, r0);
2087     else {
2088         reg = jit_get_reg(jit_class_gpr);
2089         movi(rn(reg), i0);
2090         ldxr_l(r0, r1, rn(reg));
2091         jit_unget_reg(reg);
2092     }
2093 }
2094 #  endif
2095
2096 static void
2097 _sti_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2098 {
2099     jit_int32_t         reg;
2100     if (s13_p(i0))
2101         STBI(r0, 0, i0);
2102     else {
2103         reg = jit_get_reg(jit_class_gpr);
2104         movi(rn(reg), i0);
2105         str_c(rn(reg), r0);
2106         jit_unget_reg(reg);
2107     }
2108 }
2109
2110 static void
2111 _sti_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2112 {
2113     jit_int32_t         reg;
2114     if (s13_p(i0))
2115         STHI(r0, 0, i0);
2116     else {
2117         reg = jit_get_reg(jit_class_gpr);
2118         movi(rn(reg), i0);
2119         str_s(rn(reg), r0);
2120         jit_unget_reg(reg);
2121     }
2122 }
2123
2124 static void
2125 _sti_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2126 {
2127     jit_int32_t         reg;
2128     if (s13_p(i0)) {
2129 #  if __WORDSIZE == 32
2130         STI(r0, 0, i0);
2131 #  else
2132         STWI(r0, 0, i0);
2133 #  endif
2134     }
2135     else {
2136         reg = jit_get_reg(jit_class_gpr);
2137         movi(rn(reg), i0);
2138         str_i(rn(reg), r0);
2139         jit_unget_reg(reg);
2140     }
2141 }
2142
2143 #  if __WORDSIZE == 64
2144 static void
2145 _sti_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2146 {
2147     jit_int32_t         reg;
2148     if (s13_p(i0))
2149         STXI(r0, 0, i0);
2150     else {
2151         reg = jit_get_reg(jit_class_gpr);
2152         movi(rn(reg), i0);
2153         str_l(rn(reg), r0);
2154         jit_unget_reg(reg);
2155     }
2156 }
2157 #  endif
2158
2159 static void
2160 _stxi_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2161 {
2162     jit_int32_t         reg;
2163     if (s13_p(i0))
2164         STBI(r1, r0, i0);
2165     else {
2166         reg = jit_get_reg(jit_class_gpr);
2167         movi(rn(reg), i0);
2168         stxr_c(r0, rn(reg), r1);
2169         jit_unget_reg(reg);
2170     }
2171 }
2172
2173 static void
2174 _stxi_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2175 {
2176     jit_int32_t         reg;
2177     if (s13_p(i0))
2178         STHI(r1, r0, i0);
2179     else {
2180         reg = jit_get_reg(jit_class_gpr);
2181         movi(rn(reg), i0);
2182         stxr_s(r0, rn(reg), r1);
2183         jit_unget_reg(reg);
2184     }
2185 }
2186
2187 static void
2188 _stxi_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2189 {
2190     jit_int32_t         reg;
2191     if (s13_p(i0)) {
2192 #  if __WORDSIZE == 32
2193         STI(r1, r0, i0);
2194 #  else
2195         STWI(r1, r0, i0);
2196 #  endif
2197     }
2198     else {
2199         reg = jit_get_reg(jit_class_gpr);
2200         movi(rn(reg), i0);
2201         stxr_i(r0, rn(reg), r1);
2202         jit_unget_reg(reg);
2203     }
2204 }
2205
2206 #  if __WORDSIZE == 64
2207 static void
2208 _stxi_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2209 {
2210     jit_int32_t         reg;
2211     if (s13_p(i0))
2212         STXI(r1, r0, i0);
2213     else {
2214         reg = jit_get_reg(jit_class_gpr);
2215         movi(rn(reg), i0);
2216         stxr_l(r0, rn(reg), r1);
2217         jit_unget_reg(reg);
2218     }
2219 }
2220 #  endif
2221
2222 static jit_word_t
2223 _br(jit_state_t *_jit, jit_int32_t cc,
2224     jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2225 {
2226     jit_word_t          w;
2227     CMP(r0, r1);
2228     w = _jit->pc.w;
2229 #  if __WORDSIZE == 32
2230     B(cc, (i0 - w) >> 2);
2231 #  else
2232     BP(cc, (i0 - w) >> 2);
2233 #  endif
2234     NOP();
2235     return (w);
2236 }
2237
2238 static jit_word_t
2239 _bw(jit_state_t *_jit, jit_int32_t cc,
2240     jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2241 {
2242     jit_word_t          w;
2243     jit_int32_t         reg;
2244     if (s13_p(i1)) {
2245         CMPI(r0, i1);
2246         w = _jit->pc.w;
2247 #  if __WORDSIZE == 32
2248         B(cc, (i0 - w) >> 2);
2249 #  else
2250         B(cc, (i0 - w) >> 2);
2251 #  endif
2252         NOP();
2253     }
2254     else {
2255         reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2256         movi(rn(reg), i1);
2257         w = br(cc, i0, r0, rn(reg));
2258         jit_unget_reg(reg);
2259     }
2260     return (w);
2261 }
2262
2263 static jit_word_t
2264 _b_asr(jit_state_t *_jit, jit_bool_t jif, jit_bool_t add, jit_bool_t sgn,
2265        jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2266 {
2267     jit_word_t          w;
2268     if (add)
2269         ADDcc(r0, r1, r0);
2270     else
2271         SUBcc(r0, r1, r0);
2272     w = _jit->pc.w;
2273 #  if __WORDSIZE == 32
2274     B(sgn ?
2275       (jif ? SPARC_BVS : SPARC_BVC) :
2276       (jif ? SPARC_BCS : SPARC_BCC),
2277       (i0 - w) >> 2);
2278 #  else
2279     BP(sgn ?
2280        (jif ? SPARC_BPVS : SPARC_BPVC) :
2281        (jif ? SPARC_BPCS : SPARC_BPCC),
2282        (i0 - w) >> 2);
2283 #  endif
2284     NOP();
2285     return (w);
2286 }
2287
2288 static jit_word_t
2289 _b_asw(jit_state_t *_jit, jit_bool_t jif, jit_bool_t add, jit_bool_t sgn,
2290        jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2291 {
2292     jit_word_t          w;
2293     jit_int32_t         reg;
2294     if (s13_p(i1)) {
2295         if (add)
2296             ADDIcc(r0, i1, r0);
2297         else
2298             SUBIcc(r0, i1, r0);
2299         w = _jit->pc.w;
2300 #  if __WORDSIZE == 32
2301         B(sgn ?
2302           (jif ? SPARC_BVS : SPARC_BVC) :
2303           (jif ? SPARC_BCS : SPARC_BCC),
2304           (i0 - w) >> 2);
2305 #  else
2306         BP(sgn ?
2307            (jif ? SPARC_BPVS : SPARC_BPVC) :
2308            (jif ? SPARC_BPCS : SPARC_BPCC),
2309            (i0 - w) >> 2);
2310 #  endif
2311         NOP();
2312     }
2313     else {
2314         reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2315         movi(rn(reg), i1);
2316         w = b_asr(jif, add, sgn, i0, r0, rn(reg));
2317         jit_unget_reg(reg);
2318     }
2319     return (w);
2320 }
2321
2322 static jit_word_t
2323 _bm_r(jit_state_t *_jit, jit_bool_t set,
2324       jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2325 {
2326     jit_word_t          w;
2327     BTST(r0, r1);
2328     w = _jit->pc.w;
2329 #  if __WORDSIZE == 32
2330     B(set ? SPARC_BNZ : SPARC_BZ, (i0 - w) >> 2);
2331 #  else
2332     BP(set ? SPARC_BPNE : SPARC_BPE, (i0 - w) >> 2);
2333 #  endif
2334     NOP();
2335     return (w);
2336 }
2337
2338 static jit_word_t
2339 _bm_w(jit_state_t *_jit, jit_bool_t set,
2340       jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2341 {
2342     jit_word_t          w;
2343     jit_int32_t         reg;
2344     if (s13_p(i1)) {
2345         BTSTI(r0, i1);
2346         w = _jit->pc.w;
2347 #  if __WORDSIZE == 32
2348         B(set ? SPARC_BNZ : SPARC_BZ, (i0 - w) >> 2);
2349 #  else
2350         BP(set ? SPARC_BPNE : SPARC_BPE, (i0 - w) >> 2);
2351 #  endif
2352         NOP();
2353     }
2354     else {
2355         reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2356         movi(rn(reg), i1);
2357         w = bm_r(set, i0, r0, rn(reg));
2358         jit_unget_reg(reg);
2359     }
2360     return (w);
2361 }
2362
2363 static void
2364 _jmpr(jit_state_t *_jit, jit_int32_t r0)
2365 {
2366     JMPL(0, r0, 0);
2367     NOP();
2368 }
2369
2370 static void
2371 _jmpi(jit_state_t *_jit, jit_word_t i0)
2372 {
2373     jit_word_t          w;
2374     jit_int32_t         reg;
2375     w = (i0 - _jit->pc.w) >> 2;
2376     if (s22_p(w)) {
2377         BA(w);
2378         NOP();
2379     }
2380     else {
2381         reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2382         movi(rn(reg), i0);
2383         jmpr(rn(reg));
2384         jit_unget_reg(reg);
2385     }
2386 }
2387
2388 static jit_word_t
2389 _jmpi_p(jit_state_t *_jit, jit_word_t i0)
2390 {
2391     jit_word_t          w;
2392     jit_int32_t         reg;
2393     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2394     w = movi_p(rn(reg), i0);
2395     jmpr(rn(reg));
2396     jit_unget_reg(reg);
2397     return (w);
2398 }
2399
2400 static void
2401 _callr(jit_state_t *_jit, jit_int32_t r0)
2402 {
2403     CALL(r0);
2404     NOP();
2405 }
2406
2407 static void
2408 _calli(jit_state_t *_jit, jit_word_t i0)
2409 {
2410     jit_word_t          w;
2411     w = (i0 - _jit->pc.w) >> 2;
2412     CALLI(w);
2413     NOP();
2414 }
2415
2416 static jit_word_t
2417 _calli_p(jit_state_t *_jit, jit_word_t i0)
2418 {
2419     jit_word_t          w;
2420     jit_int32_t         reg;
2421     reg = jit_get_reg(jit_class_gpr);
2422     w = movi_p(rn(reg), i0);
2423     callr(rn(reg));
2424     jit_unget_reg(reg);
2425     return (w);
2426 }
2427
2428 #define OFF(n)          BIAS(((n) * sizeof(jit_word_t)))
2429 static void
2430 _prolog(jit_state_t *_jit, jit_node_t *node)
2431 {
2432     jit_int32_t         reg;
2433     if (_jitc->function->define_frame || _jitc->function->assume_frame) {
2434         jit_int32_t     frame = -_jitc->function->frame;
2435         assert(_jitc->function->self.aoff >= frame);
2436         if (_jitc->function->assume_frame)
2437             return;
2438         _jitc->function->self.aoff = frame;
2439     }
2440     if (_jitc->function->allocar)
2441         _jitc->function->self.aoff &= -16;
2442     /* align at 16 bytes boundary */
2443     _jitc->function->stack = ((stack_framesize +
2444                               _jitc->function->self.alen -
2445                               _jitc->function->self.aoff) + 15) & -16;
2446     SAVEI(_SP_REGNO, -_jitc->function->stack, _SP_REGNO);
2447
2448     /* (most) other backends do not save incoming arguments, so,
2449      * only save locals here */
2450     if (jit_regset_tstbit(&_jitc->function->regset, _L0))
2451         stxi(OFF(0), _SP_REGNO, _L0_REGNO);
2452     if (jit_regset_tstbit(&_jitc->function->regset, _L1))
2453         stxi(OFF(1), _SP_REGNO, _L1_REGNO);
2454     if (jit_regset_tstbit(&_jitc->function->regset, _L2))
2455         stxi(OFF(2), _SP_REGNO, _L2_REGNO);
2456     if (jit_regset_tstbit(&_jitc->function->regset, _L3))
2457         stxi(OFF(3), _SP_REGNO, _L3_REGNO);
2458     if (jit_regset_tstbit(&_jitc->function->regset, _L4))
2459         stxi(OFF(4), _SP_REGNO, _L4_REGNO);
2460     if (jit_regset_tstbit(&_jitc->function->regset, _L5))
2461         stxi(OFF(5), _SP_REGNO, _L5_REGNO);
2462     if (jit_regset_tstbit(&_jitc->function->regset, _L6))
2463         stxi(OFF(6), _SP_REGNO, _L6_REGNO);
2464     if (jit_regset_tstbit(&_jitc->function->regset, _L7))
2465         stxi(OFF(7), _SP_REGNO, _L7_REGNO);
2466
2467     if (_jitc->function->allocar) {
2468         reg = jit_get_reg(jit_class_gpr);
2469         movi(rn(reg), BIAS(_jitc->function->self.aoff));
2470         /* Already "biased" by allocai */
2471         stxi_i(_jitc->function->aoffoff, _FP_REGNO, rn(reg));
2472         jit_unget_reg(reg);
2473     }
2474
2475     if (_jitc->function->self.call & jit_call_varargs) {
2476         for (reg = _jitc->function->vagp; jit_arg_reg_p(reg); ++reg)
2477             stxi(BIAS((16 + (__WORDSIZE == 32)) * sizeof(jit_word_t) +
2478                       reg * sizeof(jit_word_t)), _FP_REGNO, rn(_I0 + reg));
2479     }
2480 }
2481
2482 static void
2483 _epilog(jit_state_t *_jit, jit_node_t *node)
2484 {
2485     if (_jitc->function->assume_frame)
2486         return;
2487     /* (most) other backends do not save incoming arguments, so,
2488      * only save locals here */
2489     if (jit_regset_tstbit(&_jitc->function->regset, _L0))
2490         ldxi(_L0_REGNO, _FP_REGNO, _jitc->function->stack + OFF(0));
2491     if (jit_regset_tstbit(&_jitc->function->regset, _L1))
2492         ldxi(_L1_REGNO, _FP_REGNO, _jitc->function->stack + OFF(1));
2493     if (jit_regset_tstbit(&_jitc->function->regset, _L2))
2494         ldxi(_L2_REGNO, _FP_REGNO, _jitc->function->stack + OFF(2));
2495     if (jit_regset_tstbit(&_jitc->function->regset, _L3))
2496         ldxi(_L3_REGNO, _FP_REGNO, _jitc->function->stack + OFF(3));
2497     if (jit_regset_tstbit(&_jitc->function->regset, _L4))
2498         ldxi(_L4_REGNO, _FP_REGNO, _jitc->function->stack + OFF(4));
2499     if (jit_regset_tstbit(&_jitc->function->regset, _L5))
2500         ldxi(_L5_REGNO, _FP_REGNO, _jitc->function->stack + OFF(5));
2501     if (jit_regset_tstbit(&_jitc->function->regset, _L6))
2502         ldxi(_L6_REGNO, _FP_REGNO, _jitc->function->stack + OFF(6));
2503     if (jit_regset_tstbit(&_jitc->function->regset, _L7))
2504         ldxi(_L7_REGNO, _FP_REGNO, _jitc->function->stack + OFF(7));
2505     RESTOREI(0, 0, 0);
2506     RETL();
2507     NOP();
2508 }
2509
2510 static void
2511 _vastart(jit_state_t *_jit, jit_int32_t r0)
2512 {
2513     /* Initialize stack pointer to the first stack argument. */
2514     if (jit_arg_reg_p(_jitc->function->vagp))
2515         addi(r0, _FP_REGNO, BIAS((16 + (__WORDSIZE == 32) +
2516                                   _jitc->function->vagp) *
2517                                  sizeof(jit_word_t)));
2518     else
2519         addi(r0, _FP_REGNO, BIAS(_jitc->function->self.size));
2520 }
2521
2522 static void
2523 _vaarg(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2524 {
2525     assert(_jitc->function->self.call & jit_call_varargs);
2526
2527     /* Load argument. */
2528     ldr(r0, r1);
2529
2530     /* Update vararg stack pointer. */
2531     addi(r1, r1, sizeof(jit_word_t));
2532 }
2533
2534 static void
2535 _patch_at(jit_state_t *_jit, jit_word_t instr, jit_word_t label)
2536 {
2537     jit_instr_t          i;
2538     union {
2539         jit_int32_t     *i;
2540         jit_word_t       w;
2541     } u;
2542
2543     u.w = instr;
2544     i.v = u.i[0];
2545
2546     if (i.op.b == 0) {                          /* conditional branch */
2547         if (i.op2.b == 2 || i.op2.b == 6) {     /* int or float condition */
2548             i.disp22.b = (label - instr) >> 2;
2549             u.i[0] = i.v;
2550         }
2551 #  if __WORDSIZE == 64
2552         else if (i.op2.b == 1) {
2553             i.disp19.b = (label - instr) >> 2;
2554             u.i[0] = i.v;
2555         }
2556 #  endif
2557         else if (i.op2.b == 4) {        /* movi_p */
2558             /* SETHI */
2559             i.imm22.b = HI((int)label);
2560             u.i[0] = i.v;
2561             i.v = u.i[1];
2562             if (i.op.b == 2 && i.op3.b == 2) {
2563                 /* ORI */
2564                 i.simm13.b = LO(label);
2565                 u.i[1] = i.v;
2566 #  if __WORDSIZE == 64
2567                 i.v = u.i[2];
2568                 assert(i.op2.b == 4);
2569                 label = (label >> 32) & 0xffffffff;
2570                 i.imm22.b = HI((int)label);
2571                 u.i[2] = i.v;
2572                 i.v = u.i[3];
2573                 assert(i.op.b == 2 && i.op3.b == 2);
2574                 /* ORI */
2575                 i.simm13.b = LO(label);
2576                 u.i[3] = i.v;
2577 #  endif
2578             }
2579             else
2580                 abort();
2581         }
2582         else
2583             abort();
2584     }
2585     else
2586         abort();
2587 }
2588 #endif