notaz.gp2x.de / pcsx_rearmed.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
libretro: adjust psxclock description
[pcsx_rearmed.git] / deps / lightning / lib / jit_hppa-cpu.c
CommitLineData
4a71579b 1/*
79bfeef6 2 * Copyright (C) 2013-2023 Free Software Foundation, Inc.
4a71579b
PC		 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
21typedef struct idiv {
22 int quo;
23 int rem;
24} idiv_t;
25
26typedef struct udiv {
27 unsigned int quo;
28 unsigned int rem;
29} udiv_t;
30
ba86ff93
PC		 31#define jit_imm_idx_p() jit_cpu.imm_idx
32
4a71579b
PC		 33/* 16 spill bytes; -52 for first actual stack argument */
34#define params_offset -32
35/* Assume all callee save registers may need to be spilled */
36#define alloca_offset 192
37#define _R0_REGNO 0
38#define _R1_REGNO 1
39#define _RP_REGNO 2
40#define _FP_REGNO 3
41#define _R19_REGNO 19
42#define _R23_REGNO 23
43#define _R24_REGNO 24
44#define _R25_REGNO 25
45#define _R26_REGNO 26
46#define _R28_REGNO 28
47#define _R29_REGNO 29
48#define _SP_REGNO 30
49#define _R31_REGNO 31
50#define _CR11_REGNO 11
51#define ii(v) *_jit->pc.ui++ = v
ba86ff93
PC		 52#define ldr(r0,r1) ldr_ui(r0,r1)
53#define ldi(r0,i0) ldi_ui(r0,i0)
54#define ldxr(r0,r1,r2) ldxr_ui(r0,r1,r2)
55#define ldxi(r0,r1,i0) ldxi_ui(r0,r1,i0)
56#define str(r0,r1) str_i(r0,r1)
57#define sti(i0,r0) sti_i(i0,r0)
58#define stxr(r0,r1,r2) stxr_i(r0,r1,r2)
59#define stxi(i0,r0,r1) stxi_i(i0,r0,r1)
4a71579b
PC		 60#define f1(o,b,t,i) _f1(_jit,o,b,t,i)
61static void _f1(jit_state_t*,jit_int32_t,
62 jit_int32_t,jit_int32_t,jit_int32_t);
63#define f2(o,b,r,i,j) _f2(_jit,o,b,r,i,j)
64static void _f2(jit_state_t*,jit_int32_t,jit_int32_t,
65 jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
66#define f3(o,b,t,i,j) _f3(_jit,o,b,t,i,j)
67static void _f3(jit_state_t*,jit_int32_t,jit_int32_t,
68 jit_int32_t,jit_int32_t,jit_int32_t);
69#define f4(o,b,x,s,u,y,c,z,m,t) _f4(_jit,o,b,x,s,u,y,c,z,m,t)
70static void _f4(jit_state_t*,jit_int32_t,jit_int32_t,
71 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
72 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
73#define f5(o,b,i,s,a,y,c,z,m,t) _f5(_jit,o,b,i,s,a,y,c,z,m,t)
74static void _f5(jit_state_t*,jit_int32_t,jit_int32_t,
75 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
76 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
77#define f6(o,b,r,s,a,x,c,y,m,i) _f6(_jit,o,b,r,s,a,x,c,y,m,i)
78static void _f6(jit_state_t*,jit_int32_t,jit_int32_t,
79 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
80 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
81#define f7(o,r,i) _f7(_jit,o,r,i)
82static void _f7(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
83#define f8(o,r2,r1,cf,e1,x,e2,y,d,t) _f8(_jit,o,r2,r1,cf,e1,x,e2,y,d,t)
84static void _f8(jit_state_t*,jit_int32_t,
85 jit_int32_t,jit_int32_t,jit_int32_t,
86 jit_int32_t,jit_int32_t,jit_int32_t,
87 jit_int32_t,jit_int32_t,jit_int32_t);
88#define f9(o,r,t,cf,e1,im) _f9(_jit,o,r,t,cf,e1,im)
89static void _f9(jit_state_t*,
90 jit_int32_t,jit_int32_t,jit_int32_t,
91 jit_int32_t,jit_int32_t,jit_int32_t);
92#define f10(o,r2,r1,u,v,w,x,sa,y,t) _f10(_jit,o,r2,r1,u,v,w,x,sa,y,t)
93static void _f10(jit_state_t*,jit_int32_t,jit_int32_t,
94 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
95 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
96#define f11(o,r2,r1,c,x,y,z,u,t) _f11(_jit,o,r2,r1,c,x,y,z,u,t)
97static void _f11(jit_state_t*,jit_int32_t,
98 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
99 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
100#define f12(o,r,t,c,x,se,y,c1,z,clen) _f12(_jit,o,r,t,c,x,se,y,c1,z,clen)
101static void _f12(jit_state_t*,jit_int32_t,jit_int32_t,
102 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
103 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
104#define f13(o,t,r,c,x,nz,c1,clen) _f13(_jit,o,t,r,c,x,nz,c1,clen)
105static void _f13(jit_state_t*,jit_int32_t,jit_int32_t,
106 jit_int32_t,jit_int32_t,jit_int32_t,
107 jit_int32_t,jit_int32_t,jit_int32_t);
108#define f13x(o,t,i,c,x,nz,c1,clen) _f13x(_jit,o,t,i,c,x,nz,c1,clen)
109static void _f13x(jit_state_t*,jit_int32_t,jit_int32_t,
110 jit_int32_t,jit_int32_t,jit_int32_t,
111 jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
112#define f14(o,r2,r1,c,x,cp,y,cpos,t) _f14(_jit,o,r2,r1,c,x,cp,y,cpos,t)
113static void _f14(jit_state_t*,jit_int32_t,
114 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
115 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
116#define f15(o,r,t,c,c1,p,se,pos,clen) _f15(_jit,o,r,t,c,c1,p,se,pos,clen)
117static void _f15(jit_state_t*,jit_int32_t,
118 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
119 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
120#define f16(o,t,r,c,c1,cp,nz,cpos,clen) _f16(_jit,o,t,r,c,c1,cp,nz,cpos,clen)
121static void _f16(jit_state_t*,jit_int32_t,
122 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
123 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
124#define f16x(o,t,i,c,c1,cp,nz,cpos,clen) _f16x(_jit,o,t,i,c,c1,cp,nz,cpos,clen)
125static void _f16x(jit_state_t*,jit_int32_t,
126 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
127 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
128#define f17(o,r2,r1,c,i,n) _f17(_jit,o,r2,r1,c,i,n)
129static void _f17(jit_state_t*,jit_int32_t,jit_int32_t,
130 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
131#define f17x(o,r2,r1,c,i,n) _f17x(_jit,o,r2,r1,c,i,n)
132static void _f17x(jit_state_t*,jit_int32_t,jit_int32_t,
133 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
134#define f18(o,p,r,c,i,n) _f18(_jit,o,p,r,c,i,n)
135static void _f18(jit_state_t*,jit_int32_t,jit_int32_t,
136 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
137#define f19(o,b,s,i,n) _f19(_jit,o,b,s,i,n)
138static void _f19(jit_state_t*,jit_int32_t,jit_int32_t,
139 jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
140#define f20(o,t,i,g,n) _f20(_jit,o,t,i,g,n)
141static void _f20(jit_state_t*,jit_int32_t,jit_int32_t,
142 jit_int32_t,jit_int32_t,jit_int32_t);
143#define f21(o,t,x,y,n) _f21(_jit,o,t,x,y,n)
144static void _f21(jit_state_t*,jit_int32_t,jit_int32_t,
145 jit_int32_t,jit_int32_t,jit_int32_t);
146#define f22(o,b,x,r,n,p) _f22(_jit,o,b,x,r,n,p)
147static void _f22(jit_state_t*,jit_int32_t,jit_int32_t,
148 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
149#define f23(o,a,b,c,d,e,f,g,h) _f23(_jit,o,a,b,c,d,e,f,g,h)
150static void _f23(jit_state_t*,jit_int32_t,
151 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
152 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
153#define f24(o,b,x,s,y,m,r) _f24(_jit,o,b,x,s,y,m,r)
154static void _f24(jit_state_t*,jit_int32_t,
155 jit_int32_t,jit_int32_t,jit_int32_t,
156 jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
157#define f25(o,b,i,s,y,m,r) _f25(_jit,o,b,i,s,y,m,r)
158static void _f25(jit_state_t*,jit_int32_t,
159 jit_int32_t,jit_int32_t,jit_int32_t,
160 jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
161#define f26(o,b,x,s,y,m,r) _f26(_jit,o,b,x,s,y,m,r)
162static void _f26(jit_state_t*,jit_int32_t,
163 jit_int32_t,jit_int32_t,jit_int32_t,
164 jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
165#define f27(o,i,j) _f27(_jit,o,i,j)
166static void _f27(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
167#define f28(o,i) _f28(_jit,o,i)
168static void _f28(jit_state_t*,jit_int32_t,jit_int32_t) maybe_unused;
169#define f29(o,r,x,s,y,t) _f29(_jit,o,r,x,s,y,t)
170static void _f29(jit_state_t*,jit_int32_t,jit_int32_t,
171 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
172#define f30(o,b,r,s,x,y,t) _f30(_jit,o,b,r,s,x,y,t)
173static void _f30(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,
174 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
175#define f31(o,t,r,v,x,y) _f31(_jit,o,t,r,v,x,y)
176static void _f31(jit_state_t*,jit_int32_t,jit_int32_t,
177 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
178#define f33(o,x,r,y,z,u) _f33(_jit,o,x,r,y,z,u)
179static void _f33(jit_state_t*,jit_int32_t,jit_int32_t,
180 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
181#define f34(o,o1,x,sf,n,o2) _f34(_jit,o,o1,x,sf,n,o2)
182static void _f34(jit_state_t*,jit_int32_t,jit_int32_t,
183 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
184#define f35(o,op,x,sf,n,t) _f35(_jit,o,op,x,sf,n,t)
185static void _f35(jit_state_t*,jit_int32_t,jit_int32_t,
186 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
187#define f36(o,r,o1,x,sf,n,o2) _f36(_jit,o,r,o1,x,sf,n,o2)
188static void _f36(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,
189 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
190#define f37(o,r2,r1,o1,x,sf,n,o2) _f37(_jit,o,r2,r1,o1,x,sf,n,o2)
191static void _f37(jit_state_t*,jit_int32_t,jit_int32_t,
192 jit_int32_t,jit_int32_t,jit_int32_t,
193 jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
194#define f38(o,s,u,n) _f38(_jit,o,s,u,n)
195static void _f38(jit_state_t*,jit_int32_t,
196 jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
197/* nulify next instruction if condition is met with addition */
198#define ADD_CF_NV 0 /* never */
199#define ADD_CF_EQ 2 /* O1 == -O2 (word) */
200#define ADD_CF_LT 4 /* O1 < -O2 (signed)*/
201#define ADD_CF_LE 6 /* O1 <= -O2 (signed) */
202#define ADD_CF_NUV 8 /* O1 + O2 does not overflow (unsigned) */
203#define ADD_CF_ZNV 10 /* O1 + O2 is zero or no overflow (unsigned) */
204#define ADD_CF_SV 12 /* O1 + O2 overflows (signed) */
205#define ADD_CF_OD 14 /* O1 + O2 is odd */
206#define ADD_CF_TR 1 /* always */
207#define ADD_CF_NE 3 /* O1 != -O2 */
208#define ADD_CF_GE 5 /* O1 >= -O2 (signed) */
209#define ADD_CF_GT 7 /* O1 > -O2 (signed) */
210#define ADD_CF_UV 9 /* O1 + O2 overflows (unsigned) */
211#define ADD_CF_VNZ 11 /* O1 + O2 is nonzero and overflows (unsigned) */
212#define ADD_CF_NSV 13 /* O1 + O2 does not overflow (signed) */
213#define ADD_CF_EV 15 /* O1 + O2 is even */
214#define ADD_EN_NONE 6 /* none */
215#define ADD_EN_C 7 /* with carry */
216#define ADD_EN_L 10 /* logical */
217#define ADD_EN_TSV 12 /* trap on signed overflow */
218#define ADD_EN_C_TSV 13 /* with carry and trap on signed overflow */
219#define ADDI_OE_TC 0 /* trap on condition */
220#define ADDI_OE_TSV_TC 1 /* trap on signed overflow or condition */
221#define ADDI_OE_NONE 2 /* none */
222#define ADDI_OE_TSV 3 /* trap on signed overflow */
223#define ADD_(en,cf,r1,r2,t) f8(0x2,r2,r1,cf,en>>2,1,en&1,0,0,t)
224#define ADD(r1,r2,t) ADD_(ADD_EN_NONE,ADD_CF_NV,r1,r2,t)
225#define ADD_C(r1,r2,t) ADD_(ADD_EN_C,ADD_CF_NV,r1,r2,t)
226#define ADD_L(r1,r2,t) ADD_(ADD_EN_L,ADD_CF_NV,r1,r2,t)
227#define ADDB_(cc,r1,r2,t) f17(0x28|((cc&1)<<1),r2,r1,cc>>1,t,0)
228#define ADDB(r1,r2,t) ADDB_(ADD_CF_NV,r1,r2,t)
229#define ADDB_EQ(r1,r2,t) ADDB_(ADD_CF_EQ,r1,r2,t)
230#define ADDB_LT(r1,r2,t) ADDB_(ADD_CF_LT,r1,r2,t)
231#define ADDB_LE(r1,r2,t) ADDB_(ADD_CF_LE,r1,r2,t)
232#define ADDB_NUV(r1,r2,t) ADDB_(ADD_CF_NUV,r1,r2,t)
233#define ADDB_ZNV(r1,r2,t) ADDB_(ADD_CF_ZNV,r1,r2,t)
234#define ADDB_SV(r1,r2,t) ADDB_(ADD_CF_SV,r1,r2,t)
235#define ADDB_OD(r1,r2,t) ADDB_(ADD_CF_OD,r1,r2,t)
236#define ADDB_TR(r1,r2,t) ADDB_(ADD_CF_TR,r1,r2,t)
237#define ADDB_NE(r1,r2,t) ADDB_(ADD_CF_NE,r1,r2,t)
238#define ADDB_GE(r1,r2,t) ADDB_(ADD_CF_GE,r1,r2,t)
239#define ADDB_GT(r1,r2,t) ADDB_(ADD_CF_GT,r1,r2,t)
240#define ADDB_UV(r1,r2,t) ADDB_(ADD_CF_UV,r1,r2,t)
241#define ADDB_VNZ(r1,r2,t) ADDB_(ADD_CF_VNZ,r1,r2,t)
242#define ADDB_NSV(r1,r2,t) ADDB_(ADD_CF_NSV,r1,r2,t)
243#define ADDB_EV(r1,r2,t) ADDB_(ADD_CF_EV,r2,r1,t)
244#define ADDB_N_(cc,r1,r2,t) f17(0x28|((cc&1)<<1),r2,r1,cc>>1,t,1)
245#define ADDB_N(r1,r2,t) ADDB_N_(ADD_CF_NV,r1,r2,t)
246#define ADDB_N_EQ(r1,r2,t) ADDB_N_(ADD_CF_EQ,r1,r2,t)
247#define ADDB_N_LT(r1,r2,t) ADDB_N_(ADD_CF_LT,r1,r2,t)
248#define ADDB_N_LE(r1,r2,t) ADDB_N_(ADD_CF_LE,r1,r2,t)
249#define ADDB_N_NUV(r1,r2,t) ADDB_N_(ADD_CF_NUV,r1,r2,t)
250#define ADDB_N_ZNV(r1,r2,t) ADDB_N_(ADD_CF_ZNV,r1,r2,t)
251#define ADDB_N_SV(r1,r2,t) ADDB_N_(ADD_CF_SV,r1,r2,t)
252#define ADDB_N_OD(r1,r2,t) ADDB_N_(ADD_CF_OD,r1,r2,t)
253#define ADDB_N_TR(r1,r2,t) ADDB_N_(ADD_CF_TR,r1,r2,t)
254#define ADDB_N_NE(r1,r2,t) ADDB_N_(ADD_CF_NE,r1,r2,t)
255#define ADDB_N_GE(r1,r2,t) ADDB_N_(ADD_CF_GE,r1,r2,t)
256#define ADDB_N_GT(r1,r2,t) ADDB_N_(ADD_CF_GT,r1,r2,t)
257#define ADDB_N_UV(r1,r2,t) ADDB_N_(ADD_CF_UV,r1,r2,t)
258#define ADDB_N_VNZ(r1,r2,t) ADDB_N_(ADD_CF_VNZ,r1,r2,t)
259#define ADDB_N_NSV(r1,r2,t) ADDB_N_(ADD_CF_NSV,r1,r2,t)
260#define ADDB_N_EV(r1,r2,t) ADDB_N_(ADD_CF_EV,r1,r2,t)
261#define ADDI_(ec,cf,i,r,t) f9(0x2c|(ec>>1),r,t,cf,ec&1,i)
262#define ADDI(i,r,t) ADDI_(ADDI_OE_NONE,ADD_CF_NV,i,r,t)
263#define ADDIB_(cc,i,r,t) f17x(0x29|((cc&1)<<1),r,i,cc>>1,t,0)
264#define ADDIB(i,r,t) ADDIB_(ADD_CF_NV,i,r,t)
265#define ADDIB_EQ(i,r,t) ADDIB_(ADD_CF_EQ,i,r,t)
266#define ADDIB_LT(i,r,t) ADDIB_(ADD_CF_LT,i,r,t)
267#define ADDIB_LE(i,r,t) ADDIB_(ADD_CF_LE,i,r,t)
268#define ADDIB_NUV(i,r,t) ADDIB_(ADD_CF_NUV,i,r,t)
269#define ADDIB_ZNV(i,r,t) ADDIB_(ADD_CF_ZNV,i,r,t)
270#define ADDIB_SV(i,r,t) ADDIB_(ADD_CF_SV,i,r,t)
271#define ADDIB_OD(i,r,t) ADDIB_(ADD_CF_OD,i,r,t)
272#define ADDIB_TR(i,r,t) ADDIB_(ADD_CF_TR,i,r,t)
273#define ADDIB_NE(i,r,t) ADDIB_(ADD_CF_NE,i,r,t)
274#define ADDIB_GE(i,r,t) ADDIB_(ADD_CF_GE,i,r,t)
275#define ADDIB_GT(i,r,t) ADDIB_(ADD_CF_GT,i,r,t)
276#define ADDIB_UV(i,r,t) ADDIB_(ADD_CF_UV,i,r,t)
277#define ADDIB_VNZ(i,r,t) ADDIB_(ADD_CF_VNZ,i,r,t)
278#define ADDIB_NSV(i,r,t) ADDIB_(ADD_CF_NSV,i,r,t)
279#define ADDIB_EV(i,r,t) ADDIB_(ADD_CF_EV,i,r,t)
280#define ADDIB_N_(cc,i,r,t) f17x(0x29|((cc&1)<<1),r,i,cc>>1,t,1)
281#define ADDIB_N(i,r,t) ADDIB_N_(ADD_CF_NV,i,r,t)
282#define ADDIB_N_EQ(i,r,t) ADDIB_N_(ADD_CF_EQ,i,r,t)
283#define ADDIB_N_LT(i,r,t) ADDIB_N_(ADD_CF_LT,i,r,t)
284#define ADDIB_N_LE(i,r,t) ADDIB_N_(ADD_CF_LE,i,r,t)
285#define ADDIB_N_NUV(i,r,t) ADDIB_N_(ADD_CF_NUV,i,r,t)
286#define ADDIB_N_ZNV(i,r,t) ADDIB_N_(ADD_CF_ZNV,i,r,t)
287#define ADDIB_N_SV(i,r,t) ADDIB_N_(ADD_CF_SV,i,r,t)
288#define ADDIB_N_OD(i,r,t) ADDIB_N_(ADD_CF_OD,i,r,t)
289#define ADDIB_N_TR(i,r,t) ADDIB_N_(ADD_CF_TR,i,r,t)
290#define ADDIB_N_NE(i,r,t) ADDIB_N_(ADD_CF_NE,i,r,t)
291#define ADDIB_N_GE(i,r,t) ADDIB_N_(ADD_CF_GE,i,r,t)
292#define ADDIB_N_GT(i,r,t) ADDIB_N_(ADD_CF_GT,i,r,t)
293#define ADDIB_N_UV(i,r,t) ADDIB_N_(ADD_CF_UV,i,r,t)
294#define ADDIB_N_VNZ(i,r,t) ADDIB_N_(ADD_CF_VNZ,i,r,t)
295#define ADDIB_N_NSV(i,r,t) ADDIB_N_(ADD_CF_NSV,i,r,t)
296#define ADDIB_N_EV(i,r,t) ADDIB_N_(ADD_CF_EV,0,i,r,t)
297#define ADDIL(i,r) f7(0xa,r,i)
298#define LOG_CC_NV 0 /* never */
299#define LOG_CC_EQ 1 /* all bits are 0 */
300#define LOG_CC_LT 2 /* leftmost bit is 1 */
301#define LOG_CC_LE 3 /* leftmost bit is 1 or all bits are 0 */
302#define LOG_CC_OD 7 /* rightmost bit is 1 */
303#define LOG_CC_TR 8 /* always */
304#define LOG_CC_NE 9 /* some bits are 1 */
305#define LOG_CC_GE 10 /* leftmost bit is 0 */
306#define LOG_CC_GT 11 /* leftmost bit is 0 or some bits are 1 */
307#define LOG_CC_EV 15 /* rightmost bit is 0 */
308#define AND_(cc,r1,r2,t) f8(0x2,r2,r1,cc,0,1,0,0,0,t)
309#define AND(r1,r2,t) AND_(LOG_CC_NV,r1,r2,t)
310#define ANDCM_(cc,r1,r2,t) f8(0x2,r2,r1,cc,0,0,0,0,0,t)
311#define ANDCM(r1,r2,t) ANDCM_(LOG_CC_NV,r1,r2,t)
312#define B_(n,i,t) f20(0x3a,t,i,0,n)
313#define B(i,t) B_(0,i,t)
314#define B_N(i,t) B_(1,i,t)
315#define B_L(i) B_(0,i,_RP_REGNO)
316#define B_L_N(i) B_(1,i,_RP_REGNO)
317#define BB_CC_LT 0 /* leftmost bit in word is 1 */
318#define BB_CC_GE 1 /* leftmost bit in word is 0 */
319#define BB_(c,r,i) f18(0x30,0,r,c,i,0)
320#define BB_N_(c,r,i) f18(0x30,0,r,c,i,1)
321#define BBI_(c,r,p,i) f18(0x31,p,r,c,i,0)
322#define BBI_N_(c,r,p,i) f18(0x31,p,r,c,i,1)
323#define BB(c,r,i) BB_(c,r,i)
324#define BBI_LT(r,p,i) BBI_(BB_CC_LT,r,p,i)
325#define BBI_GE(r,p,i) BBI_(BB_CC_GE,r,p,i)
326#define BB_N(c,r,i) BB_(c,r,i)
327#define BBI_N_LT(r,p,i) BBI_N_(BB_CC_LT,r,p,i)
328#define BBI_N_GE(r,p,i) BBI_N_(BB_CC_GE,r,p,i)
329#define BE(i,s,b) f19(0x38,b,s,i,0)
330#define BE_L(i,s,b) f19(0x39,b,s,i,0)
331#define BE_L_N(i,s,b) f19(0x39,b,s,i,1)
332#define BLR(x,t) f21(0x3a,t,x,2,0)
333#define BLR_N(x,t) f21(0x3a,t,x,2,1)
334#define BREAK(i,j) f27(0,j,i)
335#define BV(x,b) f21(0x3a,b,x,6,0)
336#define BV_N(x,b) f21(0x3a,b,x,6,1)
337#define BVE(b) f22(0x3a,b,6,0,0,0)
338#define BVE_N(b) f22(0x3a,b,6,0,1,0)
339#define BVE_L(b) f22(0x3a,b,7,0,0,0)
340#define BVE_L_N(b) f22(0x3a,b,7,0,0,1)
341#define II_C_NONE 0
342#define II_C_M (1<<5)
343#define II_C_S (1<<13)
344#define II_C_SM (II_C_S|II_C_M)
345#define II_AU_NONE 0
346#define II_AU_PRE ((1<<13)|II_C_M)
347#define II_AU_POS II_C_M
348#define LD_CC_H_NONE 0 /* No hint */
349#define LD_CC_H_SPL 2 /* Spatial Locality */
350#define CLRBTS() f23(0x3a,0,0,2,0,0,1,0,1)
351#define CS_CC_NV 0 /* never */
352#define CS_CC_EQ 2 /* O1 = O2 */
353#define CS_CC_LT 4 /* O1 < O2 (signed) */
354#define CS_CC_LE 6 /* O1 <= O2 (signed) */
355#define CS_CC_ULT 8 /* O1 < O2 (unsigned) */
356#define CS_CC_ULE 10 /* O1 <= O2 (unsigned) */
357#define CS_CC_SV 12 /* O1 - O2 overflows (signed) */
358#define CS_CC_OD 14 /* O1 - O2 is odd */
359#define CS_CC_TR 1 /* always */
360#define CS_CC_NE 3 /* O1 != O2 */
361#define CS_CC_GE 5 /* O1 >= O2 (signed) */
362#define CS_CC_GT 7 /* O1 > O2 (signed) */
363#define CS_CC_UGE 9 /* O1 >= O2 (unsigned) */
364#define CS_CC_UGT 11 /* O1 > O2 (unsigned) */
365#define CS_CC_NSV 13 /* O1 - O2 does not overflows (signed) */
366#define CS_CC_EV 15 /* O1 - O2 is even */
367#define CMPB_(c,r1,r2,i) f17((c)&1?0x22:0x20,r2,r1,(c)>>1,i,0)
368#define CMPB(r1,r2,i) CMPB_(CS_CC_NV,r1,r2,i)
369#define CMPB_EQ(r1,r2,i) CMPB_(CS_CC_EQ,r1,r2,i)
370#define CMPB_LT(r1,r2,i) CMPB_(CS_CC_LT,r1,r2,i)
371#define CMPB_LE(r1,r2,i) CMPB_(CS_CC_LE,r1,r2,i)
372#define CMPB_ULT(r1,r2,i) CMPB_(CS_CC_ULT,r1,r2,i)
373#define CMPB_ULE(r1,r2,i) CMPB_(CS_CC_ULE,r1,r2,i)
374#define CMPB_SV(r1,r2,i) CMPB_(CS_CC_SV,r1,r2,i)
375#define CMPB_OD(r1,r2,i) CMPB_(CS_CC_OD,r1,r2,i)
376#define CMPB_TR(r1,r2,i) CMPB_(CS_CC_TR,r1,r2,i)
377#define CMPB_NE(r1,r2,i) CMPB_(CS_CC_NE,r1,r2,i)
378#define CMPB_GE(r1,r2,i) CMPB_(CS_CC_GE,r1,r2,i)
379#define CMPB_GT(r1,r2,i) CMPB_(CS_CC_GT,r1,r2,i)
380#define CMPB_UGE(r1,r2,i) CMPB_(CS_CC_UGE,r1,r2,i)
381#define CMPB_UGT(r1,r2,i) CMPB_(CS_CC_UGT,r1,r2,i)
382#define CMPB_NSV(r1,r2,i) CMPB_(CS_CC_NSV,r1,r2,i)
383#define CMPB_EV(r1,r2,i) CMPB_(CS_CC_EV,r1,r2,i)
384#define CMPB_N_(c,r1,r2,i) f17((c)&1?0x22:0x20,r2,r1,(c)>>1,i,1)
385#define CMPB_N(r1,r2,i) CMPB_N_(CS_CC_NV,r1,r2,i)
386#define CMPB_EQ_N(r1,r2,i) CMPB_N_(CS_CC_EQ,r1,r2,i)
387#define CMPB_LT_N(r1,r2,i) CMPB_N_(CS_CC_LT,r1,r2,i)
388#define CMPB_LE_N(r1,r2,i) CMPB_N_(CS_CC_LE,r1,r2,i)
389#define CMPB_ULT_N(r1,r2,i) CMPB_N_(CS_CC_ULT,r1,r2,i)
390#define CMPB_ULE_N(r1,r2,i) CMPB_N_(CS_CC_ULE,r1,r2,i)
391#define CMPB_SV_N(r1,r2,i) CMPB_N_(CS_CC_SV,r1,r2,i)
392#define CMPB_OD_N(r1,r2,i) CMPB_N_(CS_CC_OD,r1,r2,i)
393#define CMPB_TR_N(r1,r2,i) CMPB_N_(CS_CC_TR,r1,r2,i)
394#define CMPB_NE_N(r1,r2,i) CMPB_N_(CS_CC_NE,r1,r2,i)
395#define CMPB_GE_N(r1,r2,i) CMPB_N_(CS_CC_GE,r1,r2,i)
396#define CMPB_GT_N(r1,r2,i) CMPB_N_(CS_CC_GT,r1,r2,i)
397#define CMPB_UGE_N(r1,r2,i) CMPB_N_(CS_CC_UGE,r1,r2,i)
398#define CMPB_UGT_N(r1,r2,i) CMPB_N_(CS_CC_UGT,r1,r2,i)
399#define CMPB_NSV_N(r1,r2,i) CMPB_N_(CS_CC_NSV,r1,r2,i)
400#define CMPB_EV_N(r1,r2,i) CMPB_N_(CS_CC_EV,r1,r2,i)
401#define CMPCLR_(c,r1,r2,i) f8(0x2,r2,r1,c,2,0,0,2,0,i)
402#define CMPCLR(r1,r2,i) CMPCLR_(CS_CC_NV,r1,r2,i)
403#define CMPCLR_EQ(r1,r2,i) CMPCLR_(CS_CC_EQ,r1,r2,i)
404#define CMPCLR_LT(r1,r2,i) CMPCLR_(CS_CC_LT,r1,r2,i)
405#define CMPCLR_LE(r1,r2,i) CMPCLR_(CS_CC_LE,r1,r2,i)
406#define CMPCLR_ULT(r1,r2,i) CMPCLR_(CS_CC_ULT,r1,r2,i)
407#define CMPCLR_ULE(r1,r2,i) CMPCLR_(CS_CC_ULE,r1,r2,i)
408#define CMPCLR_SV(r1,r2,i) CMPCLR_(CS_CC_SV,r1,r2,i)
409#define CMPCLR_OD(r1,r2,i) CMPCLR_(CS_CC_OD,r1,r2,i)
410#define CMPCLR_TR(r1,r2,i) CMPCLR_(CS_CC_TR,r1,r2,i)
411#define CMPCLR_NE(r1,r2,i) CMPCLR_(CS_CC_NE,r1,r2,i)
412#define CMPCLR_GE(r1,r2,i) CMPCLR_(CS_CC_GE,r1,r2,i)
413#define CMPCLR_GT(r1,r2,i) CMPCLR_(CS_CC_GT,r1,r2,i)
414#define CMPCLR_UGE(r1,r2,i) CMPCLR_(CS_CC_UGE,r1,r2,i)
415#define CMPCLR_UGT(r1,r2,i) CMPCLR_(CS_CC_UGT,r1,r2,i)
416#define CMPCLR_NSV(r1,r2,i) CMPCLR_(CS_CC_NSV,r1,r2,i)
417#define CMPCLR_EV(r1,r2,i) CMPCLR_(CS_CC_EV,r1,r2,i)
418#define CMPIB_(c,i,r,t) f17x((c)&1?0x23:0x21,r,i,(c)>>1,t,0)
419#define CMPIB_NONE(i,r,t) CMPIB_(CS_CC_NV,i,r,t)
420#define CMPIB_EQ(i,r,t) CMPIB_(CS_CC_EQ,i,r,t)
421#define CMPIB_LT(i,r,t) CMPIB_(CS_CC_LT,i,r,t)
422#define CMPIB_LE(i,r,t) CMPIB_(CS_CC_LE,i,r,t)
423#define CMPIB_ULT(i,r,t) CMPIB_(CS_CC_ULT,i,r,t)
424#define CMPIB_ULE(i,r,t) CMPIB_(CS_CC_ULE,i,r,t)
425#define CMPIB_SV(i,r,t) CMPIB_(CS_CC_SV,i,r,t)
426#define CMPIB_OD(i,r,t) CMPIB_(CS_CC_OD,i,r,t)
427#define CMPIB(i,r,t) CMPIB_(CS_CC_TR,i,r,t)
428#define CMPIB_NE(i,r,t) CMPIB_(CS_CC_NE,i,r,t)
429#define CMPIB_GE(i,r,t) CMPIB_(CS_CC_GE,i,r,t)
430#define CMPIB_GT(i,r,t) CMPIB_(CS_CC_GT,i,r,t)
431#define CMPIB_UGE(i,r,t) CMPIB_(CS_CC_UGE,i,r,t)
432#define CMPIB_UGT(i,r,t) CMPIB_(CS_CC_UGT,i,r,t)
433#define CMPIB_NSV(i,r,t) CMPIB_(CS_CC_NSV,i,r,t)
434#define CMPIB_EV(i,r,t) CMPIB_(CS_CC_EV,i,r,t)
435#define CMPIB_N_(c,i,r,t) f17x((c)&1?0x23:0x21,r,i,(c)>>1,t,1)
436#define CMPIB_NONE_N(i,r,t) CMPIB_N_(CS_CC_NV,i,r,t)
437#define CMPIB_EQ_N(i,r,t) CMPIB_N_(CS_CC_EQ,i,r,t)
438#define CMPIB_LT_N(i,r,t) CMPIB_N_(CS_CC_LT,i,r,t)
439#define CMPIB_LE_N(i,r,t) CMPIB_N_(CS_CC_LE,i,r,t)
440#define CMPIB_ULT_N(i,r,t) CMPIB_N_(CS_CC_ULT,i,r,t)
441#define CMPIB_ULE_N(i,r,t) CMPIB_N_(CS_CC_ULE,i,r,t)
442#define CMPIB_SV_N(i,r,t) CMPIB_N_(CS_CC_SV,i,r,t)
443#define CMPIB_OD_N(i,r,t) CMPIB_N_(CS_CC_OD,i,r,t)
444#define CMPIB_N(i,r,t) CMPIB_N_(CS_CC_TR,i,r,t)
445#define CMPIB_NE_N(i,r,t) CMPIB_N_(CS_CC_NE,i,r,t)
446#define CMPIB_GE_N(i,r,t) CMPIB_N_(CS_CC_GE,i,r,t)
447#define CMPIB_GT_N(i,r,t) CMPIB_N_(CS_CC_GT,i,r,t)
448#define CMPIB_UGE_N(i,r,t) CMPIB_N_(CS_CC_UGE,i,r,t)
449#define CMPIB_UGT_N(i,r,t) CMPIB_N_(CS_CC_UGT,i,r,t)
450#define CMPIB_NSV_N(i,r,t) CMPIB_N_(CS_CC_NSV,i,r,t)
451#define CMPIB_EV_N(i,r,t) CMPIB_N_(CS_CC_EV,i,r,t)
452#define CMPICLR_(c,i,r,t) f9(0x24,r,t,c,0,i)
453#define CMPICLR(i,r,t) CMPICLR_(CS_CC_NV,i,r,t)
454#define CMPICLR_EQ(i,r,t) CMPICLR_(CS_CC_EQ,i,r,t)
455#define CMPICLR_LT(i,r,t) CMPICLR_(CS_CC_LT,i,r,t)
456#define CMPICLR_LE(i,r,t) CMPICLR_(CS_CC_LE,i,r,t)
457#define CMPICLR_ULT(i,r,t) CMPICLR_(CS_CC_ULT,i,r,t)
458#define CMPICLR_ULE(i,r,t) CMPICLR_(CS_CC_ULE,i,r,t)
459#define CMPICLR_SV(i,r,t) CMPICLR_(CS_CC_SV,i,r,t)
460#define CMPICLR_OD(i,r,t) CMPICLR_(CS_CC_OD,i,r,t)
461#define CMPICLR_TR(i,r,t) CMPICLR_(CS_CC_TR,i,r,t)
462#define CMPICLR_NE(i,r,t) CMPICLR_(CS_CC_NE,i,r,t)
463#define CMPICLR_GE(i,r,t) CMPICLR_(CS_CC_GE,i,r,t)
464#define CMPICLR_GT(i,r,t) CMPICLR_(CS_CC_GT,i,r,t)
465#define CMPICLR_UGE(i,r,t) CMPICLR_(CS_CC_UGE,i,r,t)
466#define CMPICLR_UGT(i,r,t) CMPICLR_(CS_CC_UGT,i,r,t)
467#define CMPICLR_NSV(i,r,t) CMPICLR_(CS_CC_NSV,i,r,t)
468#define CMPICLR_EV(i,r,t) CMPICLR_(CS_CC_EV,i,r,t)
469#define COPR(u,s) f38(0x0c,s,u,0)
470#define UI_CF_NONE 0 /* never */
471#define UI_CF_SBZ 2 /* some byte zero */
472#define UI_CF_SHZ 3 /* some halfword zero */
473#define UI_CF_SDC 4 /* some digit carry */
474#define UI_CF_SBC 6 /* some byte carry */
475#define UI_CF_SHC 7 /* some halfword carry */
476#define UI_TR_SHC 8 /* always */
477#define UI_CF_NBZ 10 /* no byte zero */
478#define UI_CF_NHZ 11 /* no halfword zero */
479#define UI_CF_NDC 12 /* no digit carry */
480#define UI_CF_NBC 14 /* no byte carry */
481#define UI_CF_NHC 15 /* no halfword carry */
482#define DCOR_(e1,cf,r,t) f8(0x2,r,0,cf,2,1,1,e1,0,t)
483#define DCOR(r,t) DCOR_(2,UI_CF_NONE,r,t)
484#define DCOR_I(r,t) DCOR_(3,UI_CF_NONE,r,t)
485#define SED_C_NEVER 0 /* never */
486#define SED_C_EQ 1 /* all bits 0 */
487#define SED_C_LT 2 /* lefmost bits 1 */
488#define SED_C_OD 3 /* rightmost bit 1 */
489#define SED_C_TR 4 /* always */
490#define SED_C_NE 5 /* some bit 1 */
491#define SED_C_GE 6 /* lefmost bits 1 */
492#define SED_C_EV 7 /* rightmost bit 0 */
493#define DEPW(r,len,t) f13(0x35,t,r,SED_C_NEVER,0,1,0,len)
494#define DEPW_Z(r,len,t) f13(0x35,t,r,SED_C_NEVER,0,0,0,len)
495#define DEPWR(r,pos,len,t) f16(0x35,t,r,SED_C_NEVER,0,1,1,31-(pos),len)
496#define DEPWR_Z(r,pos,len,t) f16(0x35,t,r,SED_C_NEVER,0,1,0,31-(pos),len)
497#define SHLWI(r,sa,t) DEPWR_Z(r,31-(sa),32-(sa),t)
498#define DEPWI(i,len,t) f13x(0x35,t,i,SED_C_NEVER,2,1,0,len)
499#define DEPWI_Z(i,len,t) f13x(0x35,t,i,SED_C_NEVER,2,0,0,len)
500#define DEPWRI(i,pos,len,t) f16x(0x35,t,i,SED_C_NEVER,1,1,1,31-(pos),len)
501#define DEPWRI_Z(i,pos,len,t) f16x(0x35,t,i,SED_C_NEVER,1,1,0,31-(pos),len)
502#define DIAG(i) f28(0x5,i)
503#define DS(r1,r2,t) f8(0x2,r2,r1,ADD_CF_NV,1,0,0,1,0,t)
504#define EXTRW(r,len,t) f12(0x34,r,t,SED_C_NEVER,2,1,0,0,0,len)
505#define EXTRW_U(r,len,t) f12(0x34,r,t,SED_C_NEVER,2,0,0,0,0,len)
506#define EXTRWR(r,pos,len,t) f15(0x34,r,t,SED_C_NEVER,1,1,1,pos,len)
507#define SHRWI(r,sa,t) EXTRWR(r,31-(sa),32-(sa),t)
508#define EXTRWR_U(r,pos,len,t) f15(0x34,r,t,SED_C_NEVER,1,1,0,pos,len)
509#define SHRWI_U(r,sa,t) EXTRWR_U(r,31-(sa),32-(sa),t)
510#define FDC(x,s,b) f24(0x1,b,x,s,0x4a,0,0)
511#define FDC_M(x,s,b) f24(0x1,b,x,s,0x4a,1,0)
512#define FDCI(i,s,b) f25(0x1,b,i,s,0xca,0,0)
513#define FDCE(x,s,b) f24(0x1,b,x,s,0x4b,0,0)
514#define FDCE_M(x,s,b) f24(0x1,b,x,s,0x4b,1,0)
515#define FIC(x,s,b) f26(0x1,b,x,s,0xa,0,0)
516#define FIC_M(x,s,b) f26(0x1,b,x,s,0xa,1,0)
517#define FICI(x,s,b) f25(0x1,b,x,s,0x4f,0,0)
518#define FICI_M(x,s,b) f25(0x1,b,x,s,0x4f,1,0)
519#define FICE(x,s,b) f26(0x1,b,x,s,0xb,0,0)
520#define FICE_M(x,s,b) f26(0x1,b,x,s,0xb,1,0)
521#define HADD_(c,r1,r2,t) f8(0x2,r2,r1,0,0,1,1,c,0,t)
522#define HADD(r1,r2,t) HADD_(3,r1,r2,t)
523#define HADD_SS(r1,r2,t) HADD_(1,r1,r2,t)
524#define HADD_US(r1,r2,t) HADD_(0,r1,r2,t)
525#define HAVG(r1,r2,t) f8(0x2,r2,r1,0,0,1,0,3,0,t)
526#define HSHL(r,sa,t) f10(0x3e,0,r,1,0,0,2,sa,0,t)
527#define HSHLADD(r1,sa,r2,t) f8(0x2,r2,r1,0,1,1,1,sa,0,t)
528#define HSHR(r,sa,t) f10(0x3e,r,0,1,2,0,3,sa,0,t)
529#define HSHR_U(r,sa,t) f10(0x3e,r,0,1,2,0,2,sa,0,t)
530#define HSHRADD(r1,sa,r2,t) f8(0x2,r2,r1,0,1,0,1,sa,0,t)
531#define HSUB_(c,r1,r2,t) f8(0x2,r2,r1,0,0,0,1,c,0,t)
532#define HSUB(r1,r2,t) HSUB_(3,r1,r2,t)
533#define HSUB_SS(r1,r2,t) HSUB_(1,r1,r2,t)
534#define HSUB_US(r1,r2,t) HSUB_(0,r1,r2,t)
535#define IDTLBT(r1,r2) f26(0x1,r2,r1,0,0x60,0,0)
536#define IITLBT(r1,r2) f26(0x1,r2,r1,0,0x20,0,0)
537#define LCI(x,s,b,t) f24(0x1,b,x,s,0x4c,0,t)
538#define LDBL(i,b,t) f1(0x10,b,t,i)
539#define LDB(x,b,t) f4(0x3,b,x,0,0,0,LD_CC_H_NONE,0,0,t)
540#define LDBI(i,b,t) f5(0x3,b,i,0,0,1,LD_CC_H_NONE,0,0,t)
541#define LDCD(x,b,t) f4(0x3,b,x,0,0,0,LD_CC_H_NONE,5,0,t)
542#define LDCDI(i,b,t) f5(0x3,b,i,0,0,1,LD_CC_H_NONE,5,0,t)
543#define LDCW(x,b,t) f4(0x3,b,x,0,0,0,LD_CC_H_NONE,7,0,t)
544#define LDCWI(i,b,t) f5(0x3,b,i,0,0,1,LD_CC_H_NONE,7,0,t)
545#define LDDL(i,b,t) f3(0x14,b,t,i,0)
546#define LDD(x,b,t) f4(0x3,b,x,0,0,0,LD_CC_H_NONE,3,0,t)
547#define LDDI(i,b,t) f5(0x3,b,i,0,0,1,LD_CC_H_NONE,3,0,t)
548#define LDDA(x,b,t) f4(0x3,b,x,0,0,0,LD_CC_H_NONE,4,0,t)
549#define LDDAI(i,b,t) f5(0x3,b,i,0,0,1,LD_CC_H_NONE,4,0,t)
550#define LDHL(i,b,t) f1(0x11,b,t,i)
551#define LDH(x,b,t) f4(0x3,b,x,0,0,0,LD_CC_H_NONE,1,0,t)
552#define LDHI(i,b,t) f5(0x3,b,i,0,0,1,LD_CC_H_NONE,1,0,t)
553#define LDIL(i,t) f7(0x8,t,i)
554#define LDO(i,b,t) f1(0xd,b,t,i)
555#define LDI(i,t) LDO(i,0,t)
556#define LDSID(s,b,t) f30(0x0,b,0,s,0,0x85,t)
557#define LDWL(i,b,t) f1(0x12,b,t,i)
558#define LDWL_MB(i,b,t) f1(0x13,b,t,i) /* pre-dec or post-inc */
559#define LDWL_MA(i,b,t) f2(0x17,b,t,i,2)/* post-dec or pre-inc */
560#define LDW(x,b,t) f4(0x3,b,x,0,0,0,LD_CC_H_NONE,2,0,t)
561#define LDWI(i,b,t) f5(0x3,b,i,0,0,1,LD_CC_H_NONE,2,0,t)
562#define LDWA(x,b,t) f4(0x3,b,x,0,0,0,LD_CC_H_NONE,6,0,t)
563#define LDWAI(i,b,t) f5(0x3,b,i,0,0,1,LD_CC_H_NONE,6,0,t)
564#define LPA(x,s,b,t) f24(0x1,b,x,s,0x4d,0,t)
565#define MFSP(s,t) f29(0x0,0,0,s,0x25,t)
566#define MIXH_L(r1,r2,t) f10(0x3e,r2,r1,1,0,0,1,0,0,t)
567#define MIXH_R(r1,r2,t) f10(0x3e,r2,r1,1,2,0,1,0,0,t)
568#define MIXW_L(r1,r2,t) f10(0x3e,r2,r1,1,0,0,0,0,0,t)
569#define MIXW_R(r1,r2,t) f10(0x3e,r2,r1,1,2,0,0,0,0,t)
570#define MOVB_(c,r1,r2,i) f17(0x32,r2,r1,c,i,0)
571#define MOVB(r1,r2,i) MOVB_(SED_C_NEVER,r1,r2,i)
572#define MOVB_EQ(r1,r2,i) MOVB_(SED_C_EQ,r1,r2,i)
573#define MOVB_LT(r1,r2,i) MOVB_(SED_C_LT,r1,r2,i)
574#define MOVB_OD(r1,r2,i) MOVB_(SED_C_OD,r1,r2,i)
575#define MOVB_TR(r1,r2,i) MOVB_(SED_C_TR,r1,r2,i)
576#define MOVB_NE(r1,r2,i) MOVB_(SED_C_NE,r1,r2,i)
577#define MOVB_GE(r1,r2,i) MOVB_(SED_C_GE,r1,r2,i)
578#define MOVB_EV(r1,r2,i) MOVB_(SED_C_EV,r1,r2,i)
579#define MOVIB_(c,r,i,t) f17x(0x33,r,i,c,t,0)
580#define MOVIB(i,r,t) MOVIB_(SED_C_NEVER,i,r,t)
581#define MOVIB_EQ(i,r,t) MOVIB_(SED_C_EQ,i,r,t)
582#define MOVIB_LT(i,r,t) MOVIB_(SED_C_LT,i,r,t)
583#define MOVIB_OD(i,r,t) MOVIB_(SED_C_OD,i,r,t)
584#define MOVIB_TR(i,r,t) MOVIB_(SED_C_TR,i,r,t)
585#define MOVIB_NE(i,r,t) MOVIB_(SED_C_NE,i,r,t)
586#define MOVIB_GE(i,r,t) MOVIB_(SED_C_GE,i,r,t)
587#define MOVIB_EV(i,r,t) MOVIB_(SED_C_EV,i,r,t)
588#define MTCTL(r,t) f31(0x0,t,r,0,0xc2,0)
589#define MTSAR(r) MTCTL(r,_CR11_REGNO)
590#define MTSARCM(r) f31(0x0,0xb,r,0,0xc6,0)
591#define MTSM(r) f33(0x0,0,r,0,0xc3,0)
592#define MTSP(r,s) f29(0x0,0,r,s,0xc1,0)
593#define OR_(c,r1,r2,t) f8(0x2,r2,r1,c,0,1,0,1,0,t)
594#define OR(r1,r2,t) OR_(LOG_CC_NV,r1,r2,t)
595#define NOP() OR(_R0_REGNO,_R0_REGNO,_R0_REGNO)
596#define COPY(r,t) OR(r,0,t)
597#define PDC(x,s,b) f24(0x1,b,x,s,0x4e,0,0)
598#define PDTLB(x,s,b) f24(0x1,b,x,s,0x48,0,0)
599#define PDTLB_L(x,s,b) f24(0x1,b,x,s,0x58,0,0)
600#define PDTLBE(x,s,b) f24(0x1,b,x,s,0x49,0,0)
601#define PERMH(c,r,t) f10(0x3e,r,r,0,(c)&3,0,((c)>>2)&3,(((c)>>2)&6)|(((c)>>6)&3),0,t)
602#define PITBL(x,s,b) f26(0x1,b,x,s,0x08,0,0)
603#define PITBL_L(x,s,b) f26(0x1,b,x,s,0x18,0,0)
604#define PITBLE(x,s,b) f26(0x1,b,x,s,0x09,0,0)
605#define POPBTS(i) f23(0x3a,0,0,2,0,i,1,0,1)
606#define PROBE_R(s,b,r,t) f24(0x1,b,r,s,0x46,0,t)
607#define PROBE_W(s,b,r,t) f24(0x1,b,r,s,0x47,0,t)
608#define PROBEI_R(s,b,i,t) f24(0x1,b,i,s,0x46,0,t)
609#define PROBEI_W(s,b,i,t) f24(0x1,b,i,s,0x47,0,t)
610#define PUSHBTS(r) f23(0x3a,0,r,2,0,0,0,0,1)
611#define PUSHNOM() f23(0x3a,0,0,2,0,0,0,0,1)
612#define RFI() f33(0x0,0,0,0,0x60,0)
613#define RFI_R() f33(0x0,0,0,0,0x65,0)
614#define RSM(i,t) f33(0x0,((i)&0x3e0)>>5,(i)&0x1f,0,0x73,t)
615#define SHLADD_(e,cf,r1,sa,r2,t) f8(0x2,r2,r1,cf,e,1,0,sa,0,t)
616#define SHLADD(r1,sa,r2,t) SHLADD_(1,ADD_CF_NV,r1,sa,r2,t)
617#define SHLADD_L(r1,sa,r2,t) SHLADD_(2,ADD_CF_NV,r1,sa,r2,t)
618#define SHLADD_TSV(r1,sa,r2,t) SHLADD_(3,ADD_CF_NV,r1,sa,r2,t)
619#define SHRPD(r1,r2,t) f11(0x34,r2,r1,SED_C_NEVER,0,0,1,0,t)
620#define SHRPDI(r1,r2,sa,t) f14(0x34,r2,r1,SED_C_NEVER,0,(63-(sa))>>5,1,(63-(sa))&0x1f,t)
621#define SHRPW(r1,r2,t) f11(0x34,r2,r1,SED_C_NEVER,0,0,0,0,t)
622#define SHRPWI(r1,r2,sa,t) f14(0x34,r2,r1,SED_C_NEVER,0,1,0,31-(sa),t)
623#define SPOP0(sf,so) f34(0x4,(so)>>5,0,sf,0,(so)&0x1f)
624#define SPOP1(sf,so,t) f35(0x4,so,1,sf,0,t)
625#define SPOP2(sf,so,r) f36(0x4,r,(so)>>5,2,sf,0,(so)&0x1f)
626#define SPOP3(sf,so,r1,r2) f37(0x4,r2,r1,(so)>>5,3,sf,0,(so)&0x1f)
627#define SSM(i,t) f33(0x00,(i)>>5,(i)&0x1f,0,0x6b,t)
628#define STBL(r,i,b) f1(0x18,b,r,i)
629#define STBI(r,i,b) f6(0x3,b,r,0,0,1,LD_CC_H_NONE,0x8,0,i)
630#define STDL(r,i,b) f3(0x1c,b,r,i,0)
631#define STDI(r,i,b) f6(0x3,b,r,0,0,1,LD_CC_H_NONE,0xc,0,i)
632#define STDA(r,i,b) f6(0x3,b,r,0,0,1,LD_CC_H_NONE,0xf,0,i)
633#define STHL(r,i,b) f1(0x19,b,r,i)
634#define STHI(r,i,b) f6(0x3,b,r,0,0,1,LD_CC_H_NONE,0x9,0,i)
635#define STWL(r,i,b) f1(0x1a,b,r,i)
636#define STWL_MA(r,i,b) f1(0x1b,b,r,i) /* pre-dec or post-inc */
637#define STWL_MB(r,i,b) f2(0x1f,b,r,i,2)/* post-dec or pre-inc */
638#define STWI(r,i,b) f6(0x3,b,r,0,0,1,LD_CC_H_NONE,0xa,0,i)
639#define STWA(r,i,b) f6(0x3,b,r,0,0,1,LD_CC_H_NONE,0xe,0,i)
640#define SUB_(e1,e2,cf,r1,r2,t) f8(0x2,r2,r1,cf,e1,0,e2,0,0,t)
641#define SUB(r1,r2,t) SUB_(1,0,CS_CC_NV,r1,r2,t)
642#define SUB_B(r1,r2,t) SUB_(1,1,CS_CC_NV,r1,r2,t)
643#define SUB_SV(r1,r2,t) SUB_(1,0,CS_CC_SV,r1,r2,t)
644#define SUB_NSV(r1,r2,t) SUB_(1,0,CS_CC_NSV,r1,r2,t)
645/* actually, rsbi */
646#define SUBI_(e1,cf,i,r,t) f9(0x25,r,t,cf,e1,i)
647#define SUBI(i,r,t) SUBI_(0,ADD_CF_NV,i,r,t)
648#define SYNC() f33(0x0,0,0,0,0x20,0)
649#define SYNCDMA() f33(0x0,0,1<<4,0,0x20,0)
650#define UADDCM(r1,r2,t) f8(0x2,r2,r1,ADD_CF_NV,2,0,1,2,0,t)
651#define UXOR(r1,r2,t) f8(0x2,r2,r1,LOG_CC_NV,0,1,1,2,0,t)
652#define XOR(r1,r2,t) f8(0x2,r2,r1,LOG_CC_NV,0,1,0,2,0,t)
653# define nop(c) _nop(_jit,c)
654static void _nop(jit_state_t*,jit_int32_t);
655#define movr(r0,r1) _movr(_jit,r0,r1)
656static void _movr(jit_state_t*,jit_int32_t,jit_int32_t);
657#define movi(r0,i0) _movi(_jit,r0,i0)
658static void _movi(jit_state_t*,jit_int32_t,jit_word_t);
659#define movi_p(r0,i0) _movi_p(_jit,r0,i0)
660static jit_word_t _movi_p(jit_state_t*,jit_int32_t,jit_word_t);
79bfeef6
PC		 661# define bswapr_us(r0, r1) _bswapr_us(_jit, r0, r1)
662static void _bswapr_us(jit_state_t*,jit_int32_t,jit_int32_t);
663# define bswapr_ui(r0, r1) _bswapr_ui(_jit, r0, r1)
664static void _bswapr_ui(jit_state_t*,jit_int32_t,jit_int32_t);
40a44dcb
PC		 665# define movnr(r0,r1,r2) _movnr(_jit,r0,r1,r2)
666static void _movnr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
667# define movzr(r0,r1,r2) _movzr(_jit,r0,r1,r2)
668static void _movzr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
ba3814c1
PC		 669# define casx(r0, r1, r2, r3, i0) _casx(_jit, r0, r1, r2, r3, i0)
670static void _casx(jit_state_t *_jit,jit_int32_t,jit_int32_t,
671 jit_int32_t,jit_int32_t,jit_word_t);
672#define casr(r0, r1, r2, r3) casx(r0, r1, r2, r3, 0)
673#define casi(r0, i0, r1, r2) casx(r0, _NOREG, r1, r2, i0)
4a71579b
PC		 674#define comr(r0,r1) UADDCM(_R0_REGNO,r1,r0)
675#define negr(r0,r1) SUB(_R0_REGNO,r1,r0)
ba86ff93
PC		 676#define extr(r0,r1,i0,i1) _extr(_jit,r0,r1,i0,i1)
677static void _extr(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t,jit_word_t);
678#define extr_u(r0,r1,i0,i1) _extr_u(_jit,r0,r1,i0,i1)
679static void _extr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t,jit_word_t);
680#define depr(r0,r1,i0,i1) _depr(_jit,r0,r1,i0,i1)
681static void _depr(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t,jit_word_t);
4a71579b
PC		 682#define extr_c(r0,r1) EXTRWR(r1,31,8,r0)
683#define extr_uc(r0,r1) EXTRWR_U(r1,31,8,r0)
684#define extr_s(r0,r1) EXTRWR(r1,31,16,r0)
685#define extr_us(r0,r1) EXTRWR_U(r1,31,16,r0)
4a71579b
PC		 686#define addr(r0,r1,r2) ADD(r1,r2,r0)
687#define addi(r0,r1,i0) _addi(_jit,r0,r1,i0)
688static void _addi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
689#define addcr(r0,r1,r2) addr(r0,r1,r2)
690#define addci(r0,r1,i0) _addci(_jit,r0,r1,i0)
691static void _addci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
692#define addxr(r0,r1,r2) ADD_C(r1,r2,r0)
693#define addxi(r0,r1,i0) _addxi(_jit,r0,r1,i0)
694static void _addxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
695#define subr(r0,r1,r2) SUB(r1,r2,r0)
696#define subi(r0,r1,i0) _subi(_jit,r0,r1,i0)
697static void _subi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
698#define subcr(r0,r1,r2) subr(r0,r1,r2)
699#define subci(r0,r1,i0) _subci(_jit,r0,r1,i0)
700static void _subci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
701#define subxr(r0,r1,r2) SUB_B(r1,r2,r0)
702#define subxi(r0,r1,i0) _subxi(_jit,r0,r1,i0)
703static void _subxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
704#define rsbi(r0, r1, i0) _rsbi(_jit, r0, r1, i0)
705static void _rsbi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
706#define mulr(r0,r1,r2) _mulr(_jit,r0,r1,r2)
707static void _mulr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
708#define muli(r0,r1,i0) _muli(_jit,r0,r1,i0)
709static void _muli(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
ba86ff93
PC		 710#define hmulr(r0, r1, r2) qmulr(JIT_NOREG, r0, r1, r2)
711#define hmuli(r0, r1, i0) qmuli(JIT_NOREG, r0, r1, i0)
712#define hmulr_u(r0, r1, r2) qmulr_u(JIT_NOREG, r0, r1, r2)
713#define hmuli_u(r0, r1, i0) qmuli_u(JIT_NOREG, r0, r1, i0)
4a71579b
PC		 714static long long __llmul(int, int);
715#define qmulr(r0,r1,r2,r3) _qmulr(_jit,r0,r1,r2,r3)
716static void _qmulr(jit_state_t*,
717 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
718#define qmuli(r0,r1,r2,i0) _qmuli(_jit,r0,r1,r2,i0)
719static void _qmuli(jit_state_t*,
720 jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
721#define qmulr_u(r0,r1,r2,r3) _qmulr_u(_jit,r0,r1,r2,r3)
722static void _qmulr_u(jit_state_t*,
723 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
724#define qmuli_u(r0,r1,r2,i0) _qmuli_u(_jit,r0,r1,r2,i0)
725static void _qmuli_u(jit_state_t*,
726 jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
727static int __idiv(int, int);
728#define divr(r0,r1,r2) _divr(_jit,r0,r1,r2)
729static void _divr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
730#define divi(r0,r1,i0) _divi(_jit,r0,r1,i0)
731static void _divi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
732static unsigned int __udiv(unsigned int, unsigned int);
733#define divr_u(r0,r1,r2) _divr_u(_jit,r0,r1,r2)
734static void _divr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
735#define divi_u(r0,r1,i0) _divi_u(_jit,r0,r1,i0)
736static void _divi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
737static int __irem(int, int);
738#define remr(r0,r1,r2) _remr(_jit,r0,r1,r2)
739static void _remr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
740#define remi(r0,r1,i0) _remi(_jit,r0,r1,i0)
741static void _remi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
742static unsigned int __urem(unsigned int, unsigned int);
743#define remr_u(r0,r1,r2) _remr_u(_jit,r0,r1,r2)
744static void _remr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
745#define remi_u(r0,r1,i0) _remi_u(_jit,r0,r1,i0)
746static void _remi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
747static idiv_t __idivrem(int, int);
748#define qdivr(r0,r1,r2,r3) _qdivr(_jit,r0,r1,r2,r3)
749static void _qdivr(jit_state_t*,
750 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
751#define qdivi(r0,r1,r2,i0) _qdivi(_jit,r0,r1,r2,i0)
752static void _qdivi(jit_state_t*,
753 jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
754static udiv_t __udivrem(unsigned int, unsigned int);
755#define qdivr_u(r0,r1,r2,r3) _qdivr_u(_jit,r0,r1,r2,r3)
756static void _qdivr_u(jit_state_t*,
757 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
758#define qdivi_u(r0,r1,r2,i0) _qdivi_u(_jit,r0,r1,r2,i0)
759static void _qdivi_u(jit_state_t*,
760 jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
761#define andr(r0,r1,r2) AND(r1,r2,r0)
762#define andi(r0,r1,i0) _andi(_jit,r0,r1,i0)
763static void _andi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
764#define orr(r0,r1,r2) OR(r1,r2,r0)
765#define ori(r0,r1,i0) _ori(_jit,r0,r1,i0)
766static void _ori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
767#define xorr(r0,r1,r2) XOR(r1,r2,r0)
768#define xori(r0,r1,i0) _xori(_jit,r0,r1,i0)
769static void _xori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
770#define lshr(r0,r1,r2) _lshr(_jit,r0,r1,r2)
771static void _lshr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
772#define lshi(r0,r1,i0) SHLWI(r1,i0,r0)
773#define rshr(r0,r1,r2) _rshr(_jit,r0,r1,r2)
774static void _rshr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
775#define rshi(r0,r1,i0) SHRWI(r1,i0,r0)
776#define rshr_u(r0,r1,r2) _rshr_u(_jit,r0,r1,r2)
777static void _rshr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
778#define rshi_u(r0,r1,i0) SHRWI_U(r1,i0,r0)
ba86ff93
PC		 779#define lrotr(r0,r1,r2) _lrotr(_jit,r0,r1,r2)
780static void _lrotr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
781#define lroti(r0,r1,i0) rroti(r0,r1,32-i0)
782#define rrotr(r0,r1,r2) _rrotr(_jit,r0,r1,r2)
783static void _rrotr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
784#define rroti(r0,r1,i0) _rroti(_jit,r0,r1,i0)
785static void _rroti(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
4a71579b
PC		 786#define cmpr(c,r0,r1,r2) _cmpr(_jit,c,r0,r1,r2)
787static void _cmpr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t,jit_int32_t);
788#define cmpi(c,ci,r0,r1,i0) _cmpi(_jit,c,ci,r0,r1,i0)
789static void _cmpi(jit_state_t*,jit_word_t,jit_word_t,
790 jit_int32_t,jit_int32_t,jit_word_t);
791#define ltr(r0,r1,r2) cmpr(CS_CC_GE,r0,r1,r2)
792#define lti(r0,r1,i0) cmpi(CS_CC_GE,CS_CC_LE,r0,r1,i0)
793#define ltr_u(r0,r1,r2) cmpr(CS_CC_UGE,r0,r1,r2)
794#define lti_u(r0,r1,i0) cmpi(CS_CC_UGE,CS_CC_ULE,r0,r1,i0)
795#define ler(r0,r1,r2) cmpr(CS_CC_GT,r0,r1,r2)
796#define lei(r0,r1,i0) cmpi(CS_CC_GT,CS_CC_LT,r0,r1,i0)
797#define ler_u(r0,r1,r2) cmpr(CS_CC_UGT,r0,r1,r2)
798#define lei_u(r0,r1,i0) cmpi(CS_CC_UGT,CS_CC_ULT,r0,r1,i0)
799#define eqr(r0,r1,r2) cmpr(CS_CC_NE,r0,r1,r2)
800#define eqi(r0,r1,i0) cmpi(CS_CC_NE,CS_CC_NE,r0,r1,i0)
801#define ger(r0,r1,r2) cmpr(CS_CC_LT,r0,r1,r2)
802#define gei(r0,r1,i0) cmpi(CS_CC_LT,CS_CC_GT,r0,r1,i0)
803#define ger_u(r0,r1,r2) cmpr(CS_CC_ULT,r0,r1,r2)
804#define gei_u(r0,r1,i0) cmpi(CS_CC_ULT,CS_CC_UGT,r0,r1,i0)
805#define gtr(r0,r1,r2) cmpr(CS_CC_LE,r0,r1,r2)
806#define gti(r0,r1,i0) cmpi(CS_CC_LE,CS_CC_GE,r0,r1,i0)
807#define gtr_u(r0,r1,r2) cmpr(CS_CC_ULE,r0,r1,r2)
808#define gti_u(r0,r1,i0) cmpi(CS_CC_ULE,CS_CC_UGE,r0,r1,i0)
809#define ner(r0,r1,r2) cmpr(CS_CC_EQ,r0,r1,r2)
810#define nei(r0,r1,i0) cmpi(CS_CC_EQ,CS_CC_EQ,r0,r1,i0)
811#define ldr_c(r0,r1) _ldr_c(_jit,r0,r1)
812static void _ldr_c(jit_state_t*,jit_int32_t,jit_int32_t);
813#define ldi_c(r0,i0) _ldi_c(_jit,r0,i0)
814static void _ldi_c(jit_state_t*,jit_int32_t,jit_word_t);
815#define ldxr_c(r0,r1,r2) _ldxr_c(_jit,r0,r1,r2)
816static void _ldxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
817#define ldxi_c(r0,r1,i0) _ldxi_c(_jit,r0,r1,i0)
818static void _ldxi_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
819#define ldr_uc(r0,r1) LDBI(_R0_REGNO,r1,r0)
820#define ldi_uc(r0,i0) _ldi_uc(_jit,r0,i0)
821static void _ldi_uc(jit_state_t*,jit_int32_t,jit_word_t);
822#define ldxr_uc(r0,r1,r2) LDB(r2,r1,r0)
823#define ldxi_uc(r0,r1,i0) _ldxi_uc(_jit,r0,r1,i0)
824static void _ldxi_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
825#define ldr_s(r0,r1) _ldr_s(_jit,r0,r1)
826static void _ldr_s(jit_state_t*,jit_int32_t,jit_int32_t);
827#define ldi_s(r0,i0) _ldi_s(_jit,r0,i0)
828static void _ldi_s(jit_state_t*,jit_int32_t,jit_word_t);
829#define ldxr_s(r0,r1,r2) _ldxr_s(_jit,r0,r1,r2)
830static void _ldxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
831#define ldxi_s(r0,r1,i0) _ldxi_s(_jit,r0,r1,i0)
832static void _ldxi_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
833#define ldr_us(r0,r1) LDHI(_R0_REGNO,r1,r0)
834#define ldi_us(r0,i0) _ldi_us(_jit,r0,i0)
835static void _ldi_us(jit_state_t*,jit_int32_t,jit_word_t);
836#define ldxr_us(r0,r1,r2) LDH(r2,r1,r0)
837#define ldxi_us(r0,r1,i0) _ldxi_us(_jit,r0,r1,i0)
838static void _ldxi_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
4a71579b
PC		 839#define ldr_i(r0,r1) ldr_ui(r0,r1)
840#define ldr_ui(r0,r1) LDWI(_R0_REGNO,r1,r0)
841#define ldi_i(r0,i0) ldi_ui(r0,i0)
842#define ldi_ui(r0,i0) _ldi_ui(_jit,r0,i0)
843static void _ldi_ui(jit_state_t*,jit_int32_t,jit_word_t);
844#define ldxr_i(r0,r1,r2) ldxr_ui(r0,r1,r2)
845#define ldxr_ui(r0,r1,r2) LDW(r2,r1,r0)
4a71579b
PC		 846#define ldxi_i(r0,r1,i0) ldxi_ui(r0,r1,i0)
847#define ldxi_ui(r0,r1,i0) _ldxi_ui(_jit,r0,r1,i0)
848static void _ldxi_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
849#define str_c(r0,r1) STBI(r1,_R0_REGNO,r0)
850#define sti_c(i0,r0) _sti_c(_jit,i0,r0)
851static void _sti_c(jit_state_t*,jit_word_t,jit_int32_t);
852#define stxr_c(r0,r1,r2) _stxr_c(_jit,r0,r1,r2)
853static void _stxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
854#define stxi_c(i0,r0,r1) _stxi_c(_jit,i0,r0,r1)
855static void _stxi_c(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
856#define str_s(r0,r1) STHI(r1,_R0_REGNO,r0)
857#define sti_s(i0,r0) _sti_s(_jit,i0,r0)
858static void _sti_s(jit_state_t*,jit_word_t,jit_int32_t);
859#define stxr_s(r0,r1,r2) _stxr_s(_jit,r0,r1,r2)
860static void _stxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
861#define stxi_s(i0,r0,r1) _stxi_s(_jit,i0,r0,r1)
862static void _stxi_s(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
863#define str_i(r0,r1) STWI(r1,_R0_REGNO,r0)
864#define sti_i(i0,r0) _sti_i(_jit,i0,r0)
865static void _sti_i(jit_state_t*,jit_word_t,jit_int32_t);
866#define stxr_i(r0,r1,r2) _stxr_i(_jit,r0,r1,r2)
867static void _stxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
4a71579b
PC		 868#define stxi_i(i0,r0,r1) _stxi_i(_jit,i0,r0,r1)
869static void _stxi_i(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
870#define bcmpr(c,i0,r0,r1) _bcmpr(_jit,c,i0,r0,r1)
871static jit_word_t _bcmpr(jit_state_t*,jit_word_t,
872 jit_word_t,jit_int32_t,jit_int32_t);
873#define bcmpi(c,ci,i0,r0,i1) _bcmpi(_jit,c,ci,i0,r0,i1)
874static jit_word_t _bcmpi(jit_state_t*,jit_word_t,jit_word_t,
875 jit_word_t,jit_int32_t,jit_word_t);
876#define bltr(i0,r0,r1) bcmpr(CS_CC_LT,i0,r0,r1)
877#define blti(i0,r0,r1) bcmpi(CS_CC_LT,CS_CC_GT,i0,r0,r1)
878#define bltr_u(i0,r0,r1) bcmpr(CS_CC_ULT,i0,r0,r1)
879#define blti_u(i0,r0,r1) bcmpi(CS_CC_ULT,CS_CC_UGT,i0,r0,r1)
880#define bler(i0,r0,r1) bcmpr(CS_CC_LE,i0,r0,r1)
881#define blei(i0,r0,r1) bcmpi(CS_CC_LE,CS_CC_GE,i0,r0,r1)
882#define bler_u(i0,r0,r1) bcmpr(CS_CC_ULE,i0,r0,r1)
883#define blei_u(i0,r0,r1) bcmpi(CS_CC_ULE,CS_CC_UGE,i0,r0,r1)
884#define beqr(i0,r0,r1) bcmpr(CS_CC_EQ,i0,r0,r1)
885#define beqi(i0,r0,r1) bcmpi(CS_CC_EQ,CS_CC_EQ,i0,r0,r1)
886#define bger(i0,r0,r1) bcmpr(CS_CC_GE,i0,r0,r1)
887#define bgei(i0,r0,r1) bcmpi(CS_CC_GE,CS_CC_LE,i0,r0,r1)
888#define bger_u(i0,r0,r1) bcmpr(CS_CC_UGE,i0,r0,r1)
889#define bgei_u(i0,r0,r1) bcmpi(CS_CC_UGE,CS_CC_ULE,i0,r0,r1)
890#define bgtr(i0,r0,r1) bcmpr(CS_CC_GT,i0,r0,r1)
891#define bgti(i0,r0,r1) bcmpi(CS_CC_GT,CS_CC_LT,i0,r0,r1)
892#define bgtr_u(i0,r0,r1) bcmpr(CS_CC_UGT,i0,r0,r1)
893#define bgti_u(i0,r0,r1) bcmpi(CS_CC_UGT,CS_CC_ULT,i0,r0,r1)
894#define bner(i0,r0,r1) bcmpr(CS_CC_NE,i0,r0,r1)
895#define bnei(i0,r0,r1) bcmpi(CS_CC_NE,CS_CC_NE,i0,r0,r1)
896#define bmxr(c,i0,r0,r1) _bmxr(_jit,c,i0,r0,r1)
897static jit_word_t _bmxr(jit_state_t*,jit_bool_t,
898 jit_word_t,jit_int32_t,jit_int32_t);
899#define bmxi(c,i0,r0,i1) _bmxi(_jit,c,i0,r0,i1)
900static jit_word_t _bmxi(jit_state_t*,jit_bool_t,
901 jit_word_t,jit_int32_t,jit_word_t);
902#define bmcr(r0,r1,r2) bmxr(0,r0,r1,r2)
903#define bmci(r0,r1,r2) bmxi(0,r0,r1,r2)
904#define bmsr(r0,r1,r2) bmxr(1,r0,r1,r2)
905#define bmsi(r0,r1,r2) bmxi(1,r0,r1,r2)
906#define boaddr(i0,r0,r1) _boaddr(_jit,i0,r0,r1)
907static jit_word_t _boaddr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
908#define boaddi(i0,r0,i1) _boaddi(_jit,i0,r0,i1)
909static jit_word_t _boaddi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
910#define boaddr_u(i0,r0,r1) _boaddr_u(_jit,i0,r0,r1)
911static jit_word_t _boaddr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
912#define boaddi_u(i0,r0,i1) _boaddi_u(_jit,i0,r0,i1)
913static jit_word_t _boaddi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
914#define bxaddr(i0,r0,r1) _bxaddr(_jit,i0,r0,r1)
915static jit_word_t _bxaddr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
916#define bxaddi(i0,r0,i1) _bxaddi(_jit,i0,r0,i1)
917static jit_word_t _bxaddi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
918#define bxaddr_u(i0,r0,r1) _bxaddr_u(_jit,i0,r0,r1)
919static jit_word_t _bxaddr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
920#define bxaddi_u(i0,r0,i1) _bxaddi_u(_jit,i0,r0,i1)
921static jit_word_t _bxaddi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
922#define bosubr(i0,r0,r1) _bosubr(_jit,i0,r0,r1)
923static jit_word_t _bosubr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
924#define bosubi(i0,r0,i1) _bosubi(_jit,i0,r0,i1)
925static jit_word_t _bosubi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
926#define bosubr_u(i0,r0,r1) _bosubr_u(_jit,i0,r0,r1)
927static jit_word_t _bosubr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
928#define bosubi_u(i0,r0,i1) _bosubi_u(_jit,i0,r0,i1)
929static jit_word_t _bosubi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
930#define bxsubr(i0,r0,r1) _bxsubr(_jit,i0,r0,r1)
931static jit_word_t _bxsubr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
932#define bxsubi(i0,r0,i1) _bxsubi(_jit,i0,r0,i1)
933static jit_word_t _bxsubi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
934#define bxsubr_u(i0,r0,r1) _bxsubr_u(_jit,i0,r0,r1)
935static jit_word_t _bxsubr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
936#define bxsubi_u(i0,r0,i1) _bxsubi_u(_jit,i0,r0,i1)
937static jit_word_t _bxsubi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
938#define jmpr(r0) _jmpr(_jit,r0)
939static void _jmpr(jit_state_t*,jit_int32_t);
940#define jmpi(i0) _jmpi(_jit,i0)
79bfeef6 941static jit_word_t _jmpi(jit_state_t*,jit_word_t);
4a71579b
PC		 942#define jmpi_p(i0) _jmpi_p(_jit,i0)
943static jit_word_t _jmpi_p(jit_state_t*,jit_word_t);
944#define callr(r0) _callr(_jit,r0)
945static void _callr(jit_state_t*,jit_int32_t);
946#define calli(i0) _calli(_jit,i0)
947static void _calli(jit_state_t*,jit_word_t);
948#define calli_p(i0) _calli_p(_jit,i0)
949static jit_word_t _calli_p(jit_state_t*,jit_word_t);
950#define prolog(node) _prolog(_jit, node)
951static void _prolog(jit_state_t*, jit_node_t*);
952#define epilog(node) _epilog(_jit, node)
953static void _epilog(jit_state_t*, jit_node_t*);
954#define vastart(r0) _vastart(_jit, r0)
955static void _vastart(jit_state_t*, jit_int32_t);
956#define vaarg(r0, r1) _vaarg(_jit, r0, r1)
957static void _vaarg(jit_state_t*, jit_int32_t, jit_int32_t);
958#define patch_at(i,l) _patch_at(_jit,i,l)
959static void _patch_at(jit_state_t*,jit_word_t,jit_word_t);
ba86ff93
PC		 960
961# define NEED_FALLBACK_CASX 1
4a71579b
PC		 962#endif
963
964#if CODE
965/* from binutils bfd/libhppa.h */
966static inline int
967sign_extend (int x, int len)
968{
969 int signbit = (1 << (len - 1));
970 int mask = (signbit << 1) - 1;
971 return ((x & mask) ^ signbit) - signbit;
972}
973
974static inline int
975sign_unext (int x, int len)
976{
977 int len_ones;
978
979 len_ones = (1 << len) - 1;
980
981 return x & len_ones;
982}
983
984static inline int
985low_sign_unext (int x, int len)
986{
987 int temp;
988 int sign;
989
990 sign = (x >> (len-1)) & 1;
991
992 temp = sign_unext (x, len-1);
993
994 return (temp << 1) | sign;
995}
996
997static inline int
998re_assemble_3 (int as3)
999{
1000 return (( (as3 & 4) << (13-2))
1001 | ((as3 & 3) << (13+1)));
1002}
1003
1004static inline int
1005re_assemble_12 (int as12)
1006{
1007 return (( (as12 & 0x800) >> 11)
1008 | ((as12 & 0x400) >> (10 - 2))
1009 | ((as12 & 0x3ff) << (1 + 2)));
1010}
1011
1012static inline int
1013re_assemble_16 (int as16)
1014{
1015 int s, t;
1016
1017 /* Unusual 16-bit encoding, for wide mode only. */
1018 t = (as16 << 1) & 0xffff;
1019 s = (as16 & 0x8000);
1020 return (t ^ s ^ (s >> 1)) | (s >> 15);
1021}
1022
1023static inline int
1024re_assemble_17 (int as17)
1025{
1026 return (( (as17 & 0x10000) >> 16)
1027 | ((as17 & 0x0f800) << (16 - 11))
1028 | ((as17 & 0x00400) >> (10 - 2))
1029 | ((as17 & 0x003ff) << (1 + 2)));
1030}
1031
1032static inline int
1033re_assemble_21 (int as21)
1034{
1035 return (( (as21 & 0x100000) >> 20)
1036 | ((as21 & 0x0ffe00) >> 8)
1037 | ((as21 & 0x000180) << 7)
1038 | ((as21 & 0x00007c) << 14)
1039 | ((as21 & 0x000003) << 12));
1040}
1041
1042static inline int
1043re_assemble_22 (int as22)
1044{
1045 return (( (as22 & 0x200000) >> 21)
1046 | ((as22 & 0x1f0000) << (21 - 16))
1047 | ((as22 & 0x00f800) << (16 - 11))
1048 | ((as22 & 0x000400) >> (10 - 2))
1049 | ((as22 & 0x0003ff) << (1 + 2)));
1050}
1051
1052static void
1053_f1(jit_state_t *_jit, jit_int32_t o,
1054 jit_int32_t b, jit_int32_t t, jit_int32_t i)
1055{
1056 assert(!(o & ~0x3f));
1057 assert(!(b & ~0x1f));
1058 assert(!(t & ~0x1f));
1059 assert(i >= -8192 && i <= 8191);
1060 ii((o<<26)|(b<<21)|(t<<16)|(re_assemble_16(i)));
1061}
1062
1063static void
1064_f2(jit_state_t *_jit, jit_int32_t o,
1065 jit_int32_t b, jit_int32_t t, jit_int32_t i, jit_int32_t j)
1066{
1067 assert(!(o & ~0x3f));
1068 assert(!(b & ~0x1f));
1069 assert(!(t & ~0x1f));
1070 assert(i >= -32768 && i <= 32767);
1071 assert(!(j & ~0x3));
1072 ii((o<<26)|(b<<21)|(t<<16)|(j<<1)|(re_assemble_16(i)));
1073}
1074
1075static void
1076_f3(jit_state_t *_jit, jit_int32_t o,
1077 jit_int32_t b, jit_int32_t t, jit_int32_t i, jit_int32_t j)
1078{
1079 assert(!(o & ~0x3f));
1080 assert(!(b & ~0x1f));
1081 assert(!(t & ~0x1f));
1082 assert(i >= -32768 && i <= 32767);
1083 assert(!(j & ~0x1));
1084 ii((o<<26)|(b<<21)|(t<<16)|(j<<1)|(re_assemble_16(i)));
1085}
1086
1087static void
1088_f4(jit_state_t *_jit, jit_int32_t o, jit_int32_t b,
1089 jit_int32_t x, jit_int32_t s, jit_int32_t u, jit_int32_t y,
1090 jit_int32_t c, jit_int32_t z, jit_int32_t m, jit_int32_t t)
1091{
1092 assert(!(o & ~0x3f));
1093 assert(!(b & ~0x1f));
1094 assert(!(x & ~0x1f));
1095 assert(!(s & ~0x3));
1096 assert(!(u & ~0x1));
1097 assert(!(y & ~0x1));
1098 assert(!(c & ~0x3));
1099 assert(!(z & ~0xf));
1100 assert(!(m & ~0x1));
1101 assert(!(t & ~0x1f));
1102 ii((o<<26)|(b<<21)|(x<<16)|(s<<14)|(u<<13)|(y<<12)|(c<<10)|(z<<6)|(m<<5)|t);
1103}
1104
1105static void
1106_f5(jit_state_t *_jit, jit_int32_t o, jit_int32_t b,
1107 jit_int32_t i, jit_int32_t s, jit_int32_t a, jit_int32_t y,
1108 jit_int32_t c, jit_int32_t z, jit_int32_t m, jit_int32_t t)
1109{
1110 assert(!(o & ~0x3f));
1111 assert(!(b & ~0x1f));
1112 assert(!(s & ~0x3));
1113 assert(!(a & ~0x1));
1114 assert(!(y & ~0x1));
1115 assert(!(c & ~0x3));
1116 assert(!(z & ~0xf));
1117 assert(!(m & ~0x1));
1118 assert(i >= -16 && i <= 15);
1119 ii((o<<26)|(b<<21)|(low_sign_unext(i,5)<<16)|
1120 (s<<14)|(a<<13)|(y<<12)|(c<<10)|(z<<6)|(m<<5)|t);
1121}
1122
1123static void
1124_f6(jit_state_t *_jit, jit_int32_t o, jit_int32_t b,
1125 jit_int32_t r, jit_int32_t s, jit_int32_t a, jit_int32_t x,
1126 jit_int32_t c, jit_int32_t y, jit_int32_t m, jit_int32_t i)
1127{
1128 assert(!(o & ~0x3f));
1129 assert(!(b & ~0x1f));
1130 assert(!(s & ~0x3));
1131 assert(!(a & ~0x1));
1132 assert(!(x & ~0x1));
1133 assert(!(c & ~0x3));
1134 assert(!(y & ~0xf));
1135 assert(!(m & ~0x1));
1136 assert(i >= -16 && i <= 15);
1137 ii((o<<26)|(b<<21)|(r<<16)|(s<<14)|(a<<13)|
1138 (x<<12)|(c<<10)|(y<<6)|(m<<5)|low_sign_unext(i,5));
1139}
1140
1141static void
1142_f7(jit_state_t *_jit, jit_int32_t o, jit_int32_t r, jit_int32_t i)
1143{
1144 assert(!(o & ~0x3f));
1145 assert(!(r & ~0x1f));
1146 assert(!(i & 0x7ff));
1147 ii((o<<26)|(r<<21)|re_assemble_21(i>>11));
1148}
1149
1150static void
1151_f8(jit_state_t *_jit, jit_int32_t o,
1152 jit_int32_t r2, jit_int32_t r1, jit_int32_t cf,
1153 jit_int32_t e1, jit_int32_t x, jit_int32_t e2,
1154 jit_int32_t e3, jit_int32_t d, jit_int32_t t)
1155{
1156 assert(!(o & ~0x3f));
1157 assert(!(r2 & ~0x1f));
1158 assert(!(r1 & ~0x1f));
1159 assert(!(cf & ~0xf));
1160 assert(!(e1 & ~0x3));
1161 assert(!(x & ~0x1));
1162 assert(!(e2 & ~0x3));
1163 assert(!(e3 & ~0x3));
1164 assert(!(d & ~0x1));
1165 assert(!(t & ~0x1f));
1166 ii((o<<26)|(r2<<21)|(r1<<16)|(cf<<12)|
1167 (e1<<10)|(x<<9)|(e2<<8)|(e3<<6)|(d<<5)|t);
1168}
1169
1170static void
1171_f9(jit_state_t *_jit,
1172 jit_int32_t o, jit_int32_t r, jit_int32_t t,
1173 jit_int32_t cf, jit_int32_t e1, jit_int32_t i)
1174{
1175 assert(!(o & ~0x3f));
1176 assert(!(r & ~0x1f));
1177 assert(!(t & ~0x1f));
1178 assert(!(cf & ~0xf));
1179 assert(!(e1 & ~0x1));
1180 assert(i >= -2048 && i <= 2047);
1181 ii((o<<26)|(r<<21)|(t<<16)|(cf<<12)|(e1<<11)|low_sign_unext(i,11));
1182}
1183
1184static void
1185_f10(jit_state_t *_jit, jit_int32_t o, jit_int32_t r2,
1186 jit_int32_t r1, jit_int32_t u, jit_int32_t v, jit_int32_t w,
1187 jit_int32_t x, jit_int32_t sa, jit_int32_t y, jit_int32_t t)
1188{
1189 assert(!(o & ~0x3f));
1190 assert(!(r2 & ~0x1f));
1191 assert(!(r1 & ~0x1f));
1192 assert(!(u & ~0x1));
1193 assert(!(v & ~0x3));
1194 assert(!(w & ~0x1));
1195 assert(!(x & ~0x3));
1196 assert(!(sa & ~0xf));
1197 assert(!(y & ~0x1));
1198 assert(!(t & ~0x1f));
1199 ii((o<<26)|(r2<<21)|(r1<<16)|(u<<15)|
1200 (v<<13)|(w<<12)|(x<<10)|(sa<<6)|(y<<5)|t);
1201}
1202
1203static void
1204_f11(jit_state_t *_jit, jit_int32_t o,
1205 jit_int32_t r2, jit_int32_t r1, jit_int32_t c, jit_int32_t x,
1206 jit_int32_t y, jit_int32_t z, jit_int32_t u, jit_int32_t t)
1207{
1208 assert(!(o & ~0x3f));
1209 assert(!(r1 & ~0x1f));
1210 assert(!(r2 & ~0x1f));
1211 assert(!(c & ~0x7));
1212 assert(!(x & ~0x3));
1213 assert(!(y & ~0x1));
1214 assert(!(z & ~0x1));
1215 assert(!(u & ~0xf));
1216 assert(!(t & ~0x1f));
1217 ii((o<<26)|(r2<<21)|(r1<<16)|(c<<13)|(x<<11)|(y<<10)|(z<<9)|(u<<5)|t);
1218}
1219
1220static void
1221_f12(jit_state_t *_jit, jit_int32_t o, jit_int32_t r,
1222 jit_int32_t t, jit_int32_t c, jit_int32_t x, jit_int32_t se,
1223 jit_int32_t y, jit_int32_t c1, jit_int32_t z, jit_int32_t clen)
1224{
1225 assert(!(o & ~0x3f));
1226 assert(!(r & ~0x1f));
1227 assert(!(t & ~0x1f));
1228 assert(!(c & ~0x7));
1229 assert(!(x & ~0x3));
1230 assert(!(se & ~0x1));
1231 assert(!(y & ~0x1));
1232 assert(!(c1 & ~0x1));
1233 assert(!(z & ~0x7));
1234 assert(!((32-clen) & ~0x1f));
1235 ii((o<<26)|(r<<21)|(t<<16)|(c<<13)|(x<<11)|
1236 (se<<10)|(y<<9)|(c1<<8)|(z<<5)|(32-clen));
1237}
1238
1239static void
1240_f13(jit_state_t *_jit, jit_int32_t o, jit_int32_t t,
1241 jit_int32_t r, jit_int32_t c, jit_int32_t x,
1242 jit_int32_t nz, jit_int32_t c1, jit_int32_t clen)
1243{
1244 assert(!(o & ~0x3f));
1245 assert(!(t & ~0x1f));
1246 assert(!(r & ~0x1f));
1247 assert(!(c & ~0x7));
1248 assert(!(x & ~0x3));
1249 assert(!(nz & ~0x1));
1250 assert(!(c1 & ~0x1));
1251 assert(!((32-clen) & ~0x1f));
1252 ii((o<<26)|(t<<21)|(r<<16)|(c<<13)|
1253 (x<<11)|(nz<<10)|(c1<<8)|(32-clen));
1254}
1255
1256static void
1257_f13x(jit_state_t *_jit, jit_int32_t o, jit_int32_t t,
1258 jit_int32_t i, jit_int32_t c, jit_int32_t x,
1259 jit_int32_t nz, jit_int32_t c1, jit_int32_t clen)
1260{
1261 assert(!(o & ~0x3f));
1262 assert(!(t & ~0x1f));
1263 assert(i >= -16 && i <= 15);
1264 assert(!(c & ~0x7));
1265 assert(!(x & ~0x3));
1266 assert(!(nz & ~0x1));
1267 assert(!((32-clen) & ~0x1f));
1268 ii((o<<26)|(t<<21)|(low_sign_unext(i,5)<<16)|
1269 (c<<13)|(x<<11)|(nz<<10)|(c1<<8)|(32-clen));
1270}
1271
1272static void
1273_f14(jit_state_t *_jit, jit_int32_t o,
1274 jit_int32_t r2, jit_int32_t r1, jit_int32_t c, jit_int32_t x,
1275 jit_int32_t cp, jit_int32_t y, jit_int32_t cpos, jit_int32_t t)
1276{
1277 assert(!(o & ~0x3f));
1278 assert(!(r1 & ~0x1f));
1279 assert(!(r2 & ~0x1f));
1280 assert(!(c & ~0x7));
1281 assert(!(x & ~0x3));
1282 assert(!(cp & ~0x1));
1283 assert(!(y & ~0x1));
1284 assert(!(cpos & ~0x1f));
1285 assert(!(t & ~0x1f));
1286 ii((o<<26)|(r2<<21)|(r1<<16)|(c<<13)|(x<<12)|(cp<<11)|(y<<10)|(cpos<<5)|t);
1287}
1288
1289static void
1290_f15(jit_state_t *_jit, jit_int32_t o,
1291 jit_int32_t r, jit_int32_t t, jit_int32_t c, jit_int32_t c1,
1292 jit_int32_t p, jit_int32_t se, jit_int32_t pos, jit_int32_t clen)
1293{
1294 assert(!(o & ~0x3f));
1295 assert(!(r & ~0x1f));
1296 assert(!(t & ~0x1f));
1297 assert(!(c & ~0x7));
1298 assert(!(c1 & ~0x1));
1299 assert(!(p & ~0x1));
1300 assert(!(se & ~0x1));
1301 assert(!(pos & ~0x1f));
1302 assert(!((32-clen) & ~0x1f));
1303 ii((o<<26)|(r<<21)|(t<<16)|(c<<13)|(c1<<12)|
1304 (p<<11)|(se<<10)|(pos<<5)|(32-clen));
1305}
1306
1307static void
1308_f16(jit_state_t *_jit, jit_int32_t o,
1309 jit_int32_t t, jit_int32_t r, jit_int32_t c, jit_int32_t c1,
1310 jit_int32_t cp, jit_int32_t nz, jit_int32_t cpos, jit_int32_t clen)
1311{
1312 assert(!(o & ~0x3f));
1313 assert(!(t & ~0x1f));
1314 assert(!(r & ~0x1f));
1315 assert(!(c & ~0x7));
1316 assert(!(c1 & ~0x1));
1317 assert(!(cp & ~0x1));
1318 assert(!(nz & ~0x1));
1319 assert(!(cpos & ~0x1f));
1320 assert(!((32-clen) & ~0x3f));
1321 ii((o<<26)|(t<<21)|(r<<16)|(c<<13)|
1322 (c1<<12)|(cp<<11)|(nz<<10)|(cpos<<5)|(32-clen));
1323}
1324
1325static void
1326_f16x(jit_state_t *_jit, jit_int32_t o,
1327 jit_int32_t t, jit_int32_t i, jit_int32_t c, jit_int32_t c1,
1328 jit_int32_t cp, jit_int32_t nz, jit_int32_t cpos, jit_int32_t clen)
1329{
1330 assert(!(o & ~0x3f));
1331 assert(!(t & ~0x1f));
1332 assert(i >= -16 && i <= 15);
1333 assert(!(c & ~0x7));
1334 assert(!(c1 & ~0x1));
1335 assert(!(cp & ~0x1));
1336 assert(!(nz & ~0x1));
1337 assert(!(cpos & ~0x1f));
1338 assert(!((32-clen) & ~0x3f));
1339 ii((o<<26)|(t<<21)|(low_sign_unext(i,5)<<16)|(c<<13)|
1340 (c1<<12)|(cp<<11)|(nz<<10)|(cpos<<5)|(32-clen));
1341}
1342
1343static void
1344_f17(jit_state_t *_jit, jit_int32_t o, jit_int32_t r2,
1345 jit_int32_t r1, jit_int32_t c, jit_int32_t i, jit_int32_t n)
1346{
1347 assert(!(o & ~0x3f));
1348 assert(!(r2 & ~0x1f));
1349 assert(!(r1 & ~0x1f));
1350 assert(!(c & ~0x7));
1351 assert(i >= -2048 && i <= 2047);
1352 assert(!(n & ~0x1));
1353 ii((o<<26)|(r2<<21)|(r1<<16)|(c<<13)|re_assemble_12(i)|(n<<1));
1354}
1355
1356static void
1357_f17x(jit_state_t *_jit, jit_int32_t o, jit_int32_t r,
1358 jit_int32_t i, jit_int32_t c, jit_int32_t t, jit_int32_t n)
1359{
1360 assert(!(o & ~0x3f));
1361 assert(!(r & ~0x1f));
1362 assert(i >= -16 && i <= 15);
1363 assert(!(c & ~0x7));
1364 assert(t >= -2048 && t <= 2047);
1365 assert(!(n & ~0x1));
1366 ii((o<<26)|(r<<21)|
1367 (low_sign_unext(i,5)<<16)|(c<<13)|re_assemble_12(t)|(n<<1));
1368}
1369
1370static void
1371_f18(jit_state_t *_jit, jit_int32_t o, jit_int32_t p,
1372 jit_int32_t r, jit_int32_t c, jit_int32_t i, jit_int32_t n)
1373{
1374 assert(!(o & ~0x3f));
1375 assert(!(p & ~0x1f));
1376 assert(!(r & ~0x1f));
1377 assert(!(c & ~0x1));
1378 assert(i >= -2048 && i <= 2047);
1379 assert(!(n & ~0x1));
1380 ii((o<<26)|(p<<21)|(r<<16)|(c<<15)|(1<<14)|re_assemble_12(i)|(n<<1));
1381}
1382
1383static void
1384_f19(jit_state_t *_jit, jit_int32_t o, jit_int32_t b,
1385 jit_int32_t s, jit_int32_t i, jit_int32_t n)
1386{
1387 assert(!(o & ~0x3f));
1388 assert(!(b & ~0x1f));
1389 assert(!(s & ~0x7));
1390 assert(i >= -65536 && i <= 65535);
1391 assert(!(n & ~0x1));
1392 ii((o<<26)|(b<<21)|re_assemble_3(s)|re_assemble_17(i)|(n<<1));
1393}
1394
1395static void
1396_f20(jit_state_t *_jit, jit_int32_t o, jit_int32_t t,
1397 jit_int32_t i, jit_int32_t g, jit_int32_t n)
1398{
1399 assert(!(o & ~0x3f));
1400 assert(!(t & ~0x1f));
1401 assert(i >= -32768 && i <= 32767);
1402 assert(!(g & ~0x7));
1403 assert(!(n & ~0x1));
1404 ii((o<<26)|(t<<21)|(g<<13)|re_assemble_17(i)|(n<<1));
1405}
1406
1407static void
1408_f21(jit_state_t *_jit, jit_int32_t o, jit_int32_t t,
1409 jit_int32_t x, jit_int32_t y, jit_int32_t n)
1410{
1411 assert(!(o & ~0x3f));
1412 assert(!(t & ~0x1f));
1413 assert(!(x & ~0x1f));
1414 assert(!(y & ~0x7));
1415 assert(!(n & ~0x1));
1416 ii((o<<26)|(t<<21)|(x<<16)|(y<<13)|(n<<1));
1417}
1418
1419static void
1420_f22(jit_state_t *_jit, jit_int32_t o, jit_int32_t b,
1421 jit_int32_t x, jit_int32_t r, jit_int32_t n, jit_int32_t p)
1422{
1423 assert(!(o & ~0x3f));
1424 assert(!(b & ~0x1f));
1425 assert(!(x & ~0x7));
1426 assert(!(r & ~0x3f));
1427 assert(!(n & ~0x1));
1428 assert(!(p & ~0x1));
1429 ii((o<<26)|(b<<21)|(x<<13)|(1<<12)|(r<<2)|(n<<1)|p);
1430}
1431
1432static void
1433_f23(jit_state_t *_jit, jit_int32_t o,
1434 jit_int32_t a, jit_int32_t b, jit_int32_t c, jit_int32_t d,
1435 jit_int32_t e, jit_int32_t f, jit_int32_t g, jit_int32_t h)
1436{
1437 assert(!(o & ~0x3f));
1438 assert(!(a & ~0x1f));
1439 assert(!(b & ~0x1f));
1440 assert(!(c & ~0x7));
1441 assert(!(d & ~0x1));
1442 assert(!(e & ~0x1ff));
1443 assert(!(f & ~0x1));
1444 assert(!(g & ~0x1));
1445 assert(!(h & ~0x1));
1446 ii((o<<26)|(a<<21)|(b<<16)|(c<<13)|(d<<12)|(e<<3)|(f<<2)|(g<<1)|h);
1447}
1448
1449static void
1450_f24(jit_state_t *_jit, jit_int32_t o,
1451 jit_int32_t b, jit_int32_t x, jit_int32_t s,
1452 jit_int32_t y, jit_int32_t m,jit_int32_t r)
1453{
1454 assert(!(o & ~0x3f));
1455 assert(!(b & ~0x1f));
1456 assert(!(x & ~0x1f));
1457 assert(!(s & ~0x3));
1458 assert(!(y & ~0xff));
1459 assert(!(m & ~0x1));
1460 assert(!(r & ~0x1f));
1461 ii((o<<26)|(b<<21)|(x<<16)|(s<<14)|(y<<6)|(m<<5)|r);
1462}
1463
1464static void
1465_f25(jit_state_t *_jit, jit_int32_t o,
1466 jit_int32_t b, jit_int32_t i, jit_int32_t s,
1467 jit_int32_t y, jit_int32_t m, jit_int32_t r)
1468{
1469 assert(!(o & ~0x3f));
1470 assert(!(b & ~0x1f));
1471 assert(i >= -16 && i <= 15);
1472 assert(!(s & ~0x3));
1473 assert(!(y & ~0xff));
1474 assert(!(m & ~0x1));
1475 assert(!(r & ~0x1f));
1476 ii((o<<26)|(b<<21)|(low_sign_unext(i,5)<<16)|(s<<14)|(y<<6)|(m<<5)|r);
1477}
1478
1479static void
1480_f26(jit_state_t *_jit, jit_int32_t o,
1481 jit_int32_t b, jit_int32_t x, jit_int32_t s,
1482 jit_int32_t y, jit_int32_t m,jit_int32_t r)
1483{
1484 assert(!(o & ~0x3f));
1485 assert(!(b & ~0x1f));
1486 assert(!(x & ~0x1f));
1487 assert(!(s & ~0x7));
1488 assert(!(y & ~0x7f));
1489 assert(!(m & ~0x1));
1490 assert(!(r & ~0x1f));
1491 ii((o<<26)|(b<<21)|(x<<16)|(s<<13)|(y<<6)|(m<<5)|r);
1492}
1493
1494static void
1495_f27(jit_state_t *_jit, jit_int32_t o, jit_int32_t i, jit_int32_t j)
1496{
1497 assert(!(o & ~0x3f));
1498 assert(i >= -4096 && i < 4095);
1499 assert(j >= -16 && j < 15);
1500 ii((o<<26)|(i<<13)|j);
1501}
1502
1503static void
1504_f28(jit_state_t *_jit, jit_int32_t o, jit_int32_t i)
1505{
1506 assert(!(o & ~0x3f));
1507 assert(!(i & ~0x1ffffff));
1508 ii((o<<26)|i);
1509}
1510
1511static void
1512_f29(jit_state_t *_jit, jit_int32_t o, jit_int32_t r,
1513 jit_int32_t x, jit_int32_t s, jit_int32_t y, jit_int32_t t)
1514{
1515 assert(!(o & ~0x3f));
1516 assert(!(r & ~0x1f));
1517 assert(!(x & ~0x1f));
1518 assert(!(s & ~0x7));
1519 assert(!(y & ~0xff));
1520 assert(!(t & ~0x1f));
1521 ii((o<<26)|(r<<21)|(x<<16)|re_assemble_3(s)|(y<<5)|t);
1522}
1523
1524static void
1525_f30(jit_state_t *_jit, jit_int32_t o, jit_int32_t b, jit_int32_t r,
1526 jit_int32_t s, jit_int32_t x, jit_int32_t y, jit_int32_t t)
1527{
1528 assert(!(o & ~0x3f));
1529 assert(!(b & ~0x1f));
1530 assert(!(r & ~0x1f));
1531 assert(!(s & ~0x3));
1532 assert(!(x & ~0x1));
1533 assert(!(y & ~0xff));
1534 assert(!(t & ~0x1f));
1535 ii((o<<26)|(b<<21)|(r<<16)|(s<<14)|(x<<13)|(y<<5)|t);
1536}
1537
1538static void
1539_f31(jit_state_t *_jit, jit_int32_t o, jit_int32_t t,
1540 jit_int32_t r, jit_int32_t v, jit_int32_t x, jit_int32_t y)
1541{
1542 assert(!(o & ~0x3f));
1543 assert(!(t & ~0x1f));
1544 assert(!(r & ~0x1f));
1545 assert(!(v & ~0x1f));
1546 assert(!(x & ~0xff));
1547 assert(!(y & ~0x1f));
1548 ii((o<<26)|(t<<21)|(r<<16)|(v<<14)|(x<<5)|y);
1549}
1550
1551static void
1552_f33(jit_state_t *_jit, jit_int32_t o, jit_int32_t x,
1553 jit_int32_t r, jit_int32_t y, jit_int32_t z, jit_int32_t u)
1554{
1555 assert(!(o & ~0x3f));
1556 assert(!(x & ~0x1f));
1557 assert(!(r & ~0x1f));
1558 assert(!(y & ~0x7));
1559 assert(!(z & ~0xff));
1560 assert(!(u & ~0x1f));
1561 ii((o<<26)|(x<<21)|(r<<16)|(y<<13)|(z<<5)|u);
1562}
1563
1564static void
1565_f34(jit_state_t *_jit, jit_int32_t o, jit_int32_t o1,
1566 jit_int32_t x, jit_int32_t sf, jit_int32_t n, jit_int32_t o2)
1567{
1568 assert(!(o & ~0x3f));
1569 assert(!(o1 & ~0x7fff));
1570 assert(!(x & ~0x3));
1571 assert(!(sf & ~0x7));
1572 assert(!(n & ~0x1));
1573 assert(!(o2 & ~0x1f));
1574 ii((o<<26)|(o1<<11)|(x<<9)|(sf<<6)|(n<<5)|o2);
1575}
1576
1577static void
1578_f35(jit_state_t *_jit, jit_int32_t o, jit_int32_t op,
1579 jit_int32_t x, jit_int32_t sf, jit_int32_t n, jit_int32_t t)
1580{
1581 assert(!(o & ~0x3f));
1582 assert(!(op & ~0x7fff));
1583 assert(!(x & ~0x3));
1584 assert(!(sf & ~0x7));
1585 assert(!(n & ~0x1));
1586 assert(!(t & ~0x1f));
1587 ii((o<<26)|(op<<11)|(x<<9)|(sf<<6)|(n<<5)|t);
1588}
1589
1590static void
1591_f36(jit_state_t *_jit, jit_int32_t o, jit_int32_t r, jit_int32_t o1,
1592 jit_int32_t x, jit_int32_t sf, jit_int32_t n, jit_int32_t o2)
1593{
1594 assert(!(o & ~0x3f));
1595 assert(!(r & ~0x1f));
1596 assert(!(o1 & ~0x3ff));
1597 assert(!(x & ~0x3));
1598 assert(!(sf & ~0x7));
1599 assert(!(n & ~0x1));
1600 assert(!(o2 & ~0x1f));
1601 ii((o<<26)|(r<<21)|(o1<<11)|(x<<9)|(sf<<6)|(n<<5)|o2);
1602}
1603
1604static void
1605_f37(jit_state_t *_jit, jit_int32_t o, jit_int32_t r2,
1606 jit_int32_t r1, jit_int32_t o1, jit_int32_t x,
1607 jit_int32_t sf, jit_int32_t n, jit_int32_t o2)
1608{
1609 assert(!(o & ~0x3f));
1610 assert(!(r2 & ~0x1f));
1611 assert(!(r1 & ~0x1f));
1612 assert(!(o1 & ~0x1f));
1613 assert(!(x & ~0x3));
1614 assert(!(sf & ~0x7));
1615 assert(!(n & ~0x1));
1616 assert(!(o2 & ~0x1f));
1617 ii((o<<26)|(r2<<21)|(r1<<16)|(o1<<11)|(x<<9)|(sf<<6)|(n<<5)|o2);
1618}
1619
1620static void
1621_f38(jit_state_t *_jit, jit_int32_t o,
1622 jit_int32_t s, jit_int32_t u, jit_int32_t n)
1623{
1624 assert(!(o & ~0x3f));
1625 assert(!(s & ~0x3fffff));
1626 assert(!(u & ~0x7));
1627 assert(!(n & ~0x1));
1628 ii((o<<26)|((s>>5)<<9)|(u<<6)|(n<<1)|(s&0x1f));
1629}
1630
1631static void
1632_nop(jit_state_t *_jit, jit_int32_t i0)
1633{
1634 for (; i0 > 0; i0 -= 4)
1635 NOP();
1636 assert(i0 == 0);
1637}
1638
1639static void
1640_movr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1641{
1642 if (r0 != r1)
1643 COPY(r1, r0);
1644}
1645
1646static void
1647_movi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1648{
1649 if (i0 >= -8192 && i0 <= 8191)
1650 LDI(i0, r0);
1651 else if (!(i0 & 0x7ff))
1652 LDIL(i0, r0);
1653 else {
1654 LDIL(i0 & ~0x7ff, r0);
1655 LDO(i0 & 0x7ff, r0, r0);
1656 }
1657}
1658
1659static jit_word_t
1660_movi_p(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1661{
1662 jit_word_t w;
1663 w = _jit->pc.w;
1664 LDIL(i0 & ~0x7ff, r0);
1665 LDO(i0 & 0x7ff, r0, r0);
1666 return (w);
1667}
1668
79bfeef6
PC		 1669static void
1670_bswapr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1671{
1672 jit_int32_t reg;
1673 if (r0 == r1) {
1674 reg = jit_get_reg(jit_class_gpr);
1675 movr(rn(reg), r1);
1676 EXTRWR_U(rn(reg), 23, 8, r0);
1677 DEPWR(rn(reg), 23, 8, r0);
1678 jit_unget_reg(reg);
1679 }
1680 else {
1681 EXTRWR_U(r1, 23, 8, r0);
1682 DEPWR(r1, 23, 8, r0);
1683 }
1684}
1685
1686static void
1687_bswapr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1688{
1689 jit_int32_t reg;
1690 if (r0 == r1) {
1691 reg = jit_get_reg(jit_class_gpr);
1692 movr(rn(reg), r1);
1693 SHRPWI(rn(reg), rn(reg), 16, r0);
1694 DEPWR(r0, 15, 8, r0);
1695 SHRPWI(rn(reg), r0, 8, r0);
1696 jit_unget_reg(reg);
1697 }
1698 else {
1699 SHRPWI(r1, r1, 16, r0);
1700 DEPWR(r0, 15, 8, r0);
1701 SHRPWI(r1, r0, 8, r0);
1702 }
1703}
1704
40a44dcb
PC		 1705static void
1706_movnr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1707{
1708 jit_word_t w;
1709 w = beqi(_jit->pc.w, r2, 0);
1710 COPY(r1, r0);
1711 patch_at(w, _jit->pc.w);
1712}
1713
1714static void
1715_movzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1716{
1717 jit_word_t w;
1718 w = bnei(_jit->pc.w, r2, 0);
1719 COPY(r1, r0);
1720 patch_at(w, _jit->pc.w);
1721}
1722
ba86ff93
PC		 1723static void
1724_extr(jit_state_t *_jit,
1725 jit_int32_t r0, jit_int32_t r1, jit_word_t i0, jit_word_t i1)
1726{
1727 assert(i0 >= 0 && i1 >= 1 && i0 + i1 <= __WORDSIZE);
1728 if ( i1 == __WORDSIZE)
1729 movr(r0, r1);
1730 else {
1731# if __BYTE_ORDER == __BIG_ENDIAN
1732 i0 = __WORDSIZE - (i0 + i1);
1733# endif
1734 EXTRWR(r1, 32 - (i0 + 1), i1, r0);
1735 }
1736}
1737
1738static void
1739_extr_u(jit_state_t *_jit,
1740 jit_int32_t r0, jit_int32_t r1, jit_word_t i0, jit_word_t i1)
1741{
1742 assert(i0 >= 0 && i1 >= 1 && i0 + i1 <= __WORDSIZE);
1743 if (i1 == __WORDSIZE)
1744 movr(r0, r1);
1745 else {
1746# if __BYTE_ORDER == __BIG_ENDIAN
1747 i0 = __WORDSIZE - (i0 + i1);
1748# endif
1749 EXTRWR_U(r1, 32 - (i0 + 1), i1, r0);
1750 }
1751}
1752
1753static void
1754_depr(jit_state_t *_jit,
1755 jit_int32_t r0, jit_int32_t r1, jit_word_t i0, jit_word_t i1)
1756{
1757 jit_int32_t t0;
1758 jit_word_t mask;
1759 assert(i0 >= 0 && i1 >= 1 && i0 + i1 <= __WORDSIZE);
1760 if (i1 == __WORDSIZE)
1761 movr(r0, r1);
1762 else {
1763# if __BYTE_ORDER == __BIG_ENDIAN
1764 i0 = __WORDSIZE - (i0 + i1);
1765# endif
1766 DEPWR(r1, 32 - (i0 + 1), i1, r0);
1767 }
1768}
1769
ba3814c1
PC		 1770static void
1771_casx(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1772 jit_int32_t r2, jit_int32_t r3, jit_word_t i0)
1773{
c0c16242
PC		 1774#if defined(__linux__) && defined(SYS_atomic_cmpxchg_32) && __WORDSIZE == 32
1775 /* Not defined, and unlikely to ever be defined, but could be a way to do it */
1776 movi(_R26_REGNO, SYS_atomic_cmpxchg_32);
1777 if (r1 == _NOREG)
1778 movi(_R25_REGNO, i0);
1779 else
1780 movr(_R25_REGNO, r1);
1781 movr(_R24_REGNO, r2);
1782 movr(_R23_REGNO, r3);
1783 /* Should only fail for an invalid or unaligned address.
1784 * Do not handle this condition. */
1785 calli(syscall);
1786 movr(r0, _R28_REGNO);
1787#else
1788 /*
1789 * The only atomic operations are LDCW and LDCD, that load a value,
1790 * and store zero at the address atomically. The (semaphore) address
1791 * must be 16 byte aligned.
1792 */
ba3814c1 1793 fallback_casx(r0, r1, r2, r3, i0);
c0c16242
PC		 1794 /*
1795 * It is important to be aware of the delayed nature of cache flush and
1796 * purge operations, and to use SYNC instructions to force completion
1797 * where necessary. The following example illustrates this.
1798 * Consider two processes sharing a memory location x which is protected
1799 * by a semaphore s.
1800 *
1801 * process A on Processor 1 | process B on Processor 2 | note
1802 * -------------------------+---------------------------+------------
1803 * LDCW s | | A acquires semaphore
1804 * PDC x | | A executes purge
1805 * SYNC | | Force completion of purge
1806 * STW s | | A releases semaphore
1807 * | LDCW s | B acquires semaphore
1808 * | STW x
1809 *
1810 * In the absence of the SYNC instruction, it would be possible for
1811 * process B's store to x to complete before the purge of x is completed
1812 * (since the purge may have been delayed). The purge of x could then
1813 * destroy the new value.
1814 */
1815#endif
ba3814c1
PC		 1816}
1817
4a71579b
PC		 1818static void
1819_addi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1820{
1821 jit_int32_t reg;
1822 if (i0 >= -1024 && i0 <= 1023)
1823 ADDI(i0, r1, r0);
1824 else {
1825 reg = jit_get_reg(jit_class_gpr);
1826 movi(rn(reg), i0);
1827 addr(r0, r1, rn(reg));
1828 jit_unget_reg(reg);
1829 }
1830}
1831
1832static void
1833_addci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1834{
1835 jit_int32_t reg;
1836 reg = jit_get_reg(jit_class_gpr);
1837 movi(rn(reg), i0);
1838 addcr(r0, r1, rn(reg));
1839 jit_unget_reg(reg);
1840}
1841
1842static void
1843_addxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1844{
1845 jit_int32_t reg;
1846 reg = jit_get_reg(jit_class_gpr);
1847 movi(rn(reg), i0);
1848 addxr(r0, r1, rn(reg));
1849 jit_unget_reg(reg);
1850}
1851
1852static void
1853_subi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1854{
1855 jit_int32_t reg;
1856 if (i0 >= -1023 && i0 <= 1024)
1857 addi(r0, r1, -i0);
1858 else {
1859 reg = jit_get_reg(jit_class_gpr);
1860 movi(rn(reg), i0);
1861 subr(r0, r1, rn(reg));
1862 jit_unget_reg(reg);
1863 }
1864}
1865
1866static void
1867_subci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1868{
1869 jit_int32_t reg;
1870 reg = jit_get_reg(jit_class_gpr);
1871 movi(rn(reg), i0);
1872 subcr(r0, r1, rn(reg));
1873 jit_unget_reg(reg);
1874}
1875
1876static void
1877_subxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1878{
1879 jit_int32_t reg;
1880 reg = jit_get_reg(jit_class_gpr);
1881 movi(rn(reg), i0);
1882 subxr(r0, r1, rn(reg));
1883 jit_unget_reg(reg);
1884}
1885
1886static void
1887_rsbi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1888{
1889 jit_int32_t reg;
1890 if (i0 >= -1024 && i0 <= 1023)
1891 SUBI(i0, r1, r0);
1892 else {
1893 reg = jit_get_reg(jit_class_gpr);
1894 movi(rn(reg), i0);
1895 subr(r0, rn(reg), r1);
1896 jit_unget_reg(reg);
1897 }
1898}
1899
1900static void
1901_mulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1902{
1903 jit_int32_t t0, t1;
1904 t0 = jit_get_reg(jit_class_fpr);
1905 t1 = jit_get_reg(jit_class_fpr);
1906 stxi(alloca_offset - 8, _FP_REGNO, r1);
1907 ldxi_f(rn(t0), _FP_REGNO, alloca_offset - 8);
1908 stxi(alloca_offset - 8, _FP_REGNO, r2);
1909 ldxi_f(rn(t1), _FP_REGNO, alloca_offset - 8);
1910 XMPYU(rn(t0), rn(t1), rn(t0));
1911 stxi_d(alloca_offset - 8, _FP_REGNO, rn(t0));
1912 ldxi(r0, _FP_REGNO, alloca_offset - 4);
1913 jit_unget_reg(t1);
1914 jit_unget_reg(t0);
1915}
1916
1917static void
1918_muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1919{
1920 jit_int32_t reg;
1921 if (r0 != r1) {
1922 movi(r0, i0);
1923 mulr(r0, r1, r0);
1924 }
1925 else {
1926 reg = jit_get_reg(jit_class_gpr);
1927 movi(rn(reg), i0);
1928 mulr(r0, r1, rn(reg));
1929 jit_unget_reg(reg);
1930 }
1931}
1932
1933static long long
1934__llmul(int u, int v)
1935{
1936 return ((long long)u * (long long)v);
1937}
1938
1939static void
1940_qmulr(jit_state_t *_jit,
1941 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
1942{
1943 movr(_R26_REGNO, r2);
1944 movr(_R25_REGNO, r3);
1945 calli((jit_word_t)__llmul);
ba86ff93
PC		 1946 if (r0 != JIT_NOREG)
1947 movr(r0, _R29_REGNO);
4a71579b
PC		 1948 movr(r1, _R28_REGNO);
1949}
1950
1951static void
1952_qmuli(jit_state_t *_jit,
1953 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
1954{
1955 movr(_R26_REGNO, r2);
1956 movi(_R25_REGNO, i0);
1957 calli((jit_word_t)__llmul);
ba86ff93
PC		 1958 if (r0 != JIT_NOREG)
1959 movr(r0, _R29_REGNO);
4a71579b
PC		 1960 movr(r1, _R28_REGNO);
1961}
1962
1963static void
1964_qmulr_u(jit_state_t *_jit,
1965 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
1966{
1967 jit_int32_t t0, t1;
1968 t0 = jit_get_reg(jit_class_fpr);
1969 t1 = jit_get_reg(jit_class_fpr);
1970 stxi(alloca_offset - 8, _FP_REGNO, r2);
1971 ldxi_f(rn(t0), _FP_REGNO, alloca_offset - 8);
1972 stxi(alloca_offset - 8, _FP_REGNO, r3);
1973 ldxi_f(rn(t1), _FP_REGNO, alloca_offset - 8);
1974 XMPYU(rn(t0), rn(t1), rn(t0));
1975 stxi_d(alloca_offset - 8, _FP_REGNO, rn(t0));
ba86ff93
PC		 1976 if (r0 != JIT_NOREG)
1977 ldxi(r0, _FP_REGNO, alloca_offset - 4);
4a71579b
PC		 1978 ldxi(r1, _FP_REGNO, alloca_offset - 8);
1979 jit_unget_reg(t1);
1980 jit_unget_reg(t0);
1981}
1982
1983static void
1984_qmuli_u(jit_state_t *_jit,
1985 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
1986{
1987 jit_int32_t reg;
1988 reg = jit_get_reg(jit_class_gpr);
1989 movi(rn(reg), i0);
1990 qmulr_u(r0, r1, r2, rn(reg));
1991 jit_unget_reg(reg);
1992}
1993
1994static int
1995__idiv(int u, int v)
1996{
1997 return (u / v);
1998}
1999
2000static void
2001_divr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2002{
2003 movr(_R26_REGNO, r1);
2004 movr(_R25_REGNO, r2);
2005 calli((jit_word_t)__idiv);
2006 movr(r0, _R28_REGNO);
2007}
2008
2009static void
2010_divi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2011{
2012 movr(_R26_REGNO, r1);
2013 movi(_R25_REGNO, i0);
2014 calli((jit_word_t)__idiv);
2015 movr(r0, _R28_REGNO);
2016}
2017
2018static unsigned int
2019__udiv(unsigned int u, unsigned int v)
2020{
2021 return (u / v);
2022}
2023
2024static void
2025_divr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2026{
2027 movr(_R26_REGNO, r1);
2028 movr(_R25_REGNO, r2);
2029 calli((jit_word_t)__udiv);
2030 movr(r0, _R28_REGNO);
2031}
2032
2033static void
2034_divi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2035{
2036 movr(_R26_REGNO, r1);
2037 movi(_R25_REGNO, i0);
2038 calli((jit_word_t)__udiv);
2039 movr(r0, _R28_REGNO);
2040}
2041
2042static int
2043__irem(int u, int v)
2044{
2045 return (u % v);
2046}
2047
2048static void
2049_remr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2050{
2051 movr(_R26_REGNO, r1);
2052 movr(_R25_REGNO, r2);
2053 calli((jit_word_t)__irem);
2054 movr(r0, _R28_REGNO);
2055}
2056
2057static void
2058_remi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2059{
2060 movr(_R26_REGNO, r1);
2061 movi(_R25_REGNO, i0);
2062 calli((jit_word_t)__irem);
2063 movr(r0, _R28_REGNO);
2064}
2065
2066static unsigned int
2067__urem(unsigned int u, unsigned int v)
2068{
2069 return (u % v);
2070}
2071
2072static void
2073_remr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2074{
2075 movr(_R26_REGNO, r1);
2076 movr(_R25_REGNO, r2);
2077 calli((jit_word_t)__urem);
2078 movr(r0, _R28_REGNO);
2079}
2080
2081static void
2082_remi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2083{
2084 movr(_R26_REGNO, r1);
2085 movi(_R25_REGNO, i0);
2086 calli((jit_word_t)__urem);
2087 movr(r0, _R28_REGNO);
2088}
2089
2090static idiv_t
2091__idivrem(int u, int v)
2092{
2093 idiv_t div;
2094 div.quo = u / v;
2095 div.rem = u % v;
2096 return (div);
2097}
2098
2099static void
2100_qdivr(jit_state_t *_jit,
2101 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
2102{
2103 movr(_R26_REGNO, r2);
2104 movr(_R25_REGNO, r3);
2105 calli((jit_word_t)__idivrem);
2106 movr(r0, _R28_REGNO);
2107 movr(r1, _R29_REGNO);
2108}
2109
2110static void
2111_qdivi(jit_state_t *_jit,
2112 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
2113{
2114 movr(_R26_REGNO, r2);
2115 movi(_R25_REGNO, i0);
2116 calli((jit_word_t)__idivrem);
2117 movr(r0, _R28_REGNO);
2118 movr(r1, _R29_REGNO);
2119}
2120
2121static udiv_t
2122__udivrem(unsigned int u, unsigned int v)
2123{
2124 udiv_t div;
2125 div.quo = u / v;
2126 div.rem = u % v;
2127 return (div);
2128}
2129
2130static void
2131_qdivr_u(jit_state_t *_jit,
2132 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
2133{
2134 movr(_R26_REGNO, r2);
2135 movr(_R25_REGNO, r3);
2136 calli((jit_word_t)__udivrem);
2137 movr(r0, _R28_REGNO);
2138 movr(r1, _R29_REGNO);
2139}
2140
2141static void
2142_qdivi_u(jit_state_t *_jit,
2143 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
2144{
2145 movr(_R26_REGNO, r2);
2146 movi(_R25_REGNO, i0);
2147 calli((jit_word_t)__udivrem);
2148 movr(r0, _R28_REGNO);
2149 movr(r1, _R29_REGNO);
2150}
2151
2152static void
2153_andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2154{
2155 jit_int32_t reg;
2156 reg = jit_get_reg(jit_class_gpr);
2157 movi(rn(reg), i0);
2158 andr(r0, r1, rn(reg));
2159 jit_unget_reg(reg);
2160}
2161
2162static void
2163_ori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2164{
2165 jit_int32_t reg;
2166 reg = jit_get_reg(jit_class_gpr);
2167 movi(rn(reg), i0);
2168 orr(r0, r1, rn(reg));
2169 jit_unget_reg(reg);
2170}
2171
2172static void
2173_xori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2174{
2175 jit_int32_t reg;
2176 reg = jit_get_reg(jit_class_gpr);
2177 movi(rn(reg), i0);
2178 xorr(r0, r1, rn(reg));
2179 jit_unget_reg(reg);
2180}
2181
2182static void
2183_lshr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
2184{
2185 SUBI(0x1f, r2, _R1_REGNO);
2186 MTSAR(_R1_REGNO);
2187 DEPW_Z(r1, 32, r0);
2188}
2189
2190static void
2191_rshr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
2192{
2193 SUBI(0x1f, r2, _R1_REGNO);
2194 MTSAR(_R1_REGNO);
2195 EXTRW(r1, 32, r0);
2196}
2197
2198static void
2199_rshr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
2200{
2201 SUBI(0x1f, r2, _R1_REGNO);
2202 MTSAR(_R1_REGNO);
2203 EXTRW_U(r1, 32, r0);
2204}
2205
ba86ff93
PC		 2206static void
2207_lrotr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
2208{
2209 fallback_lrotr(r0, r1, r2);
2210}
2211
2212static void
2213_rrotr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
2214{
2215 fallback_rrotr(r0, r1, r2);
2216}
2217
2218static void
2219_rroti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_word_t i0)
2220{
2221 movr(r0, r1);
2222 SHRPWI(r0, r0, i0, r0);
2223}
2224
4a71579b
PC		 2225static void
2226_cmpr(jit_state_t *_jit, jit_word_t c,
2227 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2228{
2229 CMPCLR_(c, r1, r2, r0);
2230 LDI(1, r0);
2231}
2232
2233static void
2234_cmpi(jit_state_t *_jit, jit_word_t c, jit_word_t ci,
2235 jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2236{
2237 jit_int32_t reg;
2238 if (i0 >= -16 && i0 <= 15)
2239 CMPICLR_(ci, i0, r1, r0);
2240 else {
2241 reg = jit_get_reg(jit_class_gpr);
2242 movi(rn(reg), i0);
2243 CMPCLR_(c, r1, rn(reg), r0);
2244 jit_unget_reg(reg);
2245 }
2246 LDI(1, r0);
2247}
2248
2249static void
2250_ldr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2251{
2252 ldr_uc(r0, r1);
2253 extr_c(r0, r0);
2254}
2255
2256static void
2257_ldi_c(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2258{
2259 ldi_uc(r0, i0);
2260 extr_c(r0, r0);
2261}
2262
2263static void
2264_ldxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2265{
2266 ldxr_uc(r0, r1, r2);
2267 extr_c(r0, r0);
2268}
2269
2270static void
2271_ldxi_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2272{
2273 ldxi_uc(r0, r1, i0);
2274 extr_c(r0, r0);
2275}
2276
2277static void
2278_ldi_uc(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2279{
2280 jit_int32_t reg;
ba86ff93
PC		 2281 if (jit_imm_idx_p()) {
2282 if (i0 >= -8182 && i0 <= 8191)
2283 LDBL(i0, _R0_REGNO, r0);
2284 else {
2285 reg = jit_get_reg(jit_class_gpr);
2286 LDIL(i0 & ~0x7ff, rn(reg));
2287 LDBL(sign_extend(i0, 11), rn(reg), r0);
2288 jit_unget_reg(reg);
2289 }
2290 }
4a71579b
PC		 2291 else {
2292 reg = jit_get_reg(jit_class_gpr);
ba86ff93
PC		 2293 movi(rn(reg), i0);
2294 ldr_uc(r0, rn(reg));
4a71579b
PC		 2295 jit_unget_reg(reg);
2296 }
2297}
2298
2299static void
2300_ldxi_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2301{
2302 jit_int32_t reg;
ba86ff93 2303 if (jit_imm_idx_p() && (i0 >= -16 && i0 <= 15))
4a71579b 2304 LDBI(i0, r1, r0);
ba86ff93 2305 else if (jit_imm_idx_p() && (i0 >= -8182 && i0 <= 8191))
4a71579b
PC		 2306 LDBL(i0, r1, r0);
2307 else {
2308 reg = jit_get_reg(jit_class_gpr);
2309 movi(rn(reg), i0);
2310 ldxr_uc(r0, r1, rn(reg));
2311 jit_unget_reg(reg);
2312 }
2313}
2314
2315static void
2316_ldr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2317{
2318 ldr_us(r0, r1);
2319 extr_s(r0, r0);
2320}
2321
2322static void
2323_ldi_s(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2324{
2325 ldi_us(r0, i0);
2326 extr_s(r0, r0);
2327}
2328
2329static void
2330_ldxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2331{
2332 ldxr_us(r0, r1, r2);
2333 extr_s(r0, r0);
2334}
2335
2336static void
2337_ldxi_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2338{
2339 ldxi_us(r0, r1, i0);
2340 extr_s(r0, r0);
2341}
2342
2343static void
2344_ldi_us(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2345{
2346 jit_int32_t reg;
ba86ff93
PC		 2347 if (jit_imm_idx_p()) {
2348 if (i0 >= -8182 && i0 <= 8191)
2349 LDHL(i0, _R0_REGNO, r0);
2350 else {
2351 reg = jit_get_reg(jit_class_gpr);
2352 LDIL(i0 & ~0x7ff, rn(reg));
2353 LDHL(sign_extend(i0, 11), rn(reg), r0);
2354 jit_unget_reg(reg);
2355 }
2356 }
4a71579b
PC		 2357 else {
2358 reg = jit_get_reg(jit_class_gpr);
ba86ff93
PC		 2359 movi(rn(reg), i0);
2360 ldr_us(r0, rn(reg));
4a71579b
PC		 2361 jit_unget_reg(reg);
2362 }
2363}
2364
2365static void
2366_ldxi_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2367{
2368 jit_int32_t reg;
ba86ff93 2369 if (jit_imm_idx_p() && (i0 >= -16 && i0 <= 15))
4a71579b 2370 LDHI(i0, r1, r0);
ba86ff93 2371 else if (jit_imm_idx_p() && (i0 >= -8182 && i0 <= 8191))
4a71579b
PC		 2372 LDHL(i0, r1, r0);
2373 else {
2374 reg = jit_get_reg(jit_class_gpr);
2375 movi(rn(reg), i0);
2376 ldxr_us(r0, r1, rn(reg));
2377 jit_unget_reg(reg);
2378 }
2379}
2380
2381static void
2382_ldi_ui(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2383{
2384 jit_int32_t reg;
ba86ff93
PC		 2385 if (jit_imm_idx_p()) {
2386 if (i0 >= -8182 && i0 <= 8191)
2387 LDWL(i0, _R0_REGNO, r0);
2388 else {
2389 reg = jit_get_reg(jit_class_gpr);
2390 LDIL(i0 & ~0x7ff, rn(reg));
2391 LDWL(sign_extend(i0, 11), rn(reg), r0);
2392 jit_unget_reg(reg);
2393 }
2394 }
4a71579b
PC		 2395 else {
2396 reg = jit_get_reg(jit_class_gpr);
ba86ff93
PC		 2397 movi(rn(reg), i0);
2398 ldr_ui(r0, rn(reg));
4a71579b
PC		 2399 jit_unget_reg(reg);
2400 }
2401}
2402
2403static void
2404_ldxi_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2405{
2406 jit_int32_t reg;
ba86ff93 2407 if (jit_imm_idx_p() && (i0 >= -16 && i0 <= 15))
4a71579b 2408 LDWI(i0, r1, r0);
ba86ff93 2409 else if (jit_imm_idx_p() && (i0 >= -8182 && i0 <= 8191))
4a71579b
PC		 2410 LDWL(i0, r1, r0);
2411 else {
2412 reg = jit_get_reg(jit_class_gpr);
2413 movi(rn(reg), i0);
2414 ldxr_ui(r0, r1, rn(reg));
2415 jit_unget_reg(reg);
2416 }
2417}
2418
2419static void
2420_sti_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2421{
2422 jit_int32_t reg;
ba86ff93
PC		 2423 if (jit_imm_idx_p()) {
2424 if (i0 >= -8182 && i0 <= 8191)
2425 STBL(r0, i0, _R0_REGNO);
2426 else {
2427 reg = jit_get_reg(jit_class_gpr);
2428 LDIL(i0 & ~0x7ff, rn(reg));
2429 STBL(r0, sign_extend(i0, 11), rn(reg));
2430 jit_unget_reg(reg);
2431 }
2432 }
4a71579b
PC		 2433 else {
2434 reg = jit_get_reg(jit_class_gpr);
ba86ff93
PC		 2435 movi(rn(reg), i0);
2436 str_c(rn(reg), r0);
4a71579b
PC		 2437 jit_unget_reg(reg);
2438 }
2439}
2440
2441static void
2442_stxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2443{
2444 jit_int32_t reg;
2445 reg = jit_get_reg(jit_class_gpr);
2446 addr(rn(reg), r0, r1);
2447 str_c(rn(reg), r2);
2448 jit_unget_reg(reg);
2449}
2450
2451static void
2452_stxi_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2453{
2454 jit_int32_t reg;
ba86ff93 2455 if (jit_imm_idx_p() && (i0 >= -16 && i0 <= 15))
4a71579b 2456 STBI(r1, i0, r0);
ba86ff93 2457 else if (jit_imm_idx_p() && (i0 >= -8182 && i0 <= 8191))
4a71579b
PC		 2458 STBL(r1, i0, r0);
2459 else {
2460 reg = jit_get_reg(jit_class_gpr);
2461 addi(rn(reg), r0, i0);
2462 str_c(rn(reg), r1);
2463 jit_unget_reg(reg);
2464 }
2465}
2466
2467static void
2468_sti_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2469{
2470 jit_int32_t reg;
ba86ff93
PC		 2471 if (jit_imm_idx_p()) {
2472 if (i0 >= -8182 && i0 <= 8191)
2473 STHL(r0, i0, _R0_REGNO);
2474 else {
2475 reg = jit_get_reg(jit_class_gpr);
2476 LDIL(i0 & ~0x7ff, rn(reg));
2477 STHL(r0, sign_extend(i0, 11), rn(reg));
2478 jit_unget_reg(reg);
2479 }
2480 }
4a71579b
PC		 2481 else {
2482 reg = jit_get_reg(jit_class_gpr);
ba86ff93
PC		 2483 movi(rn(reg), i0);
2484 str_s(rn(reg), r0);
4a71579b
PC		 2485 jit_unget_reg(reg);
2486 }
2487}
2488
2489static void
2490_stxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
2491{
2492 jit_int32_t reg;
2493 reg = jit_get_reg(jit_class_gpr);
2494 addr(rn(reg), r0, r1);
2495 str_s(rn(reg), r2);
2496 jit_unget_reg(reg);
2497}
2498
2499static void
2500_stxi_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2501{
2502 jit_int32_t reg;
ba86ff93 2503 if (jit_imm_idx_p() && (i0 >= -16 && i0 <= 15))
4a71579b 2504 STHI(r1, i0, r0);
ba86ff93 2505 else if (jit_imm_idx_p() && (i0 >= -8182 && i0 <= 8191))
4a71579b
PC		 2506 STHL(r1, i0, r0);
2507 else {
2508 reg = jit_get_reg(jit_class_gpr);
2509 addi(rn(reg), r0, i0);
2510 str_s(rn(reg), r1);
2511 jit_unget_reg(reg);
2512 }
2513}
2514
2515static void
2516_sti_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2517{
2518 jit_int32_t reg;
ba86ff93
PC		 2519 if (jit_imm_idx_p()) {
2520 if (i0 >= -8182 && i0 <= 8191)
2521 STWL(r0, i0, _R0_REGNO);
2522 else {
2523 reg = jit_get_reg(jit_class_gpr);
2524 LDIL(i0 & ~0x7ff, rn(reg));
2525 STWL(r0, sign_extend(i0, 11), rn(reg));
2526 jit_unget_reg(reg);
2527 }
2528 }
4a71579b
PC		 2529 else {
2530 reg = jit_get_reg(jit_class_gpr);
ba86ff93
PC		 2531 movi(rn(reg), i0);
2532 str_i(rn(reg), r0);
4a71579b
PC		 2533 jit_unget_reg(reg);
2534 }
2535}
2536
2537static void
2538_stxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
2539{
2540 jit_int32_t reg;
2541 reg = jit_get_reg(jit_class_gpr);
2542 addr(rn(reg), r0, r1);
2543 str_i(rn(reg), r2);
2544 jit_unget_reg(reg);
2545}
2546
2547static void
2548_stxi_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2549{
2550 jit_int32_t reg;
ba86ff93 2551 if (jit_imm_idx_p() && (i0 >= -16 && i0 <= 15))
4a71579b 2552 STWI(r1, i0, r0);
ba86ff93 2553 else if (jit_imm_idx_p() && (i0 >= -8182 && i0 <= 8191))
4a71579b
PC		 2554 STWL(r1, i0, r0);
2555 else {
2556 reg = jit_get_reg(jit_class_gpr);
2557 addi(rn(reg), r0, i0);
2558 str_i(rn(reg), r1);
2559 jit_unget_reg(reg);
2560 }
2561}
2562
2563static jit_word_t
2564_bcmpr(jit_state_t *_jit, jit_word_t c,
2565 jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2566{
2567 jit_word_t w;
2568 w = _jit->pc.w;
2569 CMPB_N_(c, r0, r1, ((i0 - w) >> 2) - 2);
2570 NOP();
2571 return (w);
2572}
2573
2574static jit_word_t
2575_bcmpi(jit_state_t *_jit, jit_word_t c, jit_word_t ci,
2576 jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2577{
2578 jit_word_t w;
2579 jit_int32_t reg;
2580 if (i1 >= -16 && i1 <= 15) {
2581 w = _jit->pc.w;
2582 CMPIB_N_(ci, i1, r0, ((i0 - w) >> 2) - 2);
2583 }
2584 else {
2585 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2586 movi(rn(reg), i1);
2587 w = _jit->pc.w;
2588 CMPB_N_(c, r0, rn(reg), ((i0 - w) >> 2) - 2);
2589 jit_unget_reg(reg);
2590 }
2591 NOP();
2592 return (w);
2593}
2594
2595static jit_word_t
2596_bmxr(jit_state_t *_jit, jit_bool_t c,
2597 jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2598{
2599 jit_word_t w;
2600 jit_int32_t reg;
2601 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2602 andr(rn(reg), r0, r1);
2603 w = c ? bnei(i0, rn(reg), 0) : beqi(i0, rn(reg), 0);
2604 jit_unget_reg(reg);
2605 return (w);
2606}
2607
2608static jit_word_t
2609_bmxi(jit_state_t *_jit, jit_bool_t c,
2610 jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2611{
2612 jit_word_t w;
2613 jit_int32_t reg;
2614 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2615 movi(rn(reg), i1);
2616 andr(rn(reg), r0, rn(reg));
2617 w = c ? bnei(i0, rn(reg), 0) : beqi(i0, rn(reg), 0);
2618 jit_unget_reg(reg);
2619 return (w);
2620}
2621
2622static jit_word_t
2623_boaddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2624{
2625 jit_word_t w;
2626 w = _jit->pc.w;
2627 ADDB_N_SV(r1, r0, ((i0 - w) >> 2) - 2);
2628 NOP();
2629 return (w);
2630}
2631
2632static jit_word_t
2633_boaddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2634{
2635 jit_word_t w;
2636 jit_int32_t reg;
2637 if (i1 >= -16 && i1 <= 15) {
2638 w = _jit->pc.w;
2639 ADDIB_N_SV(i1, r0, ((i0 - w) >> 2) - 2);
2640 NOP();
2641 }
2642 else {
2643 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2644 movi(rn(reg), i1);
2645 w = boaddr(i0, r0, rn(reg));
2646 jit_unget_reg(reg);
2647 }
2648 return (w);
2649}
2650
2651static jit_word_t
2652_boaddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2653{
2654 jit_word_t w;
2655 w = _jit->pc.w;
2656 ADDB_N_UV(r1, r0, ((i0 - w) >> 2) - 2);
2657 NOP();
2658 return (w);
2659}
2660
2661static jit_word_t
2662_boaddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2663{
2664 jit_word_t w;
2665 jit_int32_t reg;
2666 if (i1 >= -16 && i1 <= 15) {
2667 w = _jit->pc.w;
2668 ADDIB_N_UV(i1, r0, ((i0 - w) >> 2) - 2);
2669 NOP();
2670 }
2671 else {
2672 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2673 movi(rn(reg), i1);
2674 w = boaddr_u(i0, r0, rn(reg));
2675 jit_unget_reg(reg);
2676 }
2677 return (w);
2678}
2679
2680static jit_word_t
2681_bxaddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2682{
2683 jit_word_t w;
2684 w = _jit->pc.w;
2685 ADDB_N_NSV(r1, r0, ((i0 - w) >> 2) - 2);
2686 NOP();
2687 return (w);
2688}
2689
2690static jit_word_t
2691_bxaddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2692{
2693 jit_word_t w;
2694 jit_int32_t reg;
2695 if (i1 >= -16 && i1 <= 15) {
2696 w = _jit->pc.w;
2697 ADDIB_N_NSV(i1, r0, ((i0 - w) >> 2) - 2);
2698 NOP();
2699 }
2700 else {
2701 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2702 movi(rn(reg), i1);
2703 w = bxaddr(i0, r0, rn(reg));
2704 jit_unget_reg(reg);
2705 }
2706 return (w);
2707}
2708
2709static jit_word_t
2710_bxaddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2711{
2712 jit_word_t w;
2713 w = _jit->pc.w;
2714 ADDB_N_NUV(r1, r0, ((i0 - w) >> 2) - 2);
2715 NOP();
2716 return (w);
2717}
2718
2719static jit_word_t
2720_bxaddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2721{
2722 jit_word_t w;
2723 jit_int32_t reg;
2724 if (i1 >= -16 && i1 <= 15) {
2725 w = _jit->pc.w;
2726 ADDIB_N_NUV(i1, r0, ((i0 - w) >> 2) - 2);
2727 NOP();
2728 }
2729 else {
2730 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2731 movi(rn(reg), i1);
2732 w = bxaddr_u(i0, r0, rn(reg));
2733 jit_unget_reg(reg);
2734 }
2735 return (w);
2736}
2737
2738static jit_word_t
2739_bosubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2740{
2741 jit_word_t w;
2742 SUB_NSV(r0, r1, r0);
2743 w = _jit->pc.w;
2744 /* null'ed if no signed overflow */
2745 B_N(((i0 - w) >> 2) - 2, _R0_REGNO);
2746 NOP();
2747 return (w);
2748}
2749
2750static jit_word_t
2751_bosubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2752{
2753 movi(_R1_REGNO, i1);
2754 return (bosubr(i0, r0, _R1_REGNO));
2755}
2756
2757static jit_word_t
2758_bosubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2759{
2760 SUB(r0, r1, r0);
2761 SUB_B(_R0_REGNO, _R0_REGNO, _R1_REGNO);
2762 return (bnei(i0, _R1_REGNO, 0));
2763}
2764
2765static jit_word_t
2766_bosubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2767{
2768 movi(_R1_REGNO, i1);
2769 SUB(r0, _R1_REGNO, r0);
2770 SUB_B(_R0_REGNO, _R0_REGNO, _R1_REGNO);
2771 return (bnei(i0, _R1_REGNO, 0));
2772}
2773
2774static jit_word_t
2775_bxsubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2776{
2777 jit_word_t w;
2778 SUB_SV(r0, r1, r0);
2779 w = _jit->pc.w;
2780 /* null'ed if signed overflow */
2781 B_N(((i0 - w) >> 2) - 2, _R0_REGNO);
2782 NOP();
2783 return (w);
2784}
2785
2786static jit_word_t
2787_bxsubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2788{
2789 movi(_R1_REGNO, i1);
2790 return (bxsubr(i0, r0, _R1_REGNO));
2791}
2792
2793static jit_word_t
2794_bxsubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2795{
2796 SUB(r0, r1, r0);
2797 SUB_B(_R0_REGNO, _R0_REGNO, _R1_REGNO);
2798 return (beqi(i0, _R1_REGNO, 0));
2799}
2800
2801static jit_word_t
2802_bxsubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2803{
2804 movi(_R1_REGNO, i1);
2805 SUB(r0, _R1_REGNO, r0);
2806 SUB_B(_R0_REGNO, _R0_REGNO, _R1_REGNO);
2807 return (beqi(i0, _R1_REGNO, 0));
2808}
2809
2810static void
2811_jmpr(jit_state_t *_jit, jit_int32_t r0)
2812{
2813 BV_N(_R0_REGNO, r0);
2814}
2815
79bfeef6 2816static jit_word_t
4a71579b
PC		 2817_jmpi(jit_state_t *_jit, jit_word_t i0)
2818{
79bfeef6
PC		 2819 jit_word_t d, w;
2820 w = _jit->pc.w;
2821 d = ((i0 - w) >> 2) - 2;
2822 if (d >= -32768 && d <= 32767)
2823 B_N(d, _R0_REGNO);
4a71579b 2824 else {
79bfeef6 2825 movi(_R1_REGNO, d);
4a71579b
PC		 2826 BV_N(_R0_REGNO, _R1_REGNO);
2827 }
79bfeef6 2828 return (w);
4a71579b
PC		 2829}
2830
2831static jit_word_t
2832_jmpi_p(jit_state_t *_jit, jit_word_t i0)
2833{
2834 jit_word_t w;
2835 w = movi_p(_R1_REGNO, i0);
2836 jmpr(_R1_REGNO);
2837 return (w);
2838}
2839
2840static void
2841_callr(jit_state_t *_jit, jit_int32_t r0)
2842{
2843 jit_word_t dyn;
2844 jit_word_t imm;
2845 if (r0 != _R1_REGNO)
2846 COPY(r0, _R1_REGNO);
2847 /* inline $$dyncall */
2848 imm = _jit->pc.w;
2849 BBI_N_GE(_R1_REGNO, 30, 0); /* if (r1 & 2) { */
2850 DEPWRI(0, 31, 2, _R1_REGNO); /* r1 &= ~2; */
2851 LDWI(4, _R1_REGNO, _R19_REGNO); /* r19 = r1[1]; */
2852 LDWI(0, _R1_REGNO, _R1_REGNO); /* r1 = r1[0]; */
2853 /* } */
2854 BVE_L(_R1_REGNO);
2855 STWL(_RP_REGNO, -24, _SP_REGNO);
2856 dyn = _jit->pc.w;
2857 jmpi(_jit->pc.w);
2858 patch_at(imm, _jit->pc.w);
2859 BVE_L_N(_R1_REGNO);
2860 NOP();
2861 patch_at(dyn, _jit->pc.w);
2862}
2863
2864static void
2865_calli(jit_state_t *_jit, jit_word_t i0)
2866{
2867 jit_word_t w;
2868 if (i0 & 2) {
2869 i0 &= -4;
2870 movi(_R1_REGNO, i0);
2871 LDWI(4, _R1_REGNO, _R19_REGNO);
2872 LDWI(0, _R1_REGNO, _R1_REGNO);
2873 BVE_L(_R1_REGNO);
2874 STWL(_RP_REGNO, -24, _SP_REGNO);
2875 }
2876 else {
2877 w = ((i0 - _jit->pc.w) >> 2) - 2;
2878 if (w >= -32768 && w <= 32767)
2879 B_L_N(w);
2880 else {
2881 movi(_R1_REGNO, i0);
2882 BVE_L_N(_R1_REGNO);
2883 }
2884 NOP();
2885 }
2886}
2887
2888static jit_word_t
2889_calli_p(jit_state_t *_jit, jit_word_t i0)
2890{
2891 jit_word_t w;
2892 w = movi_p(_R1_REGNO, i0);
2893 callr(_R1_REGNO);
2894 return (w);
2895}
2896
2897static jit_int32_t gr[] = {
2898 _R4, _R5, _R6, _R7, _R8,
2899 _R9, _R10, _R11, _R12, _R13,
2900 _R14, _R15, _R16, _R17, _R18
2901};
2902
2903static jit_int32_t fr[] = {
2904 _F12, _F13, _F14, _F15, _F16,
2905 _F17, _F18, _F19, _F20, _F21
2906};
2907
2908static void
2909_prolog(jit_state_t *_jit, jit_node_t *node)
2910{
2911 jit_int32_t regno;
2912 jit_word_t offset;
2913
2914 if (_jitc->function->define_frame || _jitc->function->assume_frame) {
2915 /* hppa stack grows up */
2916 assert(_jitc->function->self.aoff <= _jitc->function->frame);
2917 if (_jitc->function->assume_frame)
2918 return;
2919 _jitc->function->self.aoff = _jitc->function->frame;
2920 }
2921 if (_jitc->function->allocar) {
2922 _jitc->function->self.aoff += 63;
2923 _jitc->function->self.aoff &= -64;
2924 }
2925 _jitc->function->stack = ((_jitc->function->self.aoff -
2926 _jitc->function->self.alen -
2927 _jitc->function->self.size) + 63) & -64;
2928
2929 /* Save stack frame (FIXME Only required if non leaf) */
2930 STWL(_RP_REGNO, -20, _SP_REGNO);
2931
2932 /* Create stack frame */
2933 COPY(_FP_REGNO, _R1_REGNO);
2934 COPY(_SP_REGNO, _FP_REGNO);
2935 STWL_MA(_R1_REGNO, _jitc->function->stack, _SP_REGNO);
2936
2937 /* Save any modified callee save registers */
2938 offset = alloca_offset - 140;
2939 for (regno = 0; regno < jit_size(gr); regno++, offset += 4) {
2940 if (jit_regset_tstbit(&_jitc->function->regset, gr[regno]))
2941 stxi(offset, _FP_REGNO, rn(gr[regno]));
2942 }
2943 for (regno = 0; regno < jit_size(fr); regno++, offset += 8) {
2944 if (jit_regset_tstbit(&_jitc->function->regset, fr[regno]))
2945 stxi_d(offset, _FP_REGNO, rn(fr[regno]));
2946 }
2947
2948 if (_jitc->function->allocar) {
2949 regno = jit_get_reg(jit_class_gpr);
2950 movi(rn(regno), _jitc->function->self.aoff);
2951 stxi_i(_jitc->function->aoffoff, _FP_REGNO, rn(regno));
2952 jit_unget_reg(regno);
2953 }
2954
2955 if (_jitc->function->self.call & jit_call_varargs) {
2956 for (regno = 3; regno >= _jitc->function->vagp; --regno)
2957 stxi(params_offset - regno * 4 - 4, _FP_REGNO, rn(_R26 - regno));
2958 }
2959}
2960
2961static void
2962_epilog(jit_state_t *_jit, jit_node_t *node)
2963{
2964 jit_int32_t regno;
2965 jit_word_t offset;
2966
2967 if (_jitc->function->assume_frame)
2968 return;
2969 /* Restore any modified callee save registers */
2970 offset = alloca_offset - 140;
2971 for (regno = 0; regno < jit_size(gr); regno++, offset += 4) {
2972 if (jit_regset_tstbit(&_jitc->function->regset, gr[regno]))
2973 ldxi(rn(gr[regno]), _FP_REGNO, offset);
2974 }
2975 for (regno = 0; regno < jit_size(fr); regno++, offset += 8) {
2976 if (jit_regset_tstbit(&_jitc->function->regset, fr[regno]))
2977 ldxi_d(rn(fr[regno]), _FP_REGNO, offset);
2978 }
2979
2980 /* Restore stack frame (FIXME Only required if non leaf) */
2981 LDWL(-20, _FP_REGNO, _RP_REGNO);
2982 LDO(_jitc->function->stack, _FP_REGNO, _SP_REGNO);
2983 LDWL_MB(-_jitc->function->stack, _SP_REGNO, _FP_REGNO);
2984#if defined(__hpux)
2985 BVE_N(_RP_REGNO);
2986#else
2987 BV_N(_R0_REGNO, _RP_REGNO);
2988#endif
2989}
2990
2991static void
2992_vastart(jit_state_t *_jit, jit_int32_t r0)
2993{
2994 /* Initialize stack pointer to the first stack argument. */
2995 if (jit_arg_reg_p(_jitc->function->vagp))
2996 addi(r0, _FP_REGNO, params_offset - _jitc->function->vagp * 4);
2997 else
2998 addi(r0, _FP_REGNO, _jitc->function->self.size);
2999}
3000
3001static void
3002_vaarg(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3003{
3004 assert(_jitc->function->self.call & jit_call_varargs);
3005
3006 /* Update vararg stack pointer. */
3007 subi(r1, r1, 4);
3008
3009 /* Load argument. */
3010 ldr(r0, r1);
3011}
3012
3013static void
3014_patch_at(jit_state_t *_jit, jit_word_t instr, jit_word_t label)
3015{
3016 jit_word_t w;
3017 union {
3018 jit_uint32_t *i;
3019 jit_word_t w;
3020 } u;
3021 u.w = instr;
3022 switch (u.i[0] >> 26) {
3023 case 0x8: /* LDIL */
3024 u.i[0] &= ~0x1fffff;
3025 u.i[0] |= re_assemble_21((label & ~0x7ff) >> 11);
3026 assert((u.i[1] >> 26) == 0xd); /* LDO */
3027 u.i[1] &= ~0xffff;
3028 u.i[1] |= re_assemble_16(label & 0x7ff);
3029 break;
3030 case 0x20: case 0x22: /* CMPB */
3031 case 0x21: case 0x23: /* CMPIB */
3032 case 0x28: case 0x2a: /* ADDB */
3033 case 0x29: case 0x2b: /* ADDIB */
3034 case 0x31: /* BBI */
3035 w = ((label - instr) >> 2) - 2;
3036 assert(w >= -2048 && w <= 2047);
3037 u.i[0] &= ~0x1ffd;
3038 u.i[0] |= re_assemble_12(w);
3039 break;
3040 case 0x3a: /* B */
3041 w = ((label - instr) >> 2) - 2;
3042 assert(w >= -32768 && w <= 32767);
3043 u.i[0] &= ~0x1f1ffd;
3044 u.i[0] |= re_assemble_17(w);
3045 break;
3046 default:
3047 abort();
3048 }
3049}
3050#endif
ARM optimized PCSX fork