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