2 * Copyright (C) 2013-2023 Free Software Foundation, Inc.
4 * This file is part of GNU lightning.
6 * GNU lightning is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU Lesser General Public License as published
8 * by the Free Software Foundation; either version 3, or (at your option)
11 * GNU lightning is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
13 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
14 * License for more details.
17 * Paulo Cesar Pereira de Andrade
31 /* 16 spill bytes; -52 for first actual stack argument */
32 #define params_offset -32
33 /* Assume all callee save registers may need to be spilled */
34 #define alloca_offset 192
48 #define _CR11_REGNO 11
49 #define ii(v) *_jit->pc.ui++ = v
50 #define f1(o,b,t,i) _f1(_jit,o,b,t,i)
51 static void _f1(jit_state_t*,jit_int32_t,
52 jit_int32_t,jit_int32_t,jit_int32_t);
53 #define f2(o,b,r,i,j) _f2(_jit,o,b,r,i,j)
54 static void _f2(jit_state_t*,jit_int32_t,jit_int32_t,
55 jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
56 #define f3(o,b,t,i,j) _f3(_jit,o,b,t,i,j)
57 static void _f3(jit_state_t*,jit_int32_t,jit_int32_t,
58 jit_int32_t,jit_int32_t,jit_int32_t);
59 #define f4(o,b,x,s,u,y,c,z,m,t) _f4(_jit,o,b,x,s,u,y,c,z,m,t)
60 static void _f4(jit_state_t*,jit_int32_t,jit_int32_t,
61 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
62 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
63 #define f5(o,b,i,s,a,y,c,z,m,t) _f5(_jit,o,b,i,s,a,y,c,z,m,t)
64 static void _f5(jit_state_t*,jit_int32_t,jit_int32_t,
65 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
66 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
67 #define f6(o,b,r,s,a,x,c,y,m,i) _f6(_jit,o,b,r,s,a,x,c,y,m,i)
68 static void _f6(jit_state_t*,jit_int32_t,jit_int32_t,
69 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
70 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
71 #define f7(o,r,i) _f7(_jit,o,r,i)
72 static void _f7(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
73 #define f8(o,r2,r1,cf,e1,x,e2,y,d,t) _f8(_jit,o,r2,r1,cf,e1,x,e2,y,d,t)
74 static void _f8(jit_state_t*,jit_int32_t,
75 jit_int32_t,jit_int32_t,jit_int32_t,
76 jit_int32_t,jit_int32_t,jit_int32_t,
77 jit_int32_t,jit_int32_t,jit_int32_t);
78 #define f9(o,r,t,cf,e1,im) _f9(_jit,o,r,t,cf,e1,im)
79 static void _f9(jit_state_t*,
80 jit_int32_t,jit_int32_t,jit_int32_t,
81 jit_int32_t,jit_int32_t,jit_int32_t);
82 #define f10(o,r2,r1,u,v,w,x,sa,y,t) _f10(_jit,o,r2,r1,u,v,w,x,sa,y,t)
83 static void _f10(jit_state_t*,jit_int32_t,jit_int32_t,
84 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
85 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
86 #define f11(o,r2,r1,c,x,y,z,u,t) _f11(_jit,o,r2,r1,c,x,y,z,u,t)
87 static void _f11(jit_state_t*,jit_int32_t,
88 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
89 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
90 #define f12(o,r,t,c,x,se,y,c1,z,clen) _f12(_jit,o,r,t,c,x,se,y,c1,z,clen)
91 static void _f12(jit_state_t*,jit_int32_t,jit_int32_t,
92 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
93 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
94 #define f13(o,t,r,c,x,nz,c1,clen) _f13(_jit,o,t,r,c,x,nz,c1,clen)
95 static void _f13(jit_state_t*,jit_int32_t,jit_int32_t,
96 jit_int32_t,jit_int32_t,jit_int32_t,
97 jit_int32_t,jit_int32_t,jit_int32_t);
98 #define f13x(o,t,i,c,x,nz,c1,clen) _f13x(_jit,o,t,i,c,x,nz,c1,clen)
99 static void _f13x(jit_state_t*,jit_int32_t,jit_int32_t,
100 jit_int32_t,jit_int32_t,jit_int32_t,
101 jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
102 #define f14(o,r2,r1,c,x,cp,y,cpos,t) _f14(_jit,o,r2,r1,c,x,cp,y,cpos,t)
103 static void _f14(jit_state_t*,jit_int32_t,
104 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
105 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
106 #define f15(o,r,t,c,c1,p,se,pos,clen) _f15(_jit,o,r,t,c,c1,p,se,pos,clen)
107 static void _f15(jit_state_t*,jit_int32_t,
108 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
109 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
110 #define f16(o,t,r,c,c1,cp,nz,cpos,clen) _f16(_jit,o,t,r,c,c1,cp,nz,cpos,clen)
111 static void _f16(jit_state_t*,jit_int32_t,
112 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
113 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
114 #define f16x(o,t,i,c,c1,cp,nz,cpos,clen) _f16x(_jit,o,t,i,c,c1,cp,nz,cpos,clen)
115 static void _f16x(jit_state_t*,jit_int32_t,
116 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
117 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
118 #define f17(o,r2,r1,c,i,n) _f17(_jit,o,r2,r1,c,i,n)
119 static void _f17(jit_state_t*,jit_int32_t,jit_int32_t,
120 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
121 #define f17x(o,r2,r1,c,i,n) _f17x(_jit,o,r2,r1,c,i,n)
122 static void _f17x(jit_state_t*,jit_int32_t,jit_int32_t,
123 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
124 #define f18(o,p,r,c,i,n) _f18(_jit,o,p,r,c,i,n)
125 static void _f18(jit_state_t*,jit_int32_t,jit_int32_t,
126 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
127 #define f19(o,b,s,i,n) _f19(_jit,o,b,s,i,n)
128 static void _f19(jit_state_t*,jit_int32_t,jit_int32_t,
129 jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
130 #define f20(o,t,i,g,n) _f20(_jit,o,t,i,g,n)
131 static void _f20(jit_state_t*,jit_int32_t,jit_int32_t,
132 jit_int32_t,jit_int32_t,jit_int32_t);
133 #define f21(o,t,x,y,n) _f21(_jit,o,t,x,y,n)
134 static void _f21(jit_state_t*,jit_int32_t,jit_int32_t,
135 jit_int32_t,jit_int32_t,jit_int32_t);
136 #define f22(o,b,x,r,n,p) _f22(_jit,o,b,x,r,n,p)
137 static void _f22(jit_state_t*,jit_int32_t,jit_int32_t,
138 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
139 #define f23(o,a,b,c,d,e,f,g,h) _f23(_jit,o,a,b,c,d,e,f,g,h)
140 static void _f23(jit_state_t*,jit_int32_t,
141 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
142 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
143 #define f24(o,b,x,s,y,m,r) _f24(_jit,o,b,x,s,y,m,r)
144 static void _f24(jit_state_t*,jit_int32_t,
145 jit_int32_t,jit_int32_t,jit_int32_t,
146 jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
147 #define f25(o,b,i,s,y,m,r) _f25(_jit,o,b,i,s,y,m,r)
148 static void _f25(jit_state_t*,jit_int32_t,
149 jit_int32_t,jit_int32_t,jit_int32_t,
150 jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
151 #define f26(o,b,x,s,y,m,r) _f26(_jit,o,b,x,s,y,m,r)
152 static void _f26(jit_state_t*,jit_int32_t,
153 jit_int32_t,jit_int32_t,jit_int32_t,
154 jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
155 #define f27(o,i,j) _f27(_jit,o,i,j)
156 static void _f27(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
157 #define f28(o,i) _f28(_jit,o,i)
158 static void _f28(jit_state_t*,jit_int32_t,jit_int32_t) maybe_unused;
159 #define f29(o,r,x,s,y,t) _f29(_jit,o,r,x,s,y,t)
160 static void _f29(jit_state_t*,jit_int32_t,jit_int32_t,
161 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
162 #define f30(o,b,r,s,x,y,t) _f30(_jit,o,b,r,s,x,y,t)
163 static void _f30(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,
164 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
165 #define f31(o,t,r,v,x,y) _f31(_jit,o,t,r,v,x,y)
166 static void _f31(jit_state_t*,jit_int32_t,jit_int32_t,
167 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
168 #define f33(o,x,r,y,z,u) _f33(_jit,o,x,r,y,z,u)
169 static void _f33(jit_state_t*,jit_int32_t,jit_int32_t,
170 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
171 #define f34(o,o1,x,sf,n,o2) _f34(_jit,o,o1,x,sf,n,o2)
172 static void _f34(jit_state_t*,jit_int32_t,jit_int32_t,
173 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
174 #define f35(o,op,x,sf,n,t) _f35(_jit,o,op,x,sf,n,t)
175 static void _f35(jit_state_t*,jit_int32_t,jit_int32_t,
176 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
177 #define f36(o,r,o1,x,sf,n,o2) _f36(_jit,o,r,o1,x,sf,n,o2)
178 static void _f36(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,
179 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
180 #define f37(o,r2,r1,o1,x,sf,n,o2) _f37(_jit,o,r2,r1,o1,x,sf,n,o2)
181 static void _f37(jit_state_t*,jit_int32_t,jit_int32_t,
182 jit_int32_t,jit_int32_t,jit_int32_t,
183 jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
184 #define f38(o,s,u,n) _f38(_jit,o,s,u,n)
185 static void _f38(jit_state_t*,jit_int32_t,
186 jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
187 /* nulify next instruction if condition is met with addition */
188 #define ADD_CF_NV 0 /* never */
189 #define ADD_CF_EQ 2 /* O1 == -O2 (word) */
190 #define ADD_CF_LT 4 /* O1 < -O2 (signed)*/
191 #define ADD_CF_LE 6 /* O1 <= -O2 (signed) */
192 #define ADD_CF_NUV 8 /* O1 + O2 does not overflow (unsigned) */
193 #define ADD_CF_ZNV 10 /* O1 + O2 is zero or no overflow (unsigned) */
194 #define ADD_CF_SV 12 /* O1 + O2 overflows (signed) */
195 #define ADD_CF_OD 14 /* O1 + O2 is odd */
196 #define ADD_CF_TR 1 /* always */
197 #define ADD_CF_NE 3 /* O1 != -O2 */
198 #define ADD_CF_GE 5 /* O1 >= -O2 (signed) */
199 #define ADD_CF_GT 7 /* O1 > -O2 (signed) */
200 #define ADD_CF_UV 9 /* O1 + O2 overflows (unsigned) */
201 #define ADD_CF_VNZ 11 /* O1 + O2 is nonzero and overflows (unsigned) */
202 #define ADD_CF_NSV 13 /* O1 + O2 does not overflow (signed) */
203 #define ADD_CF_EV 15 /* O1 + O2 is even */
204 #define ADD_EN_NONE 6 /* none */
205 #define ADD_EN_C 7 /* with carry */
206 #define ADD_EN_L 10 /* logical */
207 #define ADD_EN_TSV 12 /* trap on signed overflow */
208 #define ADD_EN_C_TSV 13 /* with carry and trap on signed overflow */
209 #define ADDI_OE_TC 0 /* trap on condition */
210 #define ADDI_OE_TSV_TC 1 /* trap on signed overflow or condition */
211 #define ADDI_OE_NONE 2 /* none */
212 #define ADDI_OE_TSV 3 /* trap on signed overflow */
213 #define ADD_(en,cf,r1,r2,t) f8(0x2,r2,r1,cf,en>>2,1,en&1,0,0,t)
214 #define ADD(r1,r2,t) ADD_(ADD_EN_NONE,ADD_CF_NV,r1,r2,t)
215 #define ADD_C(r1,r2,t) ADD_(ADD_EN_C,ADD_CF_NV,r1,r2,t)
216 #define ADD_L(r1,r2,t) ADD_(ADD_EN_L,ADD_CF_NV,r1,r2,t)
217 #define ADDB_(cc,r1,r2,t) f17(0x28|((cc&1)<<1),r2,r1,cc>>1,t,0)
218 #define ADDB(r1,r2,t) ADDB_(ADD_CF_NV,r1,r2,t)
219 #define ADDB_EQ(r1,r2,t) ADDB_(ADD_CF_EQ,r1,r2,t)
220 #define ADDB_LT(r1,r2,t) ADDB_(ADD_CF_LT,r1,r2,t)
221 #define ADDB_LE(r1,r2,t) ADDB_(ADD_CF_LE,r1,r2,t)
222 #define ADDB_NUV(r1,r2,t) ADDB_(ADD_CF_NUV,r1,r2,t)
223 #define ADDB_ZNV(r1,r2,t) ADDB_(ADD_CF_ZNV,r1,r2,t)
224 #define ADDB_SV(r1,r2,t) ADDB_(ADD_CF_SV,r1,r2,t)
225 #define ADDB_OD(r1,r2,t) ADDB_(ADD_CF_OD,r1,r2,t)
226 #define ADDB_TR(r1,r2,t) ADDB_(ADD_CF_TR,r1,r2,t)
227 #define ADDB_NE(r1,r2,t) ADDB_(ADD_CF_NE,r1,r2,t)
228 #define ADDB_GE(r1,r2,t) ADDB_(ADD_CF_GE,r1,r2,t)
229 #define ADDB_GT(r1,r2,t) ADDB_(ADD_CF_GT,r1,r2,t)
230 #define ADDB_UV(r1,r2,t) ADDB_(ADD_CF_UV,r1,r2,t)
231 #define ADDB_VNZ(r1,r2,t) ADDB_(ADD_CF_VNZ,r1,r2,t)
232 #define ADDB_NSV(r1,r2,t) ADDB_(ADD_CF_NSV,r1,r2,t)
233 #define ADDB_EV(r1,r2,t) ADDB_(ADD_CF_EV,r2,r1,t)
234 #define ADDB_N_(cc,r1,r2,t) f17(0x28|((cc&1)<<1),r2,r1,cc>>1,t,1)
235 #define ADDB_N(r1,r2,t) ADDB_N_(ADD_CF_NV,r1,r2,t)
236 #define ADDB_N_EQ(r1,r2,t) ADDB_N_(ADD_CF_EQ,r1,r2,t)
237 #define ADDB_N_LT(r1,r2,t) ADDB_N_(ADD_CF_LT,r1,r2,t)
238 #define ADDB_N_LE(r1,r2,t) ADDB_N_(ADD_CF_LE,r1,r2,t)
239 #define ADDB_N_NUV(r1,r2,t) ADDB_N_(ADD_CF_NUV,r1,r2,t)
240 #define ADDB_N_ZNV(r1,r2,t) ADDB_N_(ADD_CF_ZNV,r1,r2,t)
241 #define ADDB_N_SV(r1,r2,t) ADDB_N_(ADD_CF_SV,r1,r2,t)
242 #define ADDB_N_OD(r1,r2,t) ADDB_N_(ADD_CF_OD,r1,r2,t)
243 #define ADDB_N_TR(r1,r2,t) ADDB_N_(ADD_CF_TR,r1,r2,t)
244 #define ADDB_N_NE(r1,r2,t) ADDB_N_(ADD_CF_NE,r1,r2,t)
245 #define ADDB_N_GE(r1,r2,t) ADDB_N_(ADD_CF_GE,r1,r2,t)
246 #define ADDB_N_GT(r1,r2,t) ADDB_N_(ADD_CF_GT,r1,r2,t)
247 #define ADDB_N_UV(r1,r2,t) ADDB_N_(ADD_CF_UV,r1,r2,t)
248 #define ADDB_N_VNZ(r1,r2,t) ADDB_N_(ADD_CF_VNZ,r1,r2,t)
249 #define ADDB_N_NSV(r1,r2,t) ADDB_N_(ADD_CF_NSV,r1,r2,t)
250 #define ADDB_N_EV(r1,r2,t) ADDB_N_(ADD_CF_EV,r1,r2,t)
251 #define ADDI_(ec,cf,i,r,t) f9(0x2c|(ec>>1),r,t,cf,ec&1,i)
252 #define ADDI(i,r,t) ADDI_(ADDI_OE_NONE,ADD_CF_NV,i,r,t)
253 #define ADDIB_(cc,i,r,t) f17x(0x29|((cc&1)<<1),r,i,cc>>1,t,0)
254 #define ADDIB(i,r,t) ADDIB_(ADD_CF_NV,i,r,t)
255 #define ADDIB_EQ(i,r,t) ADDIB_(ADD_CF_EQ,i,r,t)
256 #define ADDIB_LT(i,r,t) ADDIB_(ADD_CF_LT,i,r,t)
257 #define ADDIB_LE(i,r,t) ADDIB_(ADD_CF_LE,i,r,t)
258 #define ADDIB_NUV(i,r,t) ADDIB_(ADD_CF_NUV,i,r,t)
259 #define ADDIB_ZNV(i,r,t) ADDIB_(ADD_CF_ZNV,i,r,t)
260 #define ADDIB_SV(i,r,t) ADDIB_(ADD_CF_SV,i,r,t)
261 #define ADDIB_OD(i,r,t) ADDIB_(ADD_CF_OD,i,r,t)
262 #define ADDIB_TR(i,r,t) ADDIB_(ADD_CF_TR,i,r,t)
263 #define ADDIB_NE(i,r,t) ADDIB_(ADD_CF_NE,i,r,t)
264 #define ADDIB_GE(i,r,t) ADDIB_(ADD_CF_GE,i,r,t)
265 #define ADDIB_GT(i,r,t) ADDIB_(ADD_CF_GT,i,r,t)
266 #define ADDIB_UV(i,r,t) ADDIB_(ADD_CF_UV,i,r,t)
267 #define ADDIB_VNZ(i,r,t) ADDIB_(ADD_CF_VNZ,i,r,t)
268 #define ADDIB_NSV(i,r,t) ADDIB_(ADD_CF_NSV,i,r,t)
269 #define ADDIB_EV(i,r,t) ADDIB_(ADD_CF_EV,i,r,t)
270 #define ADDIB_N_(cc,i,r,t) f17x(0x29|((cc&1)<<1),r,i,cc>>1,t,1)
271 #define ADDIB_N(i,r,t) ADDIB_N_(ADD_CF_NV,i,r,t)
272 #define ADDIB_N_EQ(i,r,t) ADDIB_N_(ADD_CF_EQ,i,r,t)
273 #define ADDIB_N_LT(i,r,t) ADDIB_N_(ADD_CF_LT,i,r,t)
274 #define ADDIB_N_LE(i,r,t) ADDIB_N_(ADD_CF_LE,i,r,t)
275 #define ADDIB_N_NUV(i,r,t) ADDIB_N_(ADD_CF_NUV,i,r,t)
276 #define ADDIB_N_ZNV(i,r,t) ADDIB_N_(ADD_CF_ZNV,i,r,t)
277 #define ADDIB_N_SV(i,r,t) ADDIB_N_(ADD_CF_SV,i,r,t)
278 #define ADDIB_N_OD(i,r,t) ADDIB_N_(ADD_CF_OD,i,r,t)
279 #define ADDIB_N_TR(i,r,t) ADDIB_N_(ADD_CF_TR,i,r,t)
280 #define ADDIB_N_NE(i,r,t) ADDIB_N_(ADD_CF_NE,i,r,t)
281 #define ADDIB_N_GE(i,r,t) ADDIB_N_(ADD_CF_GE,i,r,t)
282 #define ADDIB_N_GT(i,r,t) ADDIB_N_(ADD_CF_GT,i,r,t)
283 #define ADDIB_N_UV(i,r,t) ADDIB_N_(ADD_CF_UV,i,r,t)
284 #define ADDIB_N_VNZ(i,r,t) ADDIB_N_(ADD_CF_VNZ,i,r,t)
285 #define ADDIB_N_NSV(i,r,t) ADDIB_N_(ADD_CF_NSV,i,r,t)
286 #define ADDIB_N_EV(i,r,t) ADDIB_N_(ADD_CF_EV,0,i,r,t)
287 #define ADDIL(i,r) f7(0xa,r,i)
288 #define LOG_CC_NV 0 /* never */
289 #define LOG_CC_EQ 1 /* all bits are 0 */
290 #define LOG_CC_LT 2 /* leftmost bit is 1 */
291 #define LOG_CC_LE 3 /* leftmost bit is 1 or all bits are 0 */
292 #define LOG_CC_OD 7 /* rightmost bit is 1 */
293 #define LOG_CC_TR 8 /* always */
294 #define LOG_CC_NE 9 /* some bits are 1 */
295 #define LOG_CC_GE 10 /* leftmost bit is 0 */
296 #define LOG_CC_GT 11 /* leftmost bit is 0 or some bits are 1 */
297 #define LOG_CC_EV 15 /* rightmost bit is 0 */
298 #define AND_(cc,r1,r2,t) f8(0x2,r2,r1,cc,0,1,0,0,0,t)
299 #define AND(r1,r2,t) AND_(LOG_CC_NV,r1,r2,t)
300 #define ANDCM_(cc,r1,r2,t) f8(0x2,r2,r1,cc,0,0,0,0,0,t)
301 #define ANDCM(r1,r2,t) ANDCM_(LOG_CC_NV,r1,r2,t)
302 #define B_(n,i,t) f20(0x3a,t,i,0,n)
303 #define B(i,t) B_(0,i,t)
304 #define B_N(i,t) B_(1,i,t)
305 #define B_L(i) B_(0,i,_RP_REGNO)
306 #define B_L_N(i) B_(1,i,_RP_REGNO)
307 #define BB_CC_LT 0 /* leftmost bit in word is 1 */
308 #define BB_CC_GE 1 /* leftmost bit in word is 0 */
309 #define BB_(c,r,i) f18(0x30,0,r,c,i,0)
310 #define BB_N_(c,r,i) f18(0x30,0,r,c,i,1)
311 #define BBI_(c,r,p,i) f18(0x31,p,r,c,i,0)
312 #define BBI_N_(c,r,p,i) f18(0x31,p,r,c,i,1)
313 #define BB(c,r,i) BB_(c,r,i)
314 #define BBI_LT(r,p,i) BBI_(BB_CC_LT,r,p,i)
315 #define BBI_GE(r,p,i) BBI_(BB_CC_GE,r,p,i)
316 #define BB_N(c,r,i) BB_(c,r,i)
317 #define BBI_N_LT(r,p,i) BBI_N_(BB_CC_LT,r,p,i)
318 #define BBI_N_GE(r,p,i) BBI_N_(BB_CC_GE,r,p,i)
319 #define BE(i,s,b) f19(0x38,b,s,i,0)
320 #define BE_L(i,s,b) f19(0x39,b,s,i,0)
321 #define BE_L_N(i,s,b) f19(0x39,b,s,i,1)
322 #define BLR(x,t) f21(0x3a,t,x,2,0)
323 #define BLR_N(x,t) f21(0x3a,t,x,2,1)
324 #define BREAK(i,j) f27(0,j,i)
325 #define BV(x,b) f21(0x3a,b,x,6,0)
326 #define BV_N(x,b) f21(0x3a,b,x,6,1)
327 #define BVE(b) f22(0x3a,b,6,0,0,0)
328 #define BVE_N(b) f22(0x3a,b,6,0,1,0)
329 #define BVE_L(b) f22(0x3a,b,7,0,0,0)
330 #define BVE_L_N(b) f22(0x3a,b,7,0,0,1)
332 #define II_C_M (1<<5)
333 #define II_C_S (1<<13)
334 #define II_C_SM (II_C_S|II_C_M)
336 #define II_AU_PRE ((1<<13)|II_C_M)
337 #define II_AU_POS II_C_M
338 #define LD_CC_H_NONE 0 /* No hint */
339 #define LD_CC_H_SPL 2 /* Spatial Locality */
340 #define CLRBTS() f23(0x3a,0,0,2,0,0,1,0,1)
341 #define CS_CC_NV 0 /* never */
342 #define CS_CC_EQ 2 /* O1 = O2 */
343 #define CS_CC_LT 4 /* O1 < O2 (signed) */
344 #define CS_CC_LE 6 /* O1 <= O2 (signed) */
345 #define CS_CC_ULT 8 /* O1 < O2 (unsigned) */
346 #define CS_CC_ULE 10 /* O1 <= O2 (unsigned) */
347 #define CS_CC_SV 12 /* O1 - O2 overflows (signed) */
348 #define CS_CC_OD 14 /* O1 - O2 is odd */
349 #define CS_CC_TR 1 /* always */
350 #define CS_CC_NE 3 /* O1 != O2 */
351 #define CS_CC_GE 5 /* O1 >= O2 (signed) */
352 #define CS_CC_GT 7 /* O1 > O2 (signed) */
353 #define CS_CC_UGE 9 /* O1 >= O2 (unsigned) */
354 #define CS_CC_UGT 11 /* O1 > O2 (unsigned) */
355 #define CS_CC_NSV 13 /* O1 - O2 does not overflows (signed) */
356 #define CS_CC_EV 15 /* O1 - O2 is even */
357 #define CMPB_(c,r1,r2,i) f17((c)&1?0x22:0x20,r2,r1,(c)>>1,i,0)
358 #define CMPB(r1,r2,i) CMPB_(CS_CC_NV,r1,r2,i)
359 #define CMPB_EQ(r1,r2,i) CMPB_(CS_CC_EQ,r1,r2,i)
360 #define CMPB_LT(r1,r2,i) CMPB_(CS_CC_LT,r1,r2,i)
361 #define CMPB_LE(r1,r2,i) CMPB_(CS_CC_LE,r1,r2,i)
362 #define CMPB_ULT(r1,r2,i) CMPB_(CS_CC_ULT,r1,r2,i)
363 #define CMPB_ULE(r1,r2,i) CMPB_(CS_CC_ULE,r1,r2,i)
364 #define CMPB_SV(r1,r2,i) CMPB_(CS_CC_SV,r1,r2,i)
365 #define CMPB_OD(r1,r2,i) CMPB_(CS_CC_OD,r1,r2,i)
366 #define CMPB_TR(r1,r2,i) CMPB_(CS_CC_TR,r1,r2,i)
367 #define CMPB_NE(r1,r2,i) CMPB_(CS_CC_NE,r1,r2,i)
368 #define CMPB_GE(r1,r2,i) CMPB_(CS_CC_GE,r1,r2,i)
369 #define CMPB_GT(r1,r2,i) CMPB_(CS_CC_GT,r1,r2,i)
370 #define CMPB_UGE(r1,r2,i) CMPB_(CS_CC_UGE,r1,r2,i)
371 #define CMPB_UGT(r1,r2,i) CMPB_(CS_CC_UGT,r1,r2,i)
372 #define CMPB_NSV(r1,r2,i) CMPB_(CS_CC_NSV,r1,r2,i)
373 #define CMPB_EV(r1,r2,i) CMPB_(CS_CC_EV,r1,r2,i)
374 #define CMPB_N_(c,r1,r2,i) f17((c)&1?0x22:0x20,r2,r1,(c)>>1,i,1)
375 #define CMPB_N(r1,r2,i) CMPB_N_(CS_CC_NV,r1,r2,i)
376 #define CMPB_EQ_N(r1,r2,i) CMPB_N_(CS_CC_EQ,r1,r2,i)
377 #define CMPB_LT_N(r1,r2,i) CMPB_N_(CS_CC_LT,r1,r2,i)
378 #define CMPB_LE_N(r1,r2,i) CMPB_N_(CS_CC_LE,r1,r2,i)
379 #define CMPB_ULT_N(r1,r2,i) CMPB_N_(CS_CC_ULT,r1,r2,i)
380 #define CMPB_ULE_N(r1,r2,i) CMPB_N_(CS_CC_ULE,r1,r2,i)
381 #define CMPB_SV_N(r1,r2,i) CMPB_N_(CS_CC_SV,r1,r2,i)
382 #define CMPB_OD_N(r1,r2,i) CMPB_N_(CS_CC_OD,r1,r2,i)
383 #define CMPB_TR_N(r1,r2,i) CMPB_N_(CS_CC_TR,r1,r2,i)
384 #define CMPB_NE_N(r1,r2,i) CMPB_N_(CS_CC_NE,r1,r2,i)
385 #define CMPB_GE_N(r1,r2,i) CMPB_N_(CS_CC_GE,r1,r2,i)
386 #define CMPB_GT_N(r1,r2,i) CMPB_N_(CS_CC_GT,r1,r2,i)
387 #define CMPB_UGE_N(r1,r2,i) CMPB_N_(CS_CC_UGE,r1,r2,i)
388 #define CMPB_UGT_N(r1,r2,i) CMPB_N_(CS_CC_UGT,r1,r2,i)
389 #define CMPB_NSV_N(r1,r2,i) CMPB_N_(CS_CC_NSV,r1,r2,i)
390 #define CMPB_EV_N(r1,r2,i) CMPB_N_(CS_CC_EV,r1,r2,i)
391 #define CMPCLR_(c,r1,r2,i) f8(0x2,r2,r1,c,2,0,0,2,0,i)
392 #define CMPCLR(r1,r2,i) CMPCLR_(CS_CC_NV,r1,r2,i)
393 #define CMPCLR_EQ(r1,r2,i) CMPCLR_(CS_CC_EQ,r1,r2,i)
394 #define CMPCLR_LT(r1,r2,i) CMPCLR_(CS_CC_LT,r1,r2,i)
395 #define CMPCLR_LE(r1,r2,i) CMPCLR_(CS_CC_LE,r1,r2,i)
396 #define CMPCLR_ULT(r1,r2,i) CMPCLR_(CS_CC_ULT,r1,r2,i)
397 #define CMPCLR_ULE(r1,r2,i) CMPCLR_(CS_CC_ULE,r1,r2,i)
398 #define CMPCLR_SV(r1,r2,i) CMPCLR_(CS_CC_SV,r1,r2,i)
399 #define CMPCLR_OD(r1,r2,i) CMPCLR_(CS_CC_OD,r1,r2,i)
400 #define CMPCLR_TR(r1,r2,i) CMPCLR_(CS_CC_TR,r1,r2,i)
401 #define CMPCLR_NE(r1,r2,i) CMPCLR_(CS_CC_NE,r1,r2,i)
402 #define CMPCLR_GE(r1,r2,i) CMPCLR_(CS_CC_GE,r1,r2,i)
403 #define CMPCLR_GT(r1,r2,i) CMPCLR_(CS_CC_GT,r1,r2,i)
404 #define CMPCLR_UGE(r1,r2,i) CMPCLR_(CS_CC_UGE,r1,r2,i)
405 #define CMPCLR_UGT(r1,r2,i) CMPCLR_(CS_CC_UGT,r1,r2,i)
406 #define CMPCLR_NSV(r1,r2,i) CMPCLR_(CS_CC_NSV,r1,r2,i)
407 #define CMPCLR_EV(r1,r2,i) CMPCLR_(CS_CC_EV,r1,r2,i)
408 #define CMPIB_(c,i,r,t) f17x((c)&1?0x23:0x21,r,i,(c)>>1,t,0)
409 #define CMPIB_NONE(i,r,t) CMPIB_(CS_CC_NV,i,r,t)
410 #define CMPIB_EQ(i,r,t) CMPIB_(CS_CC_EQ,i,r,t)
411 #define CMPIB_LT(i,r,t) CMPIB_(CS_CC_LT,i,r,t)
412 #define CMPIB_LE(i,r,t) CMPIB_(CS_CC_LE,i,r,t)
413 #define CMPIB_ULT(i,r,t) CMPIB_(CS_CC_ULT,i,r,t)
414 #define CMPIB_ULE(i,r,t) CMPIB_(CS_CC_ULE,i,r,t)
415 #define CMPIB_SV(i,r,t) CMPIB_(CS_CC_SV,i,r,t)
416 #define CMPIB_OD(i,r,t) CMPIB_(CS_CC_OD,i,r,t)
417 #define CMPIB(i,r,t) CMPIB_(CS_CC_TR,i,r,t)
418 #define CMPIB_NE(i,r,t) CMPIB_(CS_CC_NE,i,r,t)
419 #define CMPIB_GE(i,r,t) CMPIB_(CS_CC_GE,i,r,t)
420 #define CMPIB_GT(i,r,t) CMPIB_(CS_CC_GT,i,r,t)
421 #define CMPIB_UGE(i,r,t) CMPIB_(CS_CC_UGE,i,r,t)
422 #define CMPIB_UGT(i,r,t) CMPIB_(CS_CC_UGT,i,r,t)
423 #define CMPIB_NSV(i,r,t) CMPIB_(CS_CC_NSV,i,r,t)
424 #define CMPIB_EV(i,r,t) CMPIB_(CS_CC_EV,i,r,t)
425 #define CMPIB_N_(c,i,r,t) f17x((c)&1?0x23:0x21,r,i,(c)>>1,t,1)
426 #define CMPIB_NONE_N(i,r,t) CMPIB_N_(CS_CC_NV,i,r,t)
427 #define CMPIB_EQ_N(i,r,t) CMPIB_N_(CS_CC_EQ,i,r,t)
428 #define CMPIB_LT_N(i,r,t) CMPIB_N_(CS_CC_LT,i,r,t)
429 #define CMPIB_LE_N(i,r,t) CMPIB_N_(CS_CC_LE,i,r,t)
430 #define CMPIB_ULT_N(i,r,t) CMPIB_N_(CS_CC_ULT,i,r,t)
431 #define CMPIB_ULE_N(i,r,t) CMPIB_N_(CS_CC_ULE,i,r,t)
432 #define CMPIB_SV_N(i,r,t) CMPIB_N_(CS_CC_SV,i,r,t)
433 #define CMPIB_OD_N(i,r,t) CMPIB_N_(CS_CC_OD,i,r,t)
434 #define CMPIB_N(i,r,t) CMPIB_N_(CS_CC_TR,i,r,t)
435 #define CMPIB_NE_N(i,r,t) CMPIB_N_(CS_CC_NE,i,r,t)
436 #define CMPIB_GE_N(i,r,t) CMPIB_N_(CS_CC_GE,i,r,t)
437 #define CMPIB_GT_N(i,r,t) CMPIB_N_(CS_CC_GT,i,r,t)
438 #define CMPIB_UGE_N(i,r,t) CMPIB_N_(CS_CC_UGE,i,r,t)
439 #define CMPIB_UGT_N(i,r,t) CMPIB_N_(CS_CC_UGT,i,r,t)
440 #define CMPIB_NSV_N(i,r,t) CMPIB_N_(CS_CC_NSV,i,r,t)
441 #define CMPIB_EV_N(i,r,t) CMPIB_N_(CS_CC_EV,i,r,t)
442 #define CMPICLR_(c,i,r,t) f9(0x24,r,t,c,0,i)
443 #define CMPICLR(i,r,t) CMPICLR_(CS_CC_NV,i,r,t)
444 #define CMPICLR_EQ(i,r,t) CMPICLR_(CS_CC_EQ,i,r,t)
445 #define CMPICLR_LT(i,r,t) CMPICLR_(CS_CC_LT,i,r,t)
446 #define CMPICLR_LE(i,r,t) CMPICLR_(CS_CC_LE,i,r,t)
447 #define CMPICLR_ULT(i,r,t) CMPICLR_(CS_CC_ULT,i,r,t)
448 #define CMPICLR_ULE(i,r,t) CMPICLR_(CS_CC_ULE,i,r,t)
449 #define CMPICLR_SV(i,r,t) CMPICLR_(CS_CC_SV,i,r,t)
450 #define CMPICLR_OD(i,r,t) CMPICLR_(CS_CC_OD,i,r,t)
451 #define CMPICLR_TR(i,r,t) CMPICLR_(CS_CC_TR,i,r,t)
452 #define CMPICLR_NE(i,r,t) CMPICLR_(CS_CC_NE,i,r,t)
453 #define CMPICLR_GE(i,r,t) CMPICLR_(CS_CC_GE,i,r,t)
454 #define CMPICLR_GT(i,r,t) CMPICLR_(CS_CC_GT,i,r,t)
455 #define CMPICLR_UGE(i,r,t) CMPICLR_(CS_CC_UGE,i,r,t)
456 #define CMPICLR_UGT(i,r,t) CMPICLR_(CS_CC_UGT,i,r,t)
457 #define CMPICLR_NSV(i,r,t) CMPICLR_(CS_CC_NSV,i,r,t)
458 #define CMPICLR_EV(i,r,t) CMPICLR_(CS_CC_EV,i,r,t)
459 #define COPR(u,s) f38(0x0c,s,u,0)
460 #define UI_CF_NONE 0 /* never */
461 #define UI_CF_SBZ 2 /* some byte zero */
462 #define UI_CF_SHZ 3 /* some halfword zero */
463 #define UI_CF_SDC 4 /* some digit carry */
464 #define UI_CF_SBC 6 /* some byte carry */
465 #define UI_CF_SHC 7 /* some halfword carry */
466 #define UI_TR_SHC 8 /* always */
467 #define UI_CF_NBZ 10 /* no byte zero */
468 #define UI_CF_NHZ 11 /* no halfword zero */
469 #define UI_CF_NDC 12 /* no digit carry */
470 #define UI_CF_NBC 14 /* no byte carry */
471 #define UI_CF_NHC 15 /* no halfword carry */
472 #define DCOR_(e1,cf,r,t) f8(0x2,r,0,cf,2,1,1,e1,0,t)
473 #define DCOR(r,t) DCOR_(2,UI_CF_NONE,r,t)
474 #define DCOR_I(r,t) DCOR_(3,UI_CF_NONE,r,t)
475 #define SED_C_NEVER 0 /* never */
476 #define SED_C_EQ 1 /* all bits 0 */
477 #define SED_C_LT 2 /* lefmost bits 1 */
478 #define SED_C_OD 3 /* rightmost bit 1 */
479 #define SED_C_TR 4 /* always */
480 #define SED_C_NE 5 /* some bit 1 */
481 #define SED_C_GE 6 /* lefmost bits 1 */
482 #define SED_C_EV 7 /* rightmost bit 0 */
483 #define DEPW(r,len,t) f13(0x35,t,r,SED_C_NEVER,0,1,0,len)
484 #define DEPW_Z(r,len,t) f13(0x35,t,r,SED_C_NEVER,0,0,0,len)
485 #define DEPWR(r,pos,len,t) f16(0x35,t,r,SED_C_NEVER,0,1,1,31-(pos),len)
486 #define DEPWR_Z(r,pos,len,t) f16(0x35,t,r,SED_C_NEVER,0,1,0,31-(pos),len)
487 #define SHLWI(r,sa,t) DEPWR_Z(r,31-(sa),32-(sa),t)
488 #define DEPWI(i,len,t) f13x(0x35,t,i,SED_C_NEVER,2,1,0,len)
489 #define DEPWI_Z(i,len,t) f13x(0x35,t,i,SED_C_NEVER,2,0,0,len)
490 #define DEPWRI(i,pos,len,t) f16x(0x35,t,i,SED_C_NEVER,1,1,1,31-(pos),len)
491 #define DEPWRI_Z(i,pos,len,t) f16x(0x35,t,i,SED_C_NEVER,1,1,0,31-(pos),len)
492 #define DIAG(i) f28(0x5,i)
493 #define DS(r1,r2,t) f8(0x2,r2,r1,ADD_CF_NV,1,0,0,1,0,t)
494 #define EXTRW(r,len,t) f12(0x34,r,t,SED_C_NEVER,2,1,0,0,0,len)
495 #define EXTRW_U(r,len,t) f12(0x34,r,t,SED_C_NEVER,2,0,0,0,0,len)
496 #define EXTRWR(r,pos,len,t) f15(0x34,r,t,SED_C_NEVER,1,1,1,pos,len)
497 #define SHRWI(r,sa,t) EXTRWR(r,31-(sa),32-(sa),t)
498 #define EXTRWR_U(r,pos,len,t) f15(0x34,r,t,SED_C_NEVER,1,1,0,pos,len)
499 #define SHRWI_U(r,sa,t) EXTRWR_U(r,31-(sa),32-(sa),t)
500 #define FDC(x,s,b) f24(0x1,b,x,s,0x4a,0,0)
501 #define FDC_M(x,s,b) f24(0x1,b,x,s,0x4a,1,0)
502 #define FDCI(i,s,b) f25(0x1,b,i,s,0xca,0,0)
503 #define FDCE(x,s,b) f24(0x1,b,x,s,0x4b,0,0)
504 #define FDCE_M(x,s,b) f24(0x1,b,x,s,0x4b,1,0)
505 #define FIC(x,s,b) f26(0x1,b,x,s,0xa,0,0)
506 #define FIC_M(x,s,b) f26(0x1,b,x,s,0xa,1,0)
507 #define FICI(x,s,b) f25(0x1,b,x,s,0x4f,0,0)
508 #define FICI_M(x,s,b) f25(0x1,b,x,s,0x4f,1,0)
509 #define FICE(x,s,b) f26(0x1,b,x,s,0xb,0,0)
510 #define FICE_M(x,s,b) f26(0x1,b,x,s,0xb,1,0)
511 #define HADD_(c,r1,r2,t) f8(0x2,r2,r1,0,0,1,1,c,0,t)
512 #define HADD(r1,r2,t) HADD_(3,r1,r2,t)
513 #define HADD_SS(r1,r2,t) HADD_(1,r1,r2,t)
514 #define HADD_US(r1,r2,t) HADD_(0,r1,r2,t)
515 #define HAVG(r1,r2,t) f8(0x2,r2,r1,0,0,1,0,3,0,t)
516 #define HSHL(r,sa,t) f10(0x3e,0,r,1,0,0,2,sa,0,t)
517 #define HSHLADD(r1,sa,r2,t) f8(0x2,r2,r1,0,1,1,1,sa,0,t)
518 #define HSHR(r,sa,t) f10(0x3e,r,0,1,2,0,3,sa,0,t)
519 #define HSHR_U(r,sa,t) f10(0x3e,r,0,1,2,0,2,sa,0,t)
520 #define HSHRADD(r1,sa,r2,t) f8(0x2,r2,r1,0,1,0,1,sa,0,t)
521 #define HSUB_(c,r1,r2,t) f8(0x2,r2,r1,0,0,0,1,c,0,t)
522 #define HSUB(r1,r2,t) HSUB_(3,r1,r2,t)
523 #define HSUB_SS(r1,r2,t) HSUB_(1,r1,r2,t)
524 #define HSUB_US(r1,r2,t) HSUB_(0,r1,r2,t)
525 #define IDTLBT(r1,r2) f26(0x1,r2,r1,0,0x60,0,0)
526 #define IITLBT(r1,r2) f26(0x1,r2,r1,0,0x20,0,0)
527 #define LCI(x,s,b,t) f24(0x1,b,x,s,0x4c,0,t)
528 #define LDBL(i,b,t) f1(0x10,b,t,i)
529 #define LDB(x,b,t) f4(0x3,b,x,0,0,0,LD_CC_H_NONE,0,0,t)
530 #define LDBI(i,b,t) f5(0x3,b,i,0,0,1,LD_CC_H_NONE,0,0,t)
531 #define LDCD(x,b,t) f4(0x3,b,x,0,0,0,LD_CC_H_NONE,5,0,t)
532 #define LDCDI(i,b,t) f5(0x3,b,i,0,0,1,LD_CC_H_NONE,5,0,t)
533 #define LDCW(x,b,t) f4(0x3,b,x,0,0,0,LD_CC_H_NONE,7,0,t)
534 #define LDCWI(i,b,t) f5(0x3,b,i,0,0,1,LD_CC_H_NONE,7,0,t)
535 #define LDDL(i,b,t) f3(0x14,b,t,i,0)
536 #define LDD(x,b,t) f4(0x3,b,x,0,0,0,LD_CC_H_NONE,3,0,t)
537 #define LDDI(i,b,t) f5(0x3,b,i,0,0,1,LD_CC_H_NONE,3,0,t)
538 #define LDDA(x,b,t) f4(0x3,b,x,0,0,0,LD_CC_H_NONE,4,0,t)
539 #define LDDAI(i,b,t) f5(0x3,b,i,0,0,1,LD_CC_H_NONE,4,0,t)
540 #define LDHL(i,b,t) f1(0x11,b,t,i)
541 #define LDH(x,b,t) f4(0x3,b,x,0,0,0,LD_CC_H_NONE,1,0,t)
542 #define LDHI(i,b,t) f5(0x3,b,i,0,0,1,LD_CC_H_NONE,1,0,t)
543 #define LDIL(i,t) f7(0x8,t,i)
544 #define LDO(i,b,t) f1(0xd,b,t,i)
545 #define LDI(i,t) LDO(i,0,t)
546 #define LDSID(s,b,t) f30(0x0,b,0,s,0,0x85,t)
547 #define LDWL(i,b,t) f1(0x12,b,t,i)
548 #define LDWL_MB(i,b,t) f1(0x13,b,t,i) /* pre-dec or post-inc */
549 #define LDWL_MA(i,b,t) f2(0x17,b,t,i,2)/* post-dec or pre-inc */
550 #define LDW(x,b,t) f4(0x3,b,x,0,0,0,LD_CC_H_NONE,2,0,t)
551 #define LDWI(i,b,t) f5(0x3,b,i,0,0,1,LD_CC_H_NONE,2,0,t)
552 #define LDWA(x,b,t) f4(0x3,b,x,0,0,0,LD_CC_H_NONE,6,0,t)
553 #define LDWAI(i,b,t) f5(0x3,b,i,0,0,1,LD_CC_H_NONE,6,0,t)
554 #define LPA(x,s,b,t) f24(0x1,b,x,s,0x4d,0,t)
555 #define MFSP(s,t) f29(0x0,0,0,s,0x25,t)
556 #define MIXH_L(r1,r2,t) f10(0x3e,r2,r1,1,0,0,1,0,0,t)
557 #define MIXH_R(r1,r2,t) f10(0x3e,r2,r1,1,2,0,1,0,0,t)
558 #define MIXW_L(r1,r2,t) f10(0x3e,r2,r1,1,0,0,0,0,0,t)
559 #define MIXW_R(r1,r2,t) f10(0x3e,r2,r1,1,2,0,0,0,0,t)
560 #define MOVB_(c,r1,r2,i) f17(0x32,r2,r1,c,i,0)
561 #define MOVB(r1,r2,i) MOVB_(SED_C_NEVER,r1,r2,i)
562 #define MOVB_EQ(r1,r2,i) MOVB_(SED_C_EQ,r1,r2,i)
563 #define MOVB_LT(r1,r2,i) MOVB_(SED_C_LT,r1,r2,i)
564 #define MOVB_OD(r1,r2,i) MOVB_(SED_C_OD,r1,r2,i)
565 #define MOVB_TR(r1,r2,i) MOVB_(SED_C_TR,r1,r2,i)
566 #define MOVB_NE(r1,r2,i) MOVB_(SED_C_NE,r1,r2,i)
567 #define MOVB_GE(r1,r2,i) MOVB_(SED_C_GE,r1,r2,i)
568 #define MOVB_EV(r1,r2,i) MOVB_(SED_C_EV,r1,r2,i)
569 #define MOVIB_(c,r,i,t) f17x(0x33,r,i,c,t,0)
570 #define MOVIB(i,r,t) MOVIB_(SED_C_NEVER,i,r,t)
571 #define MOVIB_EQ(i,r,t) MOVIB_(SED_C_EQ,i,r,t)
572 #define MOVIB_LT(i,r,t) MOVIB_(SED_C_LT,i,r,t)
573 #define MOVIB_OD(i,r,t) MOVIB_(SED_C_OD,i,r,t)
574 #define MOVIB_TR(i,r,t) MOVIB_(SED_C_TR,i,r,t)
575 #define MOVIB_NE(i,r,t) MOVIB_(SED_C_NE,i,r,t)
576 #define MOVIB_GE(i,r,t) MOVIB_(SED_C_GE,i,r,t)
577 #define MOVIB_EV(i,r,t) MOVIB_(SED_C_EV,i,r,t)
578 #define MTCTL(r,t) f31(0x0,t,r,0,0xc2,0)
579 #define MTSAR(r) MTCTL(r,_CR11_REGNO)
580 #define MTSARCM(r) f31(0x0,0xb,r,0,0xc6,0)
581 #define MTSM(r) f33(0x0,0,r,0,0xc3,0)
582 #define MTSP(r,s) f29(0x0,0,r,s,0xc1,0)
583 #define OR_(c,r1,r2,t) f8(0x2,r2,r1,c,0,1,0,1,0,t)
584 #define OR(r1,r2,t) OR_(LOG_CC_NV,r1,r2,t)
585 #define NOP() OR(_R0_REGNO,_R0_REGNO,_R0_REGNO)
586 #define COPY(r,t) OR(r,0,t)
587 #define PDC(x,s,b) f24(0x1,b,x,s,0x4e,0,0)
588 #define PDTLB(x,s,b) f24(0x1,b,x,s,0x48,0,0)
589 #define PDTLB_L(x,s,b) f24(0x1,b,x,s,0x58,0,0)
590 #define PDTLBE(x,s,b) f24(0x1,b,x,s,0x49,0,0)
591 #define PERMH(c,r,t) f10(0x3e,r,r,0,(c)&3,0,((c)>>2)&3,(((c)>>2)&6)|(((c)>>6)&3),0,t)
592 #define PITBL(x,s,b) f26(0x1,b,x,s,0x08,0,0)
593 #define PITBL_L(x,s,b) f26(0x1,b,x,s,0x18,0,0)
594 #define PITBLE(x,s,b) f26(0x1,b,x,s,0x09,0,0)
595 #define POPBTS(i) f23(0x3a,0,0,2,0,i,1,0,1)
596 #define PROBE_R(s,b,r,t) f24(0x1,b,r,s,0x46,0,t)
597 #define PROBE_W(s,b,r,t) f24(0x1,b,r,s,0x47,0,t)
598 #define PROBEI_R(s,b,i,t) f24(0x1,b,i,s,0x46,0,t)
599 #define PROBEI_W(s,b,i,t) f24(0x1,b,i,s,0x47,0,t)
600 #define PUSHBTS(r) f23(0x3a,0,r,2,0,0,0,0,1)
601 #define PUSHNOM() f23(0x3a,0,0,2,0,0,0,0,1)
602 #define RFI() f33(0x0,0,0,0,0x60,0)
603 #define RFI_R() f33(0x0,0,0,0,0x65,0)
604 #define RSM(i,t) f33(0x0,((i)&0x3e0)>>5,(i)&0x1f,0,0x73,t)
605 #define SHLADD_(e,cf,r1,sa,r2,t) f8(0x2,r2,r1,cf,e,1,0,sa,0,t)
606 #define SHLADD(r1,sa,r2,t) SHLADD_(1,ADD_CF_NV,r1,sa,r2,t)
607 #define SHLADD_L(r1,sa,r2,t) SHLADD_(2,ADD_CF_NV,r1,sa,r2,t)
608 #define SHLADD_TSV(r1,sa,r2,t) SHLADD_(3,ADD_CF_NV,r1,sa,r2,t)
609 #define SHRPD(r1,r2,t) f11(0x34,r2,r1,SED_C_NEVER,0,0,1,0,t)
610 #define SHRPDI(r1,r2,sa,t) f14(0x34,r2,r1,SED_C_NEVER,0,(63-(sa))>>5,1,(63-(sa))&0x1f,t)
611 #define SHRPW(r1,r2,t) f11(0x34,r2,r1,SED_C_NEVER,0,0,0,0,t)
612 #define SHRPWI(r1,r2,sa,t) f14(0x34,r2,r1,SED_C_NEVER,0,1,0,31-(sa),t)
613 #define SPOP0(sf,so) f34(0x4,(so)>>5,0,sf,0,(so)&0x1f)
614 #define SPOP1(sf,so,t) f35(0x4,so,1,sf,0,t)
615 #define SPOP2(sf,so,r) f36(0x4,r,(so)>>5,2,sf,0,(so)&0x1f)
616 #define SPOP3(sf,so,r1,r2) f37(0x4,r2,r1,(so)>>5,3,sf,0,(so)&0x1f)
617 #define SSM(i,t) f33(0x00,(i)>>5,(i)&0x1f,0,0x6b,t)
618 #define STBL(r,i,b) f1(0x18,b,r,i)
619 #define STBI(r,i,b) f6(0x3,b,r,0,0,1,LD_CC_H_NONE,0x8,0,i)
620 #define STDL(r,i,b) f3(0x1c,b,r,i,0)
621 #define STDI(r,i,b) f6(0x3,b,r,0,0,1,LD_CC_H_NONE,0xc,0,i)
622 #define STDA(r,i,b) f6(0x3,b,r,0,0,1,LD_CC_H_NONE,0xf,0,i)
623 #define STHL(r,i,b) f1(0x19,b,r,i)
624 #define STHI(r,i,b) f6(0x3,b,r,0,0,1,LD_CC_H_NONE,0x9,0,i)
625 #define STWL(r,i,b) f1(0x1a,b,r,i)
626 #define STWL_MA(r,i,b) f1(0x1b,b,r,i) /* pre-dec or post-inc */
627 #define STWL_MB(r,i,b) f2(0x1f,b,r,i,2)/* post-dec or pre-inc */
628 #define STWI(r,i,b) f6(0x3,b,r,0,0,1,LD_CC_H_NONE,0xa,0,i)
629 #define STWA(r,i,b) f6(0x3,b,r,0,0,1,LD_CC_H_NONE,0xe,0,i)
630 #define SUB_(e1,e2,cf,r1,r2,t) f8(0x2,r2,r1,cf,e1,0,e2,0,0,t)
631 #define SUB(r1,r2,t) SUB_(1,0,CS_CC_NV,r1,r2,t)
632 #define SUB_B(r1,r2,t) SUB_(1,1,CS_CC_NV,r1,r2,t)
633 #define SUB_SV(r1,r2,t) SUB_(1,0,CS_CC_SV,r1,r2,t)
634 #define SUB_NSV(r1,r2,t) SUB_(1,0,CS_CC_NSV,r1,r2,t)
636 #define SUBI_(e1,cf,i,r,t) f9(0x25,r,t,cf,e1,i)
637 #define SUBI(i,r,t) SUBI_(0,ADD_CF_NV,i,r,t)
638 #define SYNC() f33(0x0,0,0,0,0x20,0)
639 #define SYNCDMA() f33(0x0,0,1<<4,0,0x20,0)
640 #define UADDCM(r1,r2,t) f8(0x2,r2,r1,ADD_CF_NV,2,0,1,2,0,t)
641 #define UXOR(r1,r2,t) f8(0x2,r2,r1,LOG_CC_NV,0,1,1,2,0,t)
642 #define XOR(r1,r2,t) f8(0x2,r2,r1,LOG_CC_NV,0,1,0,2,0,t)
643 # define nop(c) _nop(_jit,c)
644 static void _nop(jit_state_t*,jit_int32_t);
645 #define movr(r0,r1) _movr(_jit,r0,r1)
646 static void _movr(jit_state_t*,jit_int32_t,jit_int32_t);
647 #define movi(r0,i0) _movi(_jit,r0,i0)
648 static void _movi(jit_state_t*,jit_int32_t,jit_word_t);
649 #define movi_p(r0,i0) _movi_p(_jit,r0,i0)
650 static jit_word_t _movi_p(jit_state_t*,jit_int32_t,jit_word_t);
651 # define bswapr_us(r0, r1) _bswapr_us(_jit, r0, r1)
652 static void _bswapr_us(jit_state_t*,jit_int32_t,jit_int32_t);
653 # define bswapr_ui(r0, r1) _bswapr_ui(_jit, r0, r1)
654 static void _bswapr_ui(jit_state_t*,jit_int32_t,jit_int32_t);
655 # define movnr(r0,r1,r2) _movnr(_jit,r0,r1,r2)
656 static void _movnr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
657 # define movzr(r0,r1,r2) _movzr(_jit,r0,r1,r2)
658 static void _movzr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
659 # define casx(r0, r1, r2, r3, i0) _casx(_jit, r0, r1, r2, r3, i0)
660 static void _casx(jit_state_t *_jit,jit_int32_t,jit_int32_t,
661 jit_int32_t,jit_int32_t,jit_word_t);
662 #define casr(r0, r1, r2, r3) casx(r0, r1, r2, r3, 0)
663 #define casi(r0, i0, r1, r2) casx(r0, _NOREG, r1, r2, i0)
664 #define comr(r0,r1) UADDCM(_R0_REGNO,r1,r0)
665 #define negr(r0,r1) SUB(_R0_REGNO,r1,r0)
666 #define extr_c(r0,r1) EXTRWR(r1,31,8,r0)
667 #define extr_uc(r0,r1) EXTRWR_U(r1,31,8,r0)
668 #define extr_s(r0,r1) EXTRWR(r1,31,16,r0)
669 #define extr_us(r0,r1) EXTRWR_U(r1,31,16,r0)
670 #define addr(r0,r1,r2) ADD(r1,r2,r0)
671 #define addi(r0,r1,i0) _addi(_jit,r0,r1,i0)
672 static void _addi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
673 #define addcr(r0,r1,r2) addr(r0,r1,r2)
674 #define addci(r0,r1,i0) _addci(_jit,r0,r1,i0)
675 static void _addci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
676 #define addxr(r0,r1,r2) ADD_C(r1,r2,r0)
677 #define addxi(r0,r1,i0) _addxi(_jit,r0,r1,i0)
678 static void _addxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
679 #define subr(r0,r1,r2) SUB(r1,r2,r0)
680 #define subi(r0,r1,i0) _subi(_jit,r0,r1,i0)
681 static void _subi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
682 #define subcr(r0,r1,r2) subr(r0,r1,r2)
683 #define subci(r0,r1,i0) _subci(_jit,r0,r1,i0)
684 static void _subci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
685 #define subxr(r0,r1,r2) SUB_B(r1,r2,r0)
686 #define subxi(r0,r1,i0) _subxi(_jit,r0,r1,i0)
687 static void _subxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
688 #define rsbi(r0, r1, i0) _rsbi(_jit, r0, r1, i0)
689 static void _rsbi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
690 #define mulr(r0,r1,r2) _mulr(_jit,r0,r1,r2)
691 static void _mulr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
692 #define muli(r0,r1,i0) _muli(_jit,r0,r1,i0)
693 static void _muli(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
694 static long long __llmul(int, int);
695 #define qmulr(r0,r1,r2,r3) _qmulr(_jit,r0,r1,r2,r3)
696 static void _qmulr(jit_state_t*,
697 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
698 #define qmuli(r0,r1,r2,i0) _qmuli(_jit,r0,r1,r2,i0)
699 static void _qmuli(jit_state_t*,
700 jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
701 #define qmulr_u(r0,r1,r2,r3) _qmulr_u(_jit,r0,r1,r2,r3)
702 static void _qmulr_u(jit_state_t*,
703 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
704 #define qmuli_u(r0,r1,r2,i0) _qmuli_u(_jit,r0,r1,r2,i0)
705 static void _qmuli_u(jit_state_t*,
706 jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
707 static int __idiv(int, int);
708 #define divr(r0,r1,r2) _divr(_jit,r0,r1,r2)
709 static void _divr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
710 #define divi(r0,r1,i0) _divi(_jit,r0,r1,i0)
711 static void _divi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
712 static unsigned int __udiv(unsigned int, unsigned int);
713 #define divr_u(r0,r1,r2) _divr_u(_jit,r0,r1,r2)
714 static void _divr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
715 #define divi_u(r0,r1,i0) _divi_u(_jit,r0,r1,i0)
716 static void _divi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
717 static int __irem(int, int);
718 #define remr(r0,r1,r2) _remr(_jit,r0,r1,r2)
719 static void _remr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
720 #define remi(r0,r1,i0) _remi(_jit,r0,r1,i0)
721 static void _remi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
722 static unsigned int __urem(unsigned int, unsigned int);
723 #define remr_u(r0,r1,r2) _remr_u(_jit,r0,r1,r2)
724 static void _remr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
725 #define remi_u(r0,r1,i0) _remi_u(_jit,r0,r1,i0)
726 static void _remi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
727 static idiv_t __idivrem(int, int);
728 #define qdivr(r0,r1,r2,r3) _qdivr(_jit,r0,r1,r2,r3)
729 static void _qdivr(jit_state_t*,
730 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
731 #define qdivi(r0,r1,r2,i0) _qdivi(_jit,r0,r1,r2,i0)
732 static void _qdivi(jit_state_t*,
733 jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
734 static udiv_t __udivrem(unsigned int, unsigned int);
735 #define qdivr_u(r0,r1,r2,r3) _qdivr_u(_jit,r0,r1,r2,r3)
736 static void _qdivr_u(jit_state_t*,
737 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
738 #define qdivi_u(r0,r1,r2,i0) _qdivi_u(_jit,r0,r1,r2,i0)
739 static void _qdivi_u(jit_state_t*,
740 jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
741 #define andr(r0,r1,r2) AND(r1,r2,r0)
742 #define andi(r0,r1,i0) _andi(_jit,r0,r1,i0)
743 static void _andi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
744 #define orr(r0,r1,r2) OR(r1,r2,r0)
745 #define ori(r0,r1,i0) _ori(_jit,r0,r1,i0)
746 static void _ori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
747 #define xorr(r0,r1,r2) XOR(r1,r2,r0)
748 #define xori(r0,r1,i0) _xori(_jit,r0,r1,i0)
749 static void _xori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
750 #define lshr(r0,r1,r2) _lshr(_jit,r0,r1,r2)
751 static void _lshr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
752 #define lshi(r0,r1,i0) SHLWI(r1,i0,r0)
753 #define rshr(r0,r1,r2) _rshr(_jit,r0,r1,r2)
754 static void _rshr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
755 #define rshi(r0,r1,i0) SHRWI(r1,i0,r0)
756 #define rshr_u(r0,r1,r2) _rshr_u(_jit,r0,r1,r2)
757 static void _rshr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
758 #define rshi_u(r0,r1,i0) SHRWI_U(r1,i0,r0)
759 #define cmpr(c,r0,r1,r2) _cmpr(_jit,c,r0,r1,r2)
760 static void _cmpr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t,jit_int32_t);
761 #define cmpi(c,ci,r0,r1,i0) _cmpi(_jit,c,ci,r0,r1,i0)
762 static void _cmpi(jit_state_t*,jit_word_t,jit_word_t,
763 jit_int32_t,jit_int32_t,jit_word_t);
764 #define ltr(r0,r1,r2) cmpr(CS_CC_GE,r0,r1,r2)
765 #define lti(r0,r1,i0) cmpi(CS_CC_GE,CS_CC_LE,r0,r1,i0)
766 #define ltr_u(r0,r1,r2) cmpr(CS_CC_UGE,r0,r1,r2)
767 #define lti_u(r0,r1,i0) cmpi(CS_CC_UGE,CS_CC_ULE,r0,r1,i0)
768 #define ler(r0,r1,r2) cmpr(CS_CC_GT,r0,r1,r2)
769 #define lei(r0,r1,i0) cmpi(CS_CC_GT,CS_CC_LT,r0,r1,i0)
770 #define ler_u(r0,r1,r2) cmpr(CS_CC_UGT,r0,r1,r2)
771 #define lei_u(r0,r1,i0) cmpi(CS_CC_UGT,CS_CC_ULT,r0,r1,i0)
772 #define eqr(r0,r1,r2) cmpr(CS_CC_NE,r0,r1,r2)
773 #define eqi(r0,r1,i0) cmpi(CS_CC_NE,CS_CC_NE,r0,r1,i0)
774 #define ger(r0,r1,r2) cmpr(CS_CC_LT,r0,r1,r2)
775 #define gei(r0,r1,i0) cmpi(CS_CC_LT,CS_CC_GT,r0,r1,i0)
776 #define ger_u(r0,r1,r2) cmpr(CS_CC_ULT,r0,r1,r2)
777 #define gei_u(r0,r1,i0) cmpi(CS_CC_ULT,CS_CC_UGT,r0,r1,i0)
778 #define gtr(r0,r1,r2) cmpr(CS_CC_LE,r0,r1,r2)
779 #define gti(r0,r1,i0) cmpi(CS_CC_LE,CS_CC_GE,r0,r1,i0)
780 #define gtr_u(r0,r1,r2) cmpr(CS_CC_ULE,r0,r1,r2)
781 #define gti_u(r0,r1,i0) cmpi(CS_CC_ULE,CS_CC_UGE,r0,r1,i0)
782 #define ner(r0,r1,r2) cmpr(CS_CC_EQ,r0,r1,r2)
783 #define nei(r0,r1,i0) cmpi(CS_CC_EQ,CS_CC_EQ,r0,r1,i0)
784 #define ldr_c(r0,r1) _ldr_c(_jit,r0,r1)
785 static void _ldr_c(jit_state_t*,jit_int32_t,jit_int32_t);
786 #define ldi_c(r0,i0) _ldi_c(_jit,r0,i0)
787 static void _ldi_c(jit_state_t*,jit_int32_t,jit_word_t);
788 #define ldxr_c(r0,r1,r2) _ldxr_c(_jit,r0,r1,r2)
789 static void _ldxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
790 #define ldxi_c(r0,r1,i0) _ldxi_c(_jit,r0,r1,i0)
791 static void _ldxi_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
792 #define ldr_uc(r0,r1) LDBI(_R0_REGNO,r1,r0)
793 #define ldi_uc(r0,i0) _ldi_uc(_jit,r0,i0)
794 static void _ldi_uc(jit_state_t*,jit_int32_t,jit_word_t);
795 #define ldxr_uc(r0,r1,r2) LDB(r2,r1,r0)
796 #define ldxi_uc(r0,r1,i0) _ldxi_uc(_jit,r0,r1,i0)
797 static void _ldxi_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
798 #define ldr_s(r0,r1) _ldr_s(_jit,r0,r1)
799 static void _ldr_s(jit_state_t*,jit_int32_t,jit_int32_t);
800 #define ldi_s(r0,i0) _ldi_s(_jit,r0,i0)
801 static void _ldi_s(jit_state_t*,jit_int32_t,jit_word_t);
802 #define ldxr_s(r0,r1,r2) _ldxr_s(_jit,r0,r1,r2)
803 static void _ldxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
804 #define ldxi_s(r0,r1,i0) _ldxi_s(_jit,r0,r1,i0)
805 static void _ldxi_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
806 #define ldr_us(r0,r1) LDHI(_R0_REGNO,r1,r0)
807 #define ldi_us(r0,i0) _ldi_us(_jit,r0,i0)
808 static void _ldi_us(jit_state_t*,jit_int32_t,jit_word_t);
809 #define ldxr_us(r0,r1,r2) LDH(r2,r1,r0)
810 #define ldxi_us(r0,r1,i0) _ldxi_us(_jit,r0,r1,i0)
811 static void _ldxi_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
812 #define ldr(r0,r1) ldr_ui(r0,r1)
813 #define ldr_i(r0,r1) ldr_ui(r0,r1)
814 #define ldr_ui(r0,r1) LDWI(_R0_REGNO,r1,r0)
815 #define ldi_i(r0,i0) ldi_ui(r0,i0)
816 #define ldi_ui(r0,i0) _ldi_ui(_jit,r0,i0)
817 static void _ldi_ui(jit_state_t*,jit_int32_t,jit_word_t);
818 #define ldxr_i(r0,r1,r2) ldxr_ui(r0,r1,r2)
819 #define ldxr_ui(r0,r1,r2) LDW(r2,r1,r0)
820 #define ldxi(r0,r1,i0) ldxi_ui(r0,r1,i0)
821 #define ldxi_i(r0,r1,i0) ldxi_ui(r0,r1,i0)
822 #define ldxi_ui(r0,r1,i0) _ldxi_ui(_jit,r0,r1,i0)
823 static void _ldxi_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
824 #define str_c(r0,r1) STBI(r1,_R0_REGNO,r0)
825 #define sti_c(i0,r0) _sti_c(_jit,i0,r0)
826 static void _sti_c(jit_state_t*,jit_word_t,jit_int32_t);
827 #define stxr_c(r0,r1,r2) _stxr_c(_jit,r0,r1,r2)
828 static void _stxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
829 #define stxi_c(i0,r0,r1) _stxi_c(_jit,i0,r0,r1)
830 static void _stxi_c(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
831 #define str_s(r0,r1) STHI(r1,_R0_REGNO,r0)
832 #define sti_s(i0,r0) _sti_s(_jit,i0,r0)
833 static void _sti_s(jit_state_t*,jit_word_t,jit_int32_t);
834 #define stxr_s(r0,r1,r2) _stxr_s(_jit,r0,r1,r2)
835 static void _stxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
836 #define stxi_s(i0,r0,r1) _stxi_s(_jit,i0,r0,r1)
837 static void _stxi_s(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
838 #define str_i(r0,r1) STWI(r1,_R0_REGNO,r0)
839 #define sti_i(i0,r0) _sti_i(_jit,i0,r0)
840 static void _sti_i(jit_state_t*,jit_word_t,jit_int32_t);
841 #define stxr_i(r0,r1,r2) _stxr_i(_jit,r0,r1,r2)
842 static void _stxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
843 #define stxi(i0,r0,r1) stxi_i(i0,r0,r1)
844 #define stxi_i(i0,r0,r1) _stxi_i(_jit,i0,r0,r1)
845 static void _stxi_i(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
846 #define bcmpr(c,i0,r0,r1) _bcmpr(_jit,c,i0,r0,r1)
847 static jit_word_t _bcmpr(jit_state_t*,jit_word_t,
848 jit_word_t,jit_int32_t,jit_int32_t);
849 #define bcmpi(c,ci,i0,r0,i1) _bcmpi(_jit,c,ci,i0,r0,i1)
850 static jit_word_t _bcmpi(jit_state_t*,jit_word_t,jit_word_t,
851 jit_word_t,jit_int32_t,jit_word_t);
852 #define bltr(i0,r0,r1) bcmpr(CS_CC_LT,i0,r0,r1)
853 #define blti(i0,r0,r1) bcmpi(CS_CC_LT,CS_CC_GT,i0,r0,r1)
854 #define bltr_u(i0,r0,r1) bcmpr(CS_CC_ULT,i0,r0,r1)
855 #define blti_u(i0,r0,r1) bcmpi(CS_CC_ULT,CS_CC_UGT,i0,r0,r1)
856 #define bler(i0,r0,r1) bcmpr(CS_CC_LE,i0,r0,r1)
857 #define blei(i0,r0,r1) bcmpi(CS_CC_LE,CS_CC_GE,i0,r0,r1)
858 #define bler_u(i0,r0,r1) bcmpr(CS_CC_ULE,i0,r0,r1)
859 #define blei_u(i0,r0,r1) bcmpi(CS_CC_ULE,CS_CC_UGE,i0,r0,r1)
860 #define beqr(i0,r0,r1) bcmpr(CS_CC_EQ,i0,r0,r1)
861 #define beqi(i0,r0,r1) bcmpi(CS_CC_EQ,CS_CC_EQ,i0,r0,r1)
862 #define bger(i0,r0,r1) bcmpr(CS_CC_GE,i0,r0,r1)
863 #define bgei(i0,r0,r1) bcmpi(CS_CC_GE,CS_CC_LE,i0,r0,r1)
864 #define bger_u(i0,r0,r1) bcmpr(CS_CC_UGE,i0,r0,r1)
865 #define bgei_u(i0,r0,r1) bcmpi(CS_CC_UGE,CS_CC_ULE,i0,r0,r1)
866 #define bgtr(i0,r0,r1) bcmpr(CS_CC_GT,i0,r0,r1)
867 #define bgti(i0,r0,r1) bcmpi(CS_CC_GT,CS_CC_LT,i0,r0,r1)
868 #define bgtr_u(i0,r0,r1) bcmpr(CS_CC_UGT,i0,r0,r1)
869 #define bgti_u(i0,r0,r1) bcmpi(CS_CC_UGT,CS_CC_ULT,i0,r0,r1)
870 #define bner(i0,r0,r1) bcmpr(CS_CC_NE,i0,r0,r1)
871 #define bnei(i0,r0,r1) bcmpi(CS_CC_NE,CS_CC_NE,i0,r0,r1)
872 #define bmxr(c,i0,r0,r1) _bmxr(_jit,c,i0,r0,r1)
873 static jit_word_t _bmxr(jit_state_t*,jit_bool_t,
874 jit_word_t,jit_int32_t,jit_int32_t);
875 #define bmxi(c,i0,r0,i1) _bmxi(_jit,c,i0,r0,i1)
876 static jit_word_t _bmxi(jit_state_t*,jit_bool_t,
877 jit_word_t,jit_int32_t,jit_word_t);
878 #define bmcr(r0,r1,r2) bmxr(0,r0,r1,r2)
879 #define bmci(r0,r1,r2) bmxi(0,r0,r1,r2)
880 #define bmsr(r0,r1,r2) bmxr(1,r0,r1,r2)
881 #define bmsi(r0,r1,r2) bmxi(1,r0,r1,r2)
882 #define boaddr(i0,r0,r1) _boaddr(_jit,i0,r0,r1)
883 static jit_word_t _boaddr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
884 #define boaddi(i0,r0,i1) _boaddi(_jit,i0,r0,i1)
885 static jit_word_t _boaddi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
886 #define boaddr_u(i0,r0,r1) _boaddr_u(_jit,i0,r0,r1)
887 static jit_word_t _boaddr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
888 #define boaddi_u(i0,r0,i1) _boaddi_u(_jit,i0,r0,i1)
889 static jit_word_t _boaddi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
890 #define bxaddr(i0,r0,r1) _bxaddr(_jit,i0,r0,r1)
891 static jit_word_t _bxaddr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
892 #define bxaddi(i0,r0,i1) _bxaddi(_jit,i0,r0,i1)
893 static jit_word_t _bxaddi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
894 #define bxaddr_u(i0,r0,r1) _bxaddr_u(_jit,i0,r0,r1)
895 static jit_word_t _bxaddr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
896 #define bxaddi_u(i0,r0,i1) _bxaddi_u(_jit,i0,r0,i1)
897 static jit_word_t _bxaddi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
898 #define bosubr(i0,r0,r1) _bosubr(_jit,i0,r0,r1)
899 static jit_word_t _bosubr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
900 #define bosubi(i0,r0,i1) _bosubi(_jit,i0,r0,i1)
901 static jit_word_t _bosubi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
902 #define bosubr_u(i0,r0,r1) _bosubr_u(_jit,i0,r0,r1)
903 static jit_word_t _bosubr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
904 #define bosubi_u(i0,r0,i1) _bosubi_u(_jit,i0,r0,i1)
905 static jit_word_t _bosubi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
906 #define bxsubr(i0,r0,r1) _bxsubr(_jit,i0,r0,r1)
907 static jit_word_t _bxsubr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
908 #define bxsubi(i0,r0,i1) _bxsubi(_jit,i0,r0,i1)
909 static jit_word_t _bxsubi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
910 #define bxsubr_u(i0,r0,r1) _bxsubr_u(_jit,i0,r0,r1)
911 static jit_word_t _bxsubr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
912 #define bxsubi_u(i0,r0,i1) _bxsubi_u(_jit,i0,r0,i1)
913 static jit_word_t _bxsubi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
914 #define jmpr(r0) _jmpr(_jit,r0)
915 static void _jmpr(jit_state_t*,jit_int32_t);
916 #define jmpi(i0) _jmpi(_jit,i0)
917 static jit_word_t _jmpi(jit_state_t*,jit_word_t);
918 #define jmpi_p(i0) _jmpi_p(_jit,i0)
919 static jit_word_t _jmpi_p(jit_state_t*,jit_word_t);
920 #define callr(r0) _callr(_jit,r0)
921 static void _callr(jit_state_t*,jit_int32_t);
922 #define calli(i0) _calli(_jit,i0)
923 static void _calli(jit_state_t*,jit_word_t);
924 #define calli_p(i0) _calli_p(_jit,i0)
925 static jit_word_t _calli_p(jit_state_t*,jit_word_t);
926 #define prolog(node) _prolog(_jit, node)
927 static void _prolog(jit_state_t*, jit_node_t*);
928 #define epilog(node) _epilog(_jit, node)
929 static void _epilog(jit_state_t*, jit_node_t*);
930 #define vastart(r0) _vastart(_jit, r0)
931 static void _vastart(jit_state_t*, jit_int32_t);
932 #define vaarg(r0, r1) _vaarg(_jit, r0, r1)
933 static void _vaarg(jit_state_t*, jit_int32_t, jit_int32_t);
934 #define patch_at(i,l) _patch_at(_jit,i,l)
935 static void _patch_at(jit_state_t*,jit_word_t,jit_word_t);
939 /* from binutils bfd/libhppa.h */
941 sign_extend (int x, int len)
943 int signbit = (1 << (len - 1));
944 int mask = (signbit << 1) - 1;
945 return ((x & mask) ^ signbit) - signbit;
949 sign_unext (int x, int len)
953 len_ones = (1 << len) - 1;
959 low_sign_unext (int x, int len)
964 sign = (x >> (len-1)) & 1;
966 temp = sign_unext (x, len-1);
968 return (temp << 1) | sign;
972 re_assemble_3 (int as3)
974 return (( (as3 & 4) << (13-2))
975 | ((as3 & 3) << (13+1)));
979 re_assemble_12 (int as12)
981 return (( (as12 & 0x800) >> 11)
982 | ((as12 & 0x400) >> (10 - 2))
983 | ((as12 & 0x3ff) << (1 + 2)));
987 re_assemble_16 (int as16)
991 /* Unusual 16-bit encoding, for wide mode only. */
992 t = (as16 << 1) & 0xffff;
994 return (t ^ s ^ (s >> 1)) | (s >> 15);
998 re_assemble_17 (int as17)
1000 return (( (as17 & 0x10000) >> 16)
1001 | ((as17 & 0x0f800) << (16 - 11))
1002 | ((as17 & 0x00400) >> (10 - 2))
1003 | ((as17 & 0x003ff) << (1 + 2)));
1007 re_assemble_21 (int as21)
1009 return (( (as21 & 0x100000) >> 20)
1010 | ((as21 & 0x0ffe00) >> 8)
1011 | ((as21 & 0x000180) << 7)
1012 | ((as21 & 0x00007c) << 14)
1013 | ((as21 & 0x000003) << 12));
1017 re_assemble_22 (int as22)
1019 return (( (as22 & 0x200000) >> 21)
1020 | ((as22 & 0x1f0000) << (21 - 16))
1021 | ((as22 & 0x00f800) << (16 - 11))
1022 | ((as22 & 0x000400) >> (10 - 2))
1023 | ((as22 & 0x0003ff) << (1 + 2)));
1027 _f1(jit_state_t *_jit, jit_int32_t o,
1028 jit_int32_t b, jit_int32_t t, jit_int32_t i)
1030 assert(!(o & ~0x3f));
1031 assert(!(b & ~0x1f));
1032 assert(!(t & ~0x1f));
1033 assert(i >= -8192 && i <= 8191);
1034 ii((o<<26)|(b<<21)|(t<<16)|(re_assemble_16(i)));
1038 _f2(jit_state_t *_jit, jit_int32_t o,
1039 jit_int32_t b, jit_int32_t t, jit_int32_t i, jit_int32_t j)
1041 assert(!(o & ~0x3f));
1042 assert(!(b & ~0x1f));
1043 assert(!(t & ~0x1f));
1044 assert(i >= -32768 && i <= 32767);
1045 assert(!(j & ~0x3));
1046 ii((o<<26)|(b<<21)|(t<<16)|(j<<1)|(re_assemble_16(i)));
1050 _f3(jit_state_t *_jit, jit_int32_t o,
1051 jit_int32_t b, jit_int32_t t, jit_int32_t i, jit_int32_t j)
1053 assert(!(o & ~0x3f));
1054 assert(!(b & ~0x1f));
1055 assert(!(t & ~0x1f));
1056 assert(i >= -32768 && i <= 32767);
1057 assert(!(j & ~0x1));
1058 ii((o<<26)|(b<<21)|(t<<16)|(j<<1)|(re_assemble_16(i)));
1062 _f4(jit_state_t *_jit, jit_int32_t o, jit_int32_t b,
1063 jit_int32_t x, jit_int32_t s, jit_int32_t u, jit_int32_t y,
1064 jit_int32_t c, jit_int32_t z, jit_int32_t m, jit_int32_t t)
1066 assert(!(o & ~0x3f));
1067 assert(!(b & ~0x1f));
1068 assert(!(x & ~0x1f));
1069 assert(!(s & ~0x3));
1070 assert(!(u & ~0x1));
1071 assert(!(y & ~0x1));
1072 assert(!(c & ~0x3));
1073 assert(!(z & ~0xf));
1074 assert(!(m & ~0x1));
1075 assert(!(t & ~0x1f));
1076 ii((o<<26)|(b<<21)|(x<<16)|(s<<14)|(u<<13)|(y<<12)|(c<<10)|(z<<6)|(m<<5)|t);
1080 _f5(jit_state_t *_jit, jit_int32_t o, jit_int32_t b,
1081 jit_int32_t i, jit_int32_t s, jit_int32_t a, jit_int32_t y,
1082 jit_int32_t c, jit_int32_t z, jit_int32_t m, jit_int32_t t)
1084 assert(!(o & ~0x3f));
1085 assert(!(b & ~0x1f));
1086 assert(!(s & ~0x3));
1087 assert(!(a & ~0x1));
1088 assert(!(y & ~0x1));
1089 assert(!(c & ~0x3));
1090 assert(!(z & ~0xf));
1091 assert(!(m & ~0x1));
1092 assert(i >= -16 && i <= 15);
1093 ii((o<<26)|(b<<21)|(low_sign_unext(i,5)<<16)|
1094 (s<<14)|(a<<13)|(y<<12)|(c<<10)|(z<<6)|(m<<5)|t);
1098 _f6(jit_state_t *_jit, jit_int32_t o, jit_int32_t b,
1099 jit_int32_t r, jit_int32_t s, jit_int32_t a, jit_int32_t x,
1100 jit_int32_t c, jit_int32_t y, jit_int32_t m, jit_int32_t i)
1102 assert(!(o & ~0x3f));
1103 assert(!(b & ~0x1f));
1104 assert(!(s & ~0x3));
1105 assert(!(a & ~0x1));
1106 assert(!(x & ~0x1));
1107 assert(!(c & ~0x3));
1108 assert(!(y & ~0xf));
1109 assert(!(m & ~0x1));
1110 assert(i >= -16 && i <= 15);
1111 ii((o<<26)|(b<<21)|(r<<16)|(s<<14)|(a<<13)|
1112 (x<<12)|(c<<10)|(y<<6)|(m<<5)|low_sign_unext(i,5));
1116 _f7(jit_state_t *_jit, jit_int32_t o, jit_int32_t r, jit_int32_t i)
1118 assert(!(o & ~0x3f));
1119 assert(!(r & ~0x1f));
1120 assert(!(i & 0x7ff));
1121 ii((o<<26)|(r<<21)|re_assemble_21(i>>11));
1125 _f8(jit_state_t *_jit, jit_int32_t o,
1126 jit_int32_t r2, jit_int32_t r1, jit_int32_t cf,
1127 jit_int32_t e1, jit_int32_t x, jit_int32_t e2,
1128 jit_int32_t e3, jit_int32_t d, jit_int32_t t)
1130 assert(!(o & ~0x3f));
1131 assert(!(r2 & ~0x1f));
1132 assert(!(r1 & ~0x1f));
1133 assert(!(cf & ~0xf));
1134 assert(!(e1 & ~0x3));
1135 assert(!(x & ~0x1));
1136 assert(!(e2 & ~0x3));
1137 assert(!(e3 & ~0x3));
1138 assert(!(d & ~0x1));
1139 assert(!(t & ~0x1f));
1140 ii((o<<26)|(r2<<21)|(r1<<16)|(cf<<12)|
1141 (e1<<10)|(x<<9)|(e2<<8)|(e3<<6)|(d<<5)|t);
1145 _f9(jit_state_t *_jit,
1146 jit_int32_t o, jit_int32_t r, jit_int32_t t,
1147 jit_int32_t cf, jit_int32_t e1, jit_int32_t i)
1149 assert(!(o & ~0x3f));
1150 assert(!(r & ~0x1f));
1151 assert(!(t & ~0x1f));
1152 assert(!(cf & ~0xf));
1153 assert(!(e1 & ~0x1));
1154 assert(i >= -2048 && i <= 2047);
1155 ii((o<<26)|(r<<21)|(t<<16)|(cf<<12)|(e1<<11)|low_sign_unext(i,11));
1159 _f10(jit_state_t *_jit, jit_int32_t o, jit_int32_t r2,
1160 jit_int32_t r1, jit_int32_t u, jit_int32_t v, jit_int32_t w,
1161 jit_int32_t x, jit_int32_t sa, jit_int32_t y, jit_int32_t t)
1163 assert(!(o & ~0x3f));
1164 assert(!(r2 & ~0x1f));
1165 assert(!(r1 & ~0x1f));
1166 assert(!(u & ~0x1));
1167 assert(!(v & ~0x3));
1168 assert(!(w & ~0x1));
1169 assert(!(x & ~0x3));
1170 assert(!(sa & ~0xf));
1171 assert(!(y & ~0x1));
1172 assert(!(t & ~0x1f));
1173 ii((o<<26)|(r2<<21)|(r1<<16)|(u<<15)|
1174 (v<<13)|(w<<12)|(x<<10)|(sa<<6)|(y<<5)|t);
1178 _f11(jit_state_t *_jit, jit_int32_t o,
1179 jit_int32_t r2, jit_int32_t r1, jit_int32_t c, jit_int32_t x,
1180 jit_int32_t y, jit_int32_t z, jit_int32_t u, jit_int32_t t)
1182 assert(!(o & ~0x3f));
1183 assert(!(r1 & ~0x1f));
1184 assert(!(r2 & ~0x1f));
1185 assert(!(c & ~0x7));
1186 assert(!(x & ~0x3));
1187 assert(!(y & ~0x1));
1188 assert(!(z & ~0x1));
1189 assert(!(u & ~0xf));
1190 assert(!(t & ~0x1f));
1191 ii((o<<26)|(r2<<21)|(r1<<16)|(c<<13)|(x<<11)|(y<<10)|(z<<9)|(u<<5)|t);
1195 _f12(jit_state_t *_jit, jit_int32_t o, jit_int32_t r,
1196 jit_int32_t t, jit_int32_t c, jit_int32_t x, jit_int32_t se,
1197 jit_int32_t y, jit_int32_t c1, jit_int32_t z, jit_int32_t clen)
1199 assert(!(o & ~0x3f));
1200 assert(!(r & ~0x1f));
1201 assert(!(t & ~0x1f));
1202 assert(!(c & ~0x7));
1203 assert(!(x & ~0x3));
1204 assert(!(se & ~0x1));
1205 assert(!(y & ~0x1));
1206 assert(!(c1 & ~0x1));
1207 assert(!(z & ~0x7));
1208 assert(!((32-clen) & ~0x1f));
1209 ii((o<<26)|(r<<21)|(t<<16)|(c<<13)|(x<<11)|
1210 (se<<10)|(y<<9)|(c1<<8)|(z<<5)|(32-clen));
1214 _f13(jit_state_t *_jit, jit_int32_t o, jit_int32_t t,
1215 jit_int32_t r, jit_int32_t c, jit_int32_t x,
1216 jit_int32_t nz, jit_int32_t c1, jit_int32_t clen)
1218 assert(!(o & ~0x3f));
1219 assert(!(t & ~0x1f));
1220 assert(!(r & ~0x1f));
1221 assert(!(c & ~0x7));
1222 assert(!(x & ~0x3));
1223 assert(!(nz & ~0x1));
1224 assert(!(c1 & ~0x1));
1225 assert(!((32-clen) & ~0x1f));
1226 ii((o<<26)|(t<<21)|(r<<16)|(c<<13)|
1227 (x<<11)|(nz<<10)|(c1<<8)|(32-clen));
1231 _f13x(jit_state_t *_jit, jit_int32_t o, jit_int32_t t,
1232 jit_int32_t i, jit_int32_t c, jit_int32_t x,
1233 jit_int32_t nz, jit_int32_t c1, jit_int32_t clen)
1235 assert(!(o & ~0x3f));
1236 assert(!(t & ~0x1f));
1237 assert(i >= -16 && i <= 15);
1238 assert(!(c & ~0x7));
1239 assert(!(x & ~0x3));
1240 assert(!(nz & ~0x1));
1241 assert(!((32-clen) & ~0x1f));
1242 ii((o<<26)|(t<<21)|(low_sign_unext(i,5)<<16)|
1243 (c<<13)|(x<<11)|(nz<<10)|(c1<<8)|(32-clen));
1247 _f14(jit_state_t *_jit, jit_int32_t o,
1248 jit_int32_t r2, jit_int32_t r1, jit_int32_t c, jit_int32_t x,
1249 jit_int32_t cp, jit_int32_t y, jit_int32_t cpos, jit_int32_t t)
1251 assert(!(o & ~0x3f));
1252 assert(!(r1 & ~0x1f));
1253 assert(!(r2 & ~0x1f));
1254 assert(!(c & ~0x7));
1255 assert(!(x & ~0x3));
1256 assert(!(cp & ~0x1));
1257 assert(!(y & ~0x1));
1258 assert(!(cpos & ~0x1f));
1259 assert(!(t & ~0x1f));
1260 ii((o<<26)|(r2<<21)|(r1<<16)|(c<<13)|(x<<12)|(cp<<11)|(y<<10)|(cpos<<5)|t);
1264 _f15(jit_state_t *_jit, jit_int32_t o,
1265 jit_int32_t r, jit_int32_t t, jit_int32_t c, jit_int32_t c1,
1266 jit_int32_t p, jit_int32_t se, jit_int32_t pos, jit_int32_t clen)
1268 assert(!(o & ~0x3f));
1269 assert(!(r & ~0x1f));
1270 assert(!(t & ~0x1f));
1271 assert(!(c & ~0x7));
1272 assert(!(c1 & ~0x1));
1273 assert(!(p & ~0x1));
1274 assert(!(se & ~0x1));
1275 assert(!(pos & ~0x1f));
1276 assert(!((32-clen) & ~0x1f));
1277 ii((o<<26)|(r<<21)|(t<<16)|(c<<13)|(c1<<12)|
1278 (p<<11)|(se<<10)|(pos<<5)|(32-clen));
1282 _f16(jit_state_t *_jit, jit_int32_t o,
1283 jit_int32_t t, jit_int32_t r, jit_int32_t c, jit_int32_t c1,
1284 jit_int32_t cp, jit_int32_t nz, jit_int32_t cpos, jit_int32_t clen)
1286 assert(!(o & ~0x3f));
1287 assert(!(t & ~0x1f));
1288 assert(!(r & ~0x1f));
1289 assert(!(c & ~0x7));
1290 assert(!(c1 & ~0x1));
1291 assert(!(cp & ~0x1));
1292 assert(!(nz & ~0x1));
1293 assert(!(cpos & ~0x1f));
1294 assert(!((32-clen) & ~0x3f));
1295 ii((o<<26)|(t<<21)|(r<<16)|(c<<13)|
1296 (c1<<12)|(cp<<11)|(nz<<10)|(cpos<<5)|(32-clen));
1300 _f16x(jit_state_t *_jit, jit_int32_t o,
1301 jit_int32_t t, jit_int32_t i, jit_int32_t c, jit_int32_t c1,
1302 jit_int32_t cp, jit_int32_t nz, jit_int32_t cpos, jit_int32_t clen)
1304 assert(!(o & ~0x3f));
1305 assert(!(t & ~0x1f));
1306 assert(i >= -16 && i <= 15);
1307 assert(!(c & ~0x7));
1308 assert(!(c1 & ~0x1));
1309 assert(!(cp & ~0x1));
1310 assert(!(nz & ~0x1));
1311 assert(!(cpos & ~0x1f));
1312 assert(!((32-clen) & ~0x3f));
1313 ii((o<<26)|(t<<21)|(low_sign_unext(i,5)<<16)|(c<<13)|
1314 (c1<<12)|(cp<<11)|(nz<<10)|(cpos<<5)|(32-clen));
1318 _f17(jit_state_t *_jit, jit_int32_t o, jit_int32_t r2,
1319 jit_int32_t r1, jit_int32_t c, jit_int32_t i, jit_int32_t n)
1321 assert(!(o & ~0x3f));
1322 assert(!(r2 & ~0x1f));
1323 assert(!(r1 & ~0x1f));
1324 assert(!(c & ~0x7));
1325 assert(i >= -2048 && i <= 2047);
1326 assert(!(n & ~0x1));
1327 ii((o<<26)|(r2<<21)|(r1<<16)|(c<<13)|re_assemble_12(i)|(n<<1));
1331 _f17x(jit_state_t *_jit, jit_int32_t o, jit_int32_t r,
1332 jit_int32_t i, jit_int32_t c, jit_int32_t t, jit_int32_t n)
1334 assert(!(o & ~0x3f));
1335 assert(!(r & ~0x1f));
1336 assert(i >= -16 && i <= 15);
1337 assert(!(c & ~0x7));
1338 assert(t >= -2048 && t <= 2047);
1339 assert(!(n & ~0x1));
1341 (low_sign_unext(i,5)<<16)|(c<<13)|re_assemble_12(t)|(n<<1));
1345 _f18(jit_state_t *_jit, jit_int32_t o, jit_int32_t p,
1346 jit_int32_t r, jit_int32_t c, jit_int32_t i, jit_int32_t n)
1348 assert(!(o & ~0x3f));
1349 assert(!(p & ~0x1f));
1350 assert(!(r & ~0x1f));
1351 assert(!(c & ~0x1));
1352 assert(i >= -2048 && i <= 2047);
1353 assert(!(n & ~0x1));
1354 ii((o<<26)|(p<<21)|(r<<16)|(c<<15)|(1<<14)|re_assemble_12(i)|(n<<1));
1358 _f19(jit_state_t *_jit, jit_int32_t o, jit_int32_t b,
1359 jit_int32_t s, jit_int32_t i, jit_int32_t n)
1361 assert(!(o & ~0x3f));
1362 assert(!(b & ~0x1f));
1363 assert(!(s & ~0x7));
1364 assert(i >= -65536 && i <= 65535);
1365 assert(!(n & ~0x1));
1366 ii((o<<26)|(b<<21)|re_assemble_3(s)|re_assemble_17(i)|(n<<1));
1370 _f20(jit_state_t *_jit, jit_int32_t o, jit_int32_t t,
1371 jit_int32_t i, jit_int32_t g, jit_int32_t n)
1373 assert(!(o & ~0x3f));
1374 assert(!(t & ~0x1f));
1375 assert(i >= -32768 && i <= 32767);
1376 assert(!(g & ~0x7));
1377 assert(!(n & ~0x1));
1378 ii((o<<26)|(t<<21)|(g<<13)|re_assemble_17(i)|(n<<1));
1382 _f21(jit_state_t *_jit, jit_int32_t o, jit_int32_t t,
1383 jit_int32_t x, jit_int32_t y, jit_int32_t n)
1385 assert(!(o & ~0x3f));
1386 assert(!(t & ~0x1f));
1387 assert(!(x & ~0x1f));
1388 assert(!(y & ~0x7));
1389 assert(!(n & ~0x1));
1390 ii((o<<26)|(t<<21)|(x<<16)|(y<<13)|(n<<1));
1394 _f22(jit_state_t *_jit, jit_int32_t o, jit_int32_t b,
1395 jit_int32_t x, jit_int32_t r, jit_int32_t n, jit_int32_t p)
1397 assert(!(o & ~0x3f));
1398 assert(!(b & ~0x1f));
1399 assert(!(x & ~0x7));
1400 assert(!(r & ~0x3f));
1401 assert(!(n & ~0x1));
1402 assert(!(p & ~0x1));
1403 ii((o<<26)|(b<<21)|(x<<13)|(1<<12)|(r<<2)|(n<<1)|p);
1407 _f23(jit_state_t *_jit, jit_int32_t o,
1408 jit_int32_t a, jit_int32_t b, jit_int32_t c, jit_int32_t d,
1409 jit_int32_t e, jit_int32_t f, jit_int32_t g, jit_int32_t h)
1411 assert(!(o & ~0x3f));
1412 assert(!(a & ~0x1f));
1413 assert(!(b & ~0x1f));
1414 assert(!(c & ~0x7));
1415 assert(!(d & ~0x1));
1416 assert(!(e & ~0x1ff));
1417 assert(!(f & ~0x1));
1418 assert(!(g & ~0x1));
1419 assert(!(h & ~0x1));
1420 ii((o<<26)|(a<<21)|(b<<16)|(c<<13)|(d<<12)|(e<<3)|(f<<2)|(g<<1)|h);
1424 _f24(jit_state_t *_jit, jit_int32_t o,
1425 jit_int32_t b, jit_int32_t x, jit_int32_t s,
1426 jit_int32_t y, jit_int32_t m,jit_int32_t r)
1428 assert(!(o & ~0x3f));
1429 assert(!(b & ~0x1f));
1430 assert(!(x & ~0x1f));
1431 assert(!(s & ~0x3));
1432 assert(!(y & ~0xff));
1433 assert(!(m & ~0x1));
1434 assert(!(r & ~0x1f));
1435 ii((o<<26)|(b<<21)|(x<<16)|(s<<14)|(y<<6)|(m<<5)|r);
1439 _f25(jit_state_t *_jit, jit_int32_t o,
1440 jit_int32_t b, jit_int32_t i, jit_int32_t s,
1441 jit_int32_t y, jit_int32_t m, jit_int32_t r)
1443 assert(!(o & ~0x3f));
1444 assert(!(b & ~0x1f));
1445 assert(i >= -16 && i <= 15);
1446 assert(!(s & ~0x3));
1447 assert(!(y & ~0xff));
1448 assert(!(m & ~0x1));
1449 assert(!(r & ~0x1f));
1450 ii((o<<26)|(b<<21)|(low_sign_unext(i,5)<<16)|(s<<14)|(y<<6)|(m<<5)|r);
1454 _f26(jit_state_t *_jit, jit_int32_t o,
1455 jit_int32_t b, jit_int32_t x, jit_int32_t s,
1456 jit_int32_t y, jit_int32_t m,jit_int32_t r)
1458 assert(!(o & ~0x3f));
1459 assert(!(b & ~0x1f));
1460 assert(!(x & ~0x1f));
1461 assert(!(s & ~0x7));
1462 assert(!(y & ~0x7f));
1463 assert(!(m & ~0x1));
1464 assert(!(r & ~0x1f));
1465 ii((o<<26)|(b<<21)|(x<<16)|(s<<13)|(y<<6)|(m<<5)|r);
1469 _f27(jit_state_t *_jit, jit_int32_t o, jit_int32_t i, jit_int32_t j)
1471 assert(!(o & ~0x3f));
1472 assert(i >= -4096 && i < 4095);
1473 assert(j >= -16 && j < 15);
1474 ii((o<<26)|(i<<13)|j);
1478 _f28(jit_state_t *_jit, jit_int32_t o, jit_int32_t i)
1480 assert(!(o & ~0x3f));
1481 assert(!(i & ~0x1ffffff));
1486 _f29(jit_state_t *_jit, jit_int32_t o, jit_int32_t r,
1487 jit_int32_t x, jit_int32_t s, jit_int32_t y, jit_int32_t t)
1489 assert(!(o & ~0x3f));
1490 assert(!(r & ~0x1f));
1491 assert(!(x & ~0x1f));
1492 assert(!(s & ~0x7));
1493 assert(!(y & ~0xff));
1494 assert(!(t & ~0x1f));
1495 ii((o<<26)|(r<<21)|(x<<16)|re_assemble_3(s)|(y<<5)|t);
1499 _f30(jit_state_t *_jit, jit_int32_t o, jit_int32_t b, jit_int32_t r,
1500 jit_int32_t s, jit_int32_t x, jit_int32_t y, jit_int32_t t)
1502 assert(!(o & ~0x3f));
1503 assert(!(b & ~0x1f));
1504 assert(!(r & ~0x1f));
1505 assert(!(s & ~0x3));
1506 assert(!(x & ~0x1));
1507 assert(!(y & ~0xff));
1508 assert(!(t & ~0x1f));
1509 ii((o<<26)|(b<<21)|(r<<16)|(s<<14)|(x<<13)|(y<<5)|t);
1513 _f31(jit_state_t *_jit, jit_int32_t o, jit_int32_t t,
1514 jit_int32_t r, jit_int32_t v, jit_int32_t x, jit_int32_t y)
1516 assert(!(o & ~0x3f));
1517 assert(!(t & ~0x1f));
1518 assert(!(r & ~0x1f));
1519 assert(!(v & ~0x1f));
1520 assert(!(x & ~0xff));
1521 assert(!(y & ~0x1f));
1522 ii((o<<26)|(t<<21)|(r<<16)|(v<<14)|(x<<5)|y);
1526 _f33(jit_state_t *_jit, jit_int32_t o, jit_int32_t x,
1527 jit_int32_t r, jit_int32_t y, jit_int32_t z, jit_int32_t u)
1529 assert(!(o & ~0x3f));
1530 assert(!(x & ~0x1f));
1531 assert(!(r & ~0x1f));
1532 assert(!(y & ~0x7));
1533 assert(!(z & ~0xff));
1534 assert(!(u & ~0x1f));
1535 ii((o<<26)|(x<<21)|(r<<16)|(y<<13)|(z<<5)|u);
1539 _f34(jit_state_t *_jit, jit_int32_t o, jit_int32_t o1,
1540 jit_int32_t x, jit_int32_t sf, jit_int32_t n, jit_int32_t o2)
1542 assert(!(o & ~0x3f));
1543 assert(!(o1 & ~0x7fff));
1544 assert(!(x & ~0x3));
1545 assert(!(sf & ~0x7));
1546 assert(!(n & ~0x1));
1547 assert(!(o2 & ~0x1f));
1548 ii((o<<26)|(o1<<11)|(x<<9)|(sf<<6)|(n<<5)|o2);
1552 _f35(jit_state_t *_jit, jit_int32_t o, jit_int32_t op,
1553 jit_int32_t x, jit_int32_t sf, jit_int32_t n, jit_int32_t t)
1555 assert(!(o & ~0x3f));
1556 assert(!(op & ~0x7fff));
1557 assert(!(x & ~0x3));
1558 assert(!(sf & ~0x7));
1559 assert(!(n & ~0x1));
1560 assert(!(t & ~0x1f));
1561 ii((o<<26)|(op<<11)|(x<<9)|(sf<<6)|(n<<5)|t);
1565 _f36(jit_state_t *_jit, jit_int32_t o, jit_int32_t r, jit_int32_t o1,
1566 jit_int32_t x, jit_int32_t sf, jit_int32_t n, jit_int32_t o2)
1568 assert(!(o & ~0x3f));
1569 assert(!(r & ~0x1f));
1570 assert(!(o1 & ~0x3ff));
1571 assert(!(x & ~0x3));
1572 assert(!(sf & ~0x7));
1573 assert(!(n & ~0x1));
1574 assert(!(o2 & ~0x1f));
1575 ii((o<<26)|(r<<21)|(o1<<11)|(x<<9)|(sf<<6)|(n<<5)|o2);
1579 _f37(jit_state_t *_jit, jit_int32_t o, jit_int32_t r2,
1580 jit_int32_t r1, jit_int32_t o1, jit_int32_t x,
1581 jit_int32_t sf, jit_int32_t n, jit_int32_t o2)
1583 assert(!(o & ~0x3f));
1584 assert(!(r2 & ~0x1f));
1585 assert(!(r1 & ~0x1f));
1586 assert(!(o1 & ~0x1f));
1587 assert(!(x & ~0x3));
1588 assert(!(sf & ~0x7));
1589 assert(!(n & ~0x1));
1590 assert(!(o2 & ~0x1f));
1591 ii((o<<26)|(r2<<21)|(r1<<16)|(o1<<11)|(x<<9)|(sf<<6)|(n<<5)|o2);
1595 _f38(jit_state_t *_jit, jit_int32_t o,
1596 jit_int32_t s, jit_int32_t u, jit_int32_t n)
1598 assert(!(o & ~0x3f));
1599 assert(!(s & ~0x3fffff));
1600 assert(!(u & ~0x7));
1601 assert(!(n & ~0x1));
1602 ii((o<<26)|((s>>5)<<9)|(u<<6)|(n<<1)|(s&0x1f));
1606 _nop(jit_state_t *_jit, jit_int32_t i0)
1608 for (; i0 > 0; i0 -= 4)
1614 _movr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1621 _movi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1623 if (i0 >= -8192 && i0 <= 8191)
1625 else if (!(i0 & 0x7ff))
1628 LDIL(i0 & ~0x7ff, r0);
1629 LDO(i0 & 0x7ff, r0, r0);
1634 _movi_p(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1638 LDIL(i0 & ~0x7ff, r0);
1639 LDO(i0 & 0x7ff, r0, r0);
1644 _bswapr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1648 reg = jit_get_reg(jit_class_gpr);
1650 EXTRWR_U(rn(reg), 23, 8, r0);
1651 DEPWR(rn(reg), 23, 8, r0);
1655 EXTRWR_U(r1, 23, 8, r0);
1656 DEPWR(r1, 23, 8, r0);
1661 _bswapr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1665 reg = jit_get_reg(jit_class_gpr);
1667 SHRPWI(rn(reg), rn(reg), 16, r0);
1668 DEPWR(r0, 15, 8, r0);
1669 SHRPWI(rn(reg), r0, 8, r0);
1673 SHRPWI(r1, r1, 16, r0);
1674 DEPWR(r0, 15, 8, r0);
1675 SHRPWI(r1, r0, 8, r0);
1680 _movnr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1683 w = beqi(_jit->pc.w, r2, 0);
1685 patch_at(w, _jit->pc.w);
1689 _movzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1692 w = bnei(_jit->pc.w, r2, 0);
1694 patch_at(w, _jit->pc.w);
1698 _casx(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1699 jit_int32_t r2, jit_int32_t r3, jit_word_t i0)
1701 #if defined(__linux__) && defined(SYS_atomic_cmpxchg_32) && __WORDSIZE == 32
1702 /* Not defined, and unlikely to ever be defined, but could be a way to do it */
1703 movi(_R26_REGNO, SYS_atomic_cmpxchg_32);
1705 movi(_R25_REGNO, i0);
1707 movr(_R25_REGNO, r1);
1708 movr(_R24_REGNO, r2);
1709 movr(_R23_REGNO, r3);
1710 /* Should only fail for an invalid or unaligned address.
1711 * Do not handle this condition. */
1713 movr(r0, _R28_REGNO);
1716 * The only atomic operations are LDCW and LDCD, that load a value,
1717 * and store zero at the address atomically. The (semaphore) address
1718 * must be 16 byte aligned.
1720 fallback_casx(r0, r1, r2, r3, i0);
1722 * It is important to be aware of the delayed nature of cache flush and
1723 * purge operations, and to use SYNC instructions to force completion
1724 * where necessary. The following example illustrates this.
1725 * Consider two processes sharing a memory location x which is protected
1728 * process A on Processor 1 | process B on Processor 2 | note
1729 * -------------------------+---------------------------+------------
1730 * LDCW s | | A acquires semaphore
1731 * PDC x | | A executes purge
1732 * SYNC | | Force completion of purge
1733 * STW s | | A releases semaphore
1734 * | LDCW s | B acquires semaphore
1737 * In the absence of the SYNC instruction, it would be possible for
1738 * process B's store to x to complete before the purge of x is completed
1739 * (since the purge may have been delayed). The purge of x could then
1740 * destroy the new value.
1746 _addi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1749 if (i0 >= -1024 && i0 <= 1023)
1752 reg = jit_get_reg(jit_class_gpr);
1754 addr(r0, r1, rn(reg));
1760 _addci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1763 reg = jit_get_reg(jit_class_gpr);
1765 addcr(r0, r1, rn(reg));
1770 _addxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1773 reg = jit_get_reg(jit_class_gpr);
1775 addxr(r0, r1, rn(reg));
1780 _subi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1783 if (i0 >= -1023 && i0 <= 1024)
1786 reg = jit_get_reg(jit_class_gpr);
1788 subr(r0, r1, rn(reg));
1794 _subci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1797 reg = jit_get_reg(jit_class_gpr);
1799 subcr(r0, r1, rn(reg));
1804 _subxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1807 reg = jit_get_reg(jit_class_gpr);
1809 subxr(r0, r1, rn(reg));
1814 _rsbi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1817 if (i0 >= -1024 && i0 <= 1023)
1820 reg = jit_get_reg(jit_class_gpr);
1822 subr(r0, rn(reg), r1);
1828 _mulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1831 t0 = jit_get_reg(jit_class_fpr);
1832 t1 = jit_get_reg(jit_class_fpr);
1833 stxi(alloca_offset - 8, _FP_REGNO, r1);
1834 ldxi_f(rn(t0), _FP_REGNO, alloca_offset - 8);
1835 stxi(alloca_offset - 8, _FP_REGNO, r2);
1836 ldxi_f(rn(t1), _FP_REGNO, alloca_offset - 8);
1837 XMPYU(rn(t0), rn(t1), rn(t0));
1838 stxi_d(alloca_offset - 8, _FP_REGNO, rn(t0));
1839 ldxi(r0, _FP_REGNO, alloca_offset - 4);
1845 _muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1853 reg = jit_get_reg(jit_class_gpr);
1855 mulr(r0, r1, rn(reg));
1861 __llmul(int u, int v)
1863 return ((long long)u * (long long)v);
1867 _qmulr(jit_state_t *_jit,
1868 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
1870 movr(_R26_REGNO, r2);
1871 movr(_R25_REGNO, r3);
1872 calli((jit_word_t)__llmul);
1873 movr(r0, _R29_REGNO);
1874 movr(r1, _R28_REGNO);
1878 _qmuli(jit_state_t *_jit,
1879 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
1881 movr(_R26_REGNO, r2);
1882 movi(_R25_REGNO, i0);
1883 calli((jit_word_t)__llmul);
1884 movr(r0, _R29_REGNO);
1885 movr(r1, _R28_REGNO);
1889 _qmulr_u(jit_state_t *_jit,
1890 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
1893 t0 = jit_get_reg(jit_class_fpr);
1894 t1 = jit_get_reg(jit_class_fpr);
1895 stxi(alloca_offset - 8, _FP_REGNO, r2);
1896 ldxi_f(rn(t0), _FP_REGNO, alloca_offset - 8);
1897 stxi(alloca_offset - 8, _FP_REGNO, r3);
1898 ldxi_f(rn(t1), _FP_REGNO, alloca_offset - 8);
1899 XMPYU(rn(t0), rn(t1), rn(t0));
1900 stxi_d(alloca_offset - 8, _FP_REGNO, rn(t0));
1901 ldxi(r0, _FP_REGNO, alloca_offset - 4);
1902 ldxi(r1, _FP_REGNO, alloca_offset - 8);
1908 _qmuli_u(jit_state_t *_jit,
1909 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
1912 reg = jit_get_reg(jit_class_gpr);
1914 qmulr_u(r0, r1, r2, rn(reg));
1919 __idiv(int u, int v)
1925 _divr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1927 movr(_R26_REGNO, r1);
1928 movr(_R25_REGNO, r2);
1929 calli((jit_word_t)__idiv);
1930 movr(r0, _R28_REGNO);
1934 _divi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1936 movr(_R26_REGNO, r1);
1937 movi(_R25_REGNO, i0);
1938 calli((jit_word_t)__idiv);
1939 movr(r0, _R28_REGNO);
1943 __udiv(unsigned int u, unsigned int v)
1949 _divr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1951 movr(_R26_REGNO, r1);
1952 movr(_R25_REGNO, r2);
1953 calli((jit_word_t)__udiv);
1954 movr(r0, _R28_REGNO);
1958 _divi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1960 movr(_R26_REGNO, r1);
1961 movi(_R25_REGNO, i0);
1962 calli((jit_word_t)__udiv);
1963 movr(r0, _R28_REGNO);
1967 __irem(int u, int v)
1973 _remr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1975 movr(_R26_REGNO, r1);
1976 movr(_R25_REGNO, r2);
1977 calli((jit_word_t)__irem);
1978 movr(r0, _R28_REGNO);
1982 _remi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1984 movr(_R26_REGNO, r1);
1985 movi(_R25_REGNO, i0);
1986 calli((jit_word_t)__irem);
1987 movr(r0, _R28_REGNO);
1991 __urem(unsigned int u, unsigned int v)
1997 _remr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1999 movr(_R26_REGNO, r1);
2000 movr(_R25_REGNO, r2);
2001 calli((jit_word_t)__urem);
2002 movr(r0, _R28_REGNO);
2006 _remi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2008 movr(_R26_REGNO, r1);
2009 movi(_R25_REGNO, i0);
2010 calli((jit_word_t)__urem);
2011 movr(r0, _R28_REGNO);
2015 __idivrem(int u, int v)
2024 _qdivr(jit_state_t *_jit,
2025 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
2027 movr(_R26_REGNO, r2);
2028 movr(_R25_REGNO, r3);
2029 calli((jit_word_t)__idivrem);
2030 movr(r0, _R28_REGNO);
2031 movr(r1, _R29_REGNO);
2035 _qdivi(jit_state_t *_jit,
2036 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
2038 movr(_R26_REGNO, r2);
2039 movi(_R25_REGNO, i0);
2040 calli((jit_word_t)__idivrem);
2041 movr(r0, _R28_REGNO);
2042 movr(r1, _R29_REGNO);
2046 __udivrem(unsigned int u, unsigned int v)
2055 _qdivr_u(jit_state_t *_jit,
2056 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
2058 movr(_R26_REGNO, r2);
2059 movr(_R25_REGNO, r3);
2060 calli((jit_word_t)__udivrem);
2061 movr(r0, _R28_REGNO);
2062 movr(r1, _R29_REGNO);
2066 _qdivi_u(jit_state_t *_jit,
2067 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
2069 movr(_R26_REGNO, r2);
2070 movi(_R25_REGNO, i0);
2071 calli((jit_word_t)__udivrem);
2072 movr(r0, _R28_REGNO);
2073 movr(r1, _R29_REGNO);
2077 _andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2080 reg = jit_get_reg(jit_class_gpr);
2082 andr(r0, r1, rn(reg));
2087 _ori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2090 reg = jit_get_reg(jit_class_gpr);
2092 orr(r0, r1, rn(reg));
2097 _xori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2100 reg = jit_get_reg(jit_class_gpr);
2102 xorr(r0, r1, rn(reg));
2107 _lshr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
2109 SUBI(0x1f, r2, _R1_REGNO);
2115 _rshr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
2117 SUBI(0x1f, r2, _R1_REGNO);
2123 _rshr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
2125 SUBI(0x1f, r2, _R1_REGNO);
2127 EXTRW_U(r1, 32, r0);
2131 _cmpr(jit_state_t *_jit, jit_word_t c,
2132 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2134 CMPCLR_(c, r1, r2, r0);
2139 _cmpi(jit_state_t *_jit, jit_word_t c, jit_word_t ci,
2140 jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2143 if (i0 >= -16 && i0 <= 15)
2144 CMPICLR_(ci, i0, r1, r0);
2146 reg = jit_get_reg(jit_class_gpr);
2148 CMPCLR_(c, r1, rn(reg), r0);
2155 _ldr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2162 _ldi_c(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2169 _ldxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2171 ldxr_uc(r0, r1, r2);
2176 _ldxi_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2178 ldxi_uc(r0, r1, i0);
2183 _ldi_uc(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2186 if (i0 >= -8182 && i0 <= 8191)
2187 LDBL(i0, _R0_REGNO, r0);
2189 reg = jit_get_reg(jit_class_gpr);
2190 LDIL(i0 & ~0x7ff, rn(reg));
2191 LDBL(sign_extend(i0, 11), rn(reg), r0);
2197 _ldxi_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2200 if (i0 >= -16 && i0 <= 15)
2202 else if (i0 >= -8182 && i0 <= 8191)
2205 reg = jit_get_reg(jit_class_gpr);
2207 ldxr_uc(r0, r1, rn(reg));
2213 _ldr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2220 _ldi_s(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2227 _ldxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2229 ldxr_us(r0, r1, r2);
2234 _ldxi_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2236 ldxi_us(r0, r1, i0);
2241 _ldi_us(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2244 if (i0 >= -8182 && i0 <= 8191)
2245 LDHL(i0, _R0_REGNO, r0);
2247 reg = jit_get_reg(jit_class_gpr);
2248 LDIL(i0 & ~0x7ff, rn(reg));
2249 LDHL(sign_extend(i0, 11), rn(reg), r0);
2255 _ldxi_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2258 if (i0 >= -16 && i0 <= 15)
2260 else if (i0 >= -8182 && i0 <= 8191)
2263 reg = jit_get_reg(jit_class_gpr);
2265 ldxr_us(r0, r1, rn(reg));
2271 _ldi_ui(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2274 if (i0 >= -8182 && i0 <= 8191)
2275 LDWL(i0, _R0_REGNO, r0);
2277 reg = jit_get_reg(jit_class_gpr);
2278 LDIL(i0 & ~0x7ff, rn(reg));
2279 LDWL(sign_extend(i0, 11), rn(reg), r0);
2285 _ldxi_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2288 if (i0 >= -16 && i0 <= 15)
2290 else if (i0 >= -8182 && i0 <= 8191)
2293 reg = jit_get_reg(jit_class_gpr);
2295 ldxr_ui(r0, r1, rn(reg));
2301 _sti_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2304 if (i0 >= -8182 && i0 <= 8191)
2305 STBL(r0, i0, _R0_REGNO);
2307 reg = jit_get_reg(jit_class_gpr);
2308 LDIL(i0 & ~0x7ff, rn(reg));
2309 STBL(r0, sign_extend(i0, 11), rn(reg));
2315 _stxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2318 reg = jit_get_reg(jit_class_gpr);
2319 addr(rn(reg), r0, r1);
2325 _stxi_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2328 if (i0 >= -16 && i0 <= 15)
2330 else if (i0 >= -8182 && i0 <= 8191)
2333 reg = jit_get_reg(jit_class_gpr);
2334 addi(rn(reg), r0, i0);
2341 _sti_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2344 if (i0 >= -8182 && i0 <= 8191)
2345 STHL(r0, i0, _R0_REGNO);
2347 reg = jit_get_reg(jit_class_gpr);
2348 LDIL(i0 & ~0x7ff, rn(reg));
2349 STHL(r0, sign_extend(i0, 11), rn(reg));
2355 _stxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
2358 reg = jit_get_reg(jit_class_gpr);
2359 addr(rn(reg), r0, r1);
2365 _stxi_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2368 if (i0 >= -16 && i0 <= 15)
2370 else if (i0 >= -8182 && i0 <= 8191)
2373 reg = jit_get_reg(jit_class_gpr);
2374 addi(rn(reg), r0, i0);
2381 _sti_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2384 if (i0 >= -8182 && i0 <= 8191)
2385 STWL(r0, i0, _R0_REGNO);
2387 reg = jit_get_reg(jit_class_gpr);
2388 LDIL(i0 & ~0x7ff, rn(reg));
2389 STWL(r0, sign_extend(i0, 11), rn(reg));
2395 _stxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
2398 reg = jit_get_reg(jit_class_gpr);
2399 addr(rn(reg), r0, r1);
2405 _stxi_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2408 if (i0 >= -16 && i0 <= 15)
2410 else if (i0 >= -8182 && i0 <= 8191)
2413 reg = jit_get_reg(jit_class_gpr);
2414 addi(rn(reg), r0, i0);
2421 _bcmpr(jit_state_t *_jit, jit_word_t c,
2422 jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2426 CMPB_N_(c, r0, r1, ((i0 - w) >> 2) - 2);
2432 _bcmpi(jit_state_t *_jit, jit_word_t c, jit_word_t ci,
2433 jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2437 if (i1 >= -16 && i1 <= 15) {
2439 CMPIB_N_(ci, i1, r0, ((i0 - w) >> 2) - 2);
2442 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2445 CMPB_N_(c, r0, rn(reg), ((i0 - w) >> 2) - 2);
2453 _bmxr(jit_state_t *_jit, jit_bool_t c,
2454 jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2458 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2459 andr(rn(reg), r0, r1);
2460 w = c ? bnei(i0, rn(reg), 0) : beqi(i0, rn(reg), 0);
2466 _bmxi(jit_state_t *_jit, jit_bool_t c,
2467 jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2471 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2473 andr(rn(reg), r0, rn(reg));
2474 w = c ? bnei(i0, rn(reg), 0) : beqi(i0, rn(reg), 0);
2480 _boaddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2484 ADDB_N_SV(r1, r0, ((i0 - w) >> 2) - 2);
2490 _boaddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2494 if (i1 >= -16 && i1 <= 15) {
2496 ADDIB_N_SV(i1, r0, ((i0 - w) >> 2) - 2);
2500 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2502 w = boaddr(i0, r0, rn(reg));
2509 _boaddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2513 ADDB_N_UV(r1, r0, ((i0 - w) >> 2) - 2);
2519 _boaddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2523 if (i1 >= -16 && i1 <= 15) {
2525 ADDIB_N_UV(i1, r0, ((i0 - w) >> 2) - 2);
2529 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2531 w = boaddr_u(i0, r0, rn(reg));
2538 _bxaddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2542 ADDB_N_NSV(r1, r0, ((i0 - w) >> 2) - 2);
2548 _bxaddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2552 if (i1 >= -16 && i1 <= 15) {
2554 ADDIB_N_NSV(i1, r0, ((i0 - w) >> 2) - 2);
2558 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2560 w = bxaddr(i0, r0, rn(reg));
2567 _bxaddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2571 ADDB_N_NUV(r1, r0, ((i0 - w) >> 2) - 2);
2577 _bxaddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2581 if (i1 >= -16 && i1 <= 15) {
2583 ADDIB_N_NUV(i1, r0, ((i0 - w) >> 2) - 2);
2587 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2589 w = bxaddr_u(i0, r0, rn(reg));
2596 _bosubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2599 SUB_NSV(r0, r1, r0);
2601 /* null'ed if no signed overflow */
2602 B_N(((i0 - w) >> 2) - 2, _R0_REGNO);
2608 _bosubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2610 movi(_R1_REGNO, i1);
2611 return (bosubr(i0, r0, _R1_REGNO));
2615 _bosubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2618 SUB_B(_R0_REGNO, _R0_REGNO, _R1_REGNO);
2619 return (bnei(i0, _R1_REGNO, 0));
2623 _bosubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2625 movi(_R1_REGNO, i1);
2626 SUB(r0, _R1_REGNO, r0);
2627 SUB_B(_R0_REGNO, _R0_REGNO, _R1_REGNO);
2628 return (bnei(i0, _R1_REGNO, 0));
2632 _bxsubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2637 /* null'ed if signed overflow */
2638 B_N(((i0 - w) >> 2) - 2, _R0_REGNO);
2644 _bxsubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2646 movi(_R1_REGNO, i1);
2647 return (bxsubr(i0, r0, _R1_REGNO));
2651 _bxsubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2654 SUB_B(_R0_REGNO, _R0_REGNO, _R1_REGNO);
2655 return (beqi(i0, _R1_REGNO, 0));
2659 _bxsubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2661 movi(_R1_REGNO, i1);
2662 SUB(r0, _R1_REGNO, r0);
2663 SUB_B(_R0_REGNO, _R0_REGNO, _R1_REGNO);
2664 return (beqi(i0, _R1_REGNO, 0));
2668 _jmpr(jit_state_t *_jit, jit_int32_t r0)
2670 BV_N(_R0_REGNO, r0);
2674 _jmpi(jit_state_t *_jit, jit_word_t i0)
2678 d = ((i0 - w) >> 2) - 2;
2679 if (d >= -32768 && d <= 32767)
2683 BV_N(_R0_REGNO, _R1_REGNO);
2689 _jmpi_p(jit_state_t *_jit, jit_word_t i0)
2692 w = movi_p(_R1_REGNO, i0);
2698 _callr(jit_state_t *_jit, jit_int32_t r0)
2702 if (r0 != _R1_REGNO)
2703 COPY(r0, _R1_REGNO);
2704 /* inline $$dyncall */
2706 BBI_N_GE(_R1_REGNO, 30, 0); /* if (r1 & 2) { */
2707 DEPWRI(0, 31, 2, _R1_REGNO); /* r1 &= ~2; */
2708 LDWI(4, _R1_REGNO, _R19_REGNO); /* r19 = r1[1]; */
2709 LDWI(0, _R1_REGNO, _R1_REGNO); /* r1 = r1[0]; */
2712 STWL(_RP_REGNO, -24, _SP_REGNO);
2715 patch_at(imm, _jit->pc.w);
2718 patch_at(dyn, _jit->pc.w);
2722 _calli(jit_state_t *_jit, jit_word_t i0)
2727 movi(_R1_REGNO, i0);
2728 LDWI(4, _R1_REGNO, _R19_REGNO);
2729 LDWI(0, _R1_REGNO, _R1_REGNO);
2731 STWL(_RP_REGNO, -24, _SP_REGNO);
2734 w = ((i0 - _jit->pc.w) >> 2) - 2;
2735 if (w >= -32768 && w <= 32767)
2738 movi(_R1_REGNO, i0);
2746 _calli_p(jit_state_t *_jit, jit_word_t i0)
2749 w = movi_p(_R1_REGNO, i0);
2754 static jit_int32_t gr[] = {
2755 _R4, _R5, _R6, _R7, _R8,
2756 _R9, _R10, _R11, _R12, _R13,
2757 _R14, _R15, _R16, _R17, _R18
2760 static jit_int32_t fr[] = {
2761 _F12, _F13, _F14, _F15, _F16,
2762 _F17, _F18, _F19, _F20, _F21
2766 _prolog(jit_state_t *_jit, jit_node_t *node)
2771 if (_jitc->function->define_frame || _jitc->function->assume_frame) {
2772 /* hppa stack grows up */
2773 assert(_jitc->function->self.aoff <= _jitc->function->frame);
2774 if (_jitc->function->assume_frame)
2776 _jitc->function->self.aoff = _jitc->function->frame;
2778 if (_jitc->function->allocar) {
2779 _jitc->function->self.aoff += 63;
2780 _jitc->function->self.aoff &= -64;
2782 _jitc->function->stack = ((_jitc->function->self.aoff -
2783 _jitc->function->self.alen -
2784 _jitc->function->self.size) + 63) & -64;
2786 /* Save stack frame (FIXME Only required if non leaf) */
2787 STWL(_RP_REGNO, -20, _SP_REGNO);
2789 /* Create stack frame */
2790 COPY(_FP_REGNO, _R1_REGNO);
2791 COPY(_SP_REGNO, _FP_REGNO);
2792 STWL_MA(_R1_REGNO, _jitc->function->stack, _SP_REGNO);
2794 /* Save any modified callee save registers */
2795 offset = alloca_offset - 140;
2796 for (regno = 0; regno < jit_size(gr); regno++, offset += 4) {
2797 if (jit_regset_tstbit(&_jitc->function->regset, gr[regno]))
2798 stxi(offset, _FP_REGNO, rn(gr[regno]));
2800 for (regno = 0; regno < jit_size(fr); regno++, offset += 8) {
2801 if (jit_regset_tstbit(&_jitc->function->regset, fr[regno]))
2802 stxi_d(offset, _FP_REGNO, rn(fr[regno]));
2805 if (_jitc->function->allocar) {
2806 regno = jit_get_reg(jit_class_gpr);
2807 movi(rn(regno), _jitc->function->self.aoff);
2808 stxi_i(_jitc->function->aoffoff, _FP_REGNO, rn(regno));
2809 jit_unget_reg(regno);
2812 if (_jitc->function->self.call & jit_call_varargs) {
2813 for (regno = 3; regno >= _jitc->function->vagp; --regno)
2814 stxi(params_offset - regno * 4 - 4, _FP_REGNO, rn(_R26 - regno));
2819 _epilog(jit_state_t *_jit, jit_node_t *node)
2824 if (_jitc->function->assume_frame)
2826 /* Restore any modified callee save registers */
2827 offset = alloca_offset - 140;
2828 for (regno = 0; regno < jit_size(gr); regno++, offset += 4) {
2829 if (jit_regset_tstbit(&_jitc->function->regset, gr[regno]))
2830 ldxi(rn(gr[regno]), _FP_REGNO, offset);
2832 for (regno = 0; regno < jit_size(fr); regno++, offset += 8) {
2833 if (jit_regset_tstbit(&_jitc->function->regset, fr[regno]))
2834 ldxi_d(rn(fr[regno]), _FP_REGNO, offset);
2837 /* Restore stack frame (FIXME Only required if non leaf) */
2838 LDWL(-20, _FP_REGNO, _RP_REGNO);
2839 LDO(_jitc->function->stack, _FP_REGNO, _SP_REGNO);
2840 LDWL_MB(-_jitc->function->stack, _SP_REGNO, _FP_REGNO);
2844 BV_N(_R0_REGNO, _RP_REGNO);
2849 _vastart(jit_state_t *_jit, jit_int32_t r0)
2851 /* Initialize stack pointer to the first stack argument. */
2852 if (jit_arg_reg_p(_jitc->function->vagp))
2853 addi(r0, _FP_REGNO, params_offset - _jitc->function->vagp * 4);
2855 addi(r0, _FP_REGNO, _jitc->function->self.size);
2859 _vaarg(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2861 assert(_jitc->function->self.call & jit_call_varargs);
2863 /* Update vararg stack pointer. */
2866 /* Load argument. */
2871 _patch_at(jit_state_t *_jit, jit_word_t instr, jit_word_t label)
2879 switch (u.i[0] >> 26) {
2880 case 0x8: /* LDIL */
2881 u.i[0] &= ~0x1fffff;
2882 u.i[0] |= re_assemble_21((label & ~0x7ff) >> 11);
2883 assert((u.i[1] >> 26) == 0xd); /* LDO */
2885 u.i[1] |= re_assemble_16(label & 0x7ff);
2887 case 0x20: case 0x22: /* CMPB */
2888 case 0x21: case 0x23: /* CMPIB */
2889 case 0x28: case 0x2a: /* ADDB */
2890 case 0x29: case 0x2b: /* ADDIB */
2891 case 0x31: /* BBI */
2892 w = ((label - instr) >> 2) - 2;
2893 assert(w >= -2048 && w <= 2047);
2895 u.i[0] |= re_assemble_12(w);
2898 w = ((label - instr) >> 2) - 2;
2899 assert(w >= -32768 && w <= 32767);
2900 u.i[0] &= ~0x1f1ffd;
2901 u.i[0] |= re_assemble_17(w);