Commit | Line | Data |
---|---|---|
4a71579b | 1 | /* |
79bfeef6 | 2 | * Copyright (C) 2013-2023 Free Software Foundation, Inc. |
4a71579b PC |
3 | * |
4 | * This file is part of GNU lightning. | |
5 | * | |
6 | * GNU lightning is free software; you can redistribute it and/or modify it | |
7 | * under the terms of the GNU Lesser General Public License as published | |
8 | * by the Free Software Foundation; either version 3, or (at your option) | |
9 | * any later version. | |
10 | * | |
11 | * GNU lightning is distributed in the hope that it will be useful, but | |
12 | * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY | |
13 | * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public | |
14 | * License for more details. | |
15 | * | |
16 | * Authors: | |
17 | * Paulo Cesar Pereira de Andrade | |
18 | */ | |
19 | ||
20 | #if PROTO | |
21 | ||
22 | /* FIXME should actually be hw model/version/etc or other constraint | |
23 | * that causes a SIGSEGV/SIGILL if using these instructions */ | |
24 | #if 1 //defined(__hpux) | |
25 | # define FSTXR 0 | |
26 | # define FLDXR 0 | |
27 | #else | |
28 | # define FSTXR 1 | |
29 | # define FLDXR 1 | |
30 | #endif | |
31 | ||
32 | #define f39(o,b,x,t) _f39(_jit,o,b,x,t) | |
33 | static void _f39(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); | |
34 | #define f40(o,b,x,r) _f40(_jit,o,b,x,r) | |
35 | static void _f40(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) | |
36 | maybe_unused; | |
37 | #define f41(o,b,x,t) _f41(_jit,o,b,x,t) | |
38 | static void _f41(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); | |
39 | #define f42(o,b,i,r) _f42(_jit,o,b,i,r) | |
40 | static void _f42(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); | |
41 | #define f43(o,b,t,i) f1(o,b,t,i) | |
42 | #define f45(o,r,a,b,fmt,c,d,e,t) _f45(_jit,o,r,a,b,fmt,c,d,e,t) | |
43 | static void _f45(jit_state_t*,jit_int32_t, | |
44 | jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t, | |
45 | jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused; | |
46 | #define f46(o,r,a,s,df,sf,b,c,d,t) _f46(_jit,o,r,a,s,df,sf,b,c,d,t) | |
47 | static void _f46(jit_state_t*,jit_int32_t,jit_int32_t, | |
48 | jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t, | |
49 | jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); | |
50 | #define f47(o,r1,r2,a,fmt,b,c,d,t) f47_48(o,r1,r2,a,fmt,b,c,d,t) | |
51 | #define f48(o,r1,r2,a,fmt,b,c,d,t) f47_48(o,r1,r2,a,fmt,b,c,d,t) | |
52 | #define f47_48(o,r1,r2,y,fmt,b,c,d,t) _f47_48(_jit,o,r1,r2,y,fmt,b,c,d,t) | |
53 | static void _f47_48(jit_state_t*,jit_int32_t, | |
54 | jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t, | |
55 | jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); | |
56 | #define f49(o,r,a,b,c,f,d,e,g,h,i,t) f49_52(o,r,a,b,c,f,d,e,g,h,i,t) | |
57 | #define f51(o,r1,r2,y,a,f,b,d,e,g,h,c) f49_52(o,r1,r2,y,a,f,b,d,e,g,h,c) | |
58 | #define f52(o,r1,r2,a,b,f,c,d,e,g,h,t) f49_52(o,r1,r2,a,b,f,c,d,e,g,h,t) | |
59 | #define f49_52(o,r1,r2,y,v,f,a,b,u,c,d,t) _f49_52(_jit,o,r1,r2,y,v,f,a,b,u,c,d,t) | |
60 | static void _f49_52(jit_state_t*,jit_int32_t, | |
61 | jit_int32_t,jit_int32_t,jit_int32_t, | |
62 | jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t, | |
63 | jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); | |
64 | #define f53(o,r1,r2,ta,ra,f,tm) _f53(_jit,o,r1,r2,ta,ra,f,tm) | |
65 | static void _f53(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t, | |
66 | jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused; | |
67 | #define f54(o,r1,r2,a,b,f,c,d,e,g,t) _f54(_jit,o,r1,r2,a,b,f,c,d,e,g,t) | |
68 | static void _f54(jit_state_t*,jit_int32_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) maybe_unused; | |
71 | #define FABS_(f,r,t) f49(0xe,r,0,3,0,f,0,0,0,0,0,t) | |
72 | #define FABS_S(r,t) FABS_(0,r,t) | |
73 | #define FABS_D(r,t) FABS_(1,r,t) | |
74 | #define FABS_Q(r,t) f45(0xc,r,0,3,3,0,0,0,t) | |
75 | #define FADD_(f,r1,r2,t) f52(0xe,r1,r2,0,0,f,3,0,0,0,0,t) | |
76 | #define FADD_S(r1,r2,t) FADD_(0,r1,r2,t) | |
77 | #define FADD_D(r1,r2,t) FADD_(1,r1,r2,t) | |
78 | #define FADD_Q(r1,r2,t) f48(0xc,r1,r2,0,3,3,0,0,t) | |
79 | #define FPSR_GT 1 | |
80 | #define FPSR_LT 2 | |
81 | #define FPSR_EQ 4 | |
82 | #define FPSR_UN 8 | |
83 | /* | |
84 | Actually these are reversed, but easier for the FTEST after the FCMP | |
85 | fcmp,dbl,false? fr4,fr12 0 | |
86 | fcmp,dbl,false fr4,fr12 1 | |
87 | fcmp,dbl,? fr4,fr12 2 | |
88 | fcmp,dbl,!<=> fr4,fr12 3 ORD | |
89 | fcmp,dbl,= fr4,fr12 4 NE | |
90 | fcmp,dbl,=t fr4,fr12 5 | |
91 | fcmp,dbl,?= fr4,fr12 6 | |
92 | fcmp,dbl,!<> fr4,fr12 7 LTGT | |
93 | fcmp,dbl,!?>= fr4,fr12 8 | |
94 | fcmp,dbl,< fr4,fr12 9 UNGE | |
95 | fcmp,dbl,?< fr4,fr12 10 | |
96 | fcmp,dbl,!>= fr4,fr12 11 GE | |
97 | fcmp,dbl,!?> fr4,fr12 12 | |
98 | fcmp,dbl,<= fr4,fr12 13 UNGT | |
99 | fcmp,dbl,?<= fr4,fr12 14 | |
100 | fcmp,dbl,!> fr4,fr12 15 GT | |
101 | fcmp,dbl,!?<= fr4,fr12 16 | |
102 | fcmp,dbl,> fr4,fr12 17 UNLE | |
103 | fcmp,dbl,?> fr4,fr12 18 | |
104 | fcmp,dbl,!<= fr4,fr12 19 LE | |
105 | fcmp,dbl,!?< fr4,fr12 20 | |
106 | fcmp,dbl,>= fr4,fr12 21 UNLT | |
107 | fcmp,dbl,?>= fr4,fr12 22 | |
108 | fcmp,dbl,!< fr4,fr12 23 LT | |
109 | fcmp,dbl,!?= fr4,fr12 24 | |
110 | fcmp,dbl,<> fr4,fr12 25 UNEQ | |
111 | fcmp,dbl,!= fr4,fr12 26 EQ | |
112 | fcmp,dbl,!=t fr4,fr12 27 | |
113 | fcmp,dbl,!? fr4,fr12 28 | |
114 | fcmp,dbl,<=> fr4,fr12 29 UNORD | |
115 | fcmp,dbl,true? fr4,fr12 30 | |
116 | fcmp,dbl,true fr4,fr12 31 | |
117 | */ | |
118 | #define FCMP_LT 23 | |
119 | #define FCMP_LE 19 | |
120 | #define FCMP_EQ 26 | |
121 | #define FCMP_GE 11 | |
122 | #define FCMP_GT 15 | |
123 | #define FCMP_NE 4 | |
124 | #define FCMP_UNLT 21 | |
125 | #define FCMP_UNLE 17 | |
126 | #define FCMP_UNEQ 25 | |
127 | #define FCMP_UNGE 9 | |
128 | #define FCMP_UNGT 13 | |
129 | #define FCMP_LTGT 7 | |
130 | #define FCMP_ORD 3 | |
131 | #define FCMP_UNORD 29 | |
132 | #define FCMP_(f,r1,r2,c) f51(0xe,r1,r2,0,0,f,2,0,0,0,0,c) | |
133 | #define FCMP_S_(r1,r2,c) FCMP_(0,r1,r2,c) | |
134 | #define FCMP_D_(r1,r2,c) FCMP_(1,r1,r2,c) | |
135 | #define FCMP_Q_(r1,r2,c) f47(0xc,r1,r2,0,3,2,0,0,c) | |
136 | #define FCMP_S_LT(r1,r2) FCMP_S_(r1,r2,FCMP_LT) | |
137 | #define FCMP_D_LT(r1,r2) FCMP_D_(r1,r2,FCMP_LT) | |
138 | #define FCMP_Q_LT(r1,r2) FCMP_Q_(r1,r2,FCMP_LT) | |
139 | #define FCMP_S_LE(r1,r2) FCMP_S_(r1,r2,FCMP_LE) | |
140 | #define FCMP_D_LE(r1,r2) FCMP_D_(r1,r2,FCMP_LE) | |
141 | #define FCMP_Q_LE(r1,r2) FCMP_Q_(r1,r2,FCMP_LE) | |
142 | #define FCMP_S_EQ(r1,r2) FCMP_S_(r1,r2,FCMP_EQ) | |
143 | #define FCMP_D_EQ(r1,r2) FCMP_D_(r1,r2,FCMP_EQ) | |
144 | #define FCMP_Q_EQ(r1,r2) FCMP_Q_(r1,r2,FCMP_EQ) | |
145 | #define FCMP_S_GE(r1,r2) FCMP_S_(r1,r2,FCMP_GE) | |
146 | #define FCMP_D_GE(r1,r2) FCMP_D_(r1,r2,FCMP_GE) | |
147 | #define FCMP_Q_GE(r1,r2) FCMP_Q_(r1,r2,FCMP_GE) | |
148 | #define FCMP_S_GT(r1,r2) FCMP_S_(r1,r2,FCMP_GT) | |
149 | #define FCMP_D_GT(r1,r2) FCMP_D_(r1,r2,FCMP_GT) | |
150 | #define FCMP_Q_GT(r1,r2) FCMP_Q_(r1,r2,FCMP_GT) | |
151 | #define FCMP_S_NE(r1,r2) FCMP_S_(r1,r2,FCMP_NE) | |
152 | #define FCMP_D_NE(r1,r2) FCMP_D_(r1,r2,FCMP_NE) | |
153 | #define FCMP_Q_NE(r1,r2) FCMP_Q_(r1,r2,FCMP_NE) | |
154 | #define FCMP_S_UNLT(r1,r2) FCMP_S_(r1,r2,FCMP_UNLT) | |
155 | #define FCMP_D_UNLT(r1,r2) FCMP_D_(r1,r2,FCMP_UNLT) | |
156 | #define FCMP_Q_UNLT(r1,r2) FCMP_Q_(r1,r2,FCMP_UNLT) | |
157 | #define FCMP_S_UNLE(r1,r2) FCMP_S_(r1,r2,FCMP_UNLE) | |
158 | #define FCMP_D_UNLE(r1,r2) FCMP_D_(r1,r2,FCMP_UNLE) | |
159 | #define FCMP_Q_UNLE(r1,r2) FCMP_Q_(r1,r2,FCMP_UNLE) | |
160 | #define FCMP_S_UNEQ(r1,r2) FCMP_S_(r1,r2,FCMP_UNEQ) | |
161 | #define FCMP_D_UNEQ(r1,r2) FCMP_D_(r1,r2,FCMP_UNEQ) | |
162 | #define FCMP_Q_UNEQ(r1,r2) FCMP_Q_(r1,r2,FCMP_UNEQ) | |
163 | #define FCMP_S_UNGE(r1,r2) FCMP_S_(r1,r2,FCMP_UNGE) | |
164 | #define FCMP_D_UNGE(r1,r2) FCMP_D_(r1,r2,FCMP_UNGE) | |
165 | #define FCMP_Q_UNGE(r1,r2) FCMP_Q_(r1,r2,FCMP_UNGE) | |
166 | #define FCMP_S_UNGT(r1,r2) FCMP_S_(r1,r2,FCMP_UNGT) | |
167 | #define FCMP_D_UNGT(r1,r2) FCMP_D_(r1,r2,FCMP_UNGT) | |
168 | #define FCMP_Q_UNGT(r1,r2) FCMP_Q_(r1,r2,FCMP_UNGT) | |
169 | #define FCMP_S_LTGT(r1,r2) FCMP_S_(r1,r2,FCMP_LTGT) | |
170 | #define FCMP_D_LTGT(r1,r2) FCMP_D_(r1,r2,FCMP_LTGT) | |
171 | #define FCMP_Q_LTGT(r1,r2) FCMP_Q_(r1,r2,FCMP_LTGT) | |
172 | #define FCMP_S_ORD(r1,r2) FCMP_S_(r1,r2,FCMP_ORD) | |
173 | #define FCMP_D_ORD(r1,r2) FCMP_D_(r1,r2,FCMP_ORD) | |
174 | #define FCMP_Q_ORD(r1,r2) FCMP_Q_(r1,r2,FCMP_ORD) | |
175 | #define FCMP_S_UNORD(r1,r2) FCMP_S_(r1,r2,FCMP_UNORD) | |
176 | #define FCMP_D_UNORD(r1,r2) FCMP_D_(r1,r2,FCMP_UNORD) | |
177 | #define FCMP_Q_UNORD(r1,r2) FCMP_Q_(r1,r2,FCMP_UNORD) | |
178 | #define XFNVFF(s,d,r,t) f46(0xc,r,0,0,d,s,1,0,0,t) | |
179 | #define FCNVFF_Q_S(r,t) XFNVFF(3,0,r,t) | |
180 | #define FCNVFF_Q_D(r,t) XFNVFF(3,1,r,t) | |
181 | #define FCNVFF_S_Q(r,t) XFNVFF(0,3,r,t) | |
182 | #define FCNVFF_D_Q(r,t) XFNVFF(1,3,r,t) | |
183 | #define FCNVFF_(s,d,r,t) f46(0xc,r,0,0,d,s,1,0,0,t) | |
184 | #define FCNVFF_S_D(r,t) FCNVFF_(0,1,r,t) | |
185 | #define FCNVFF_D_S(r,t) FCNVFF_(1,0,r,t) | |
186 | #define FCNVXF_(s,d,r,t) f46(0xc,r,0,1,d,s,1,0,0,t) | |
187 | #define FCNVXF_S_S(r,t) FCNVXF_(0,0,r,t) | |
188 | #define FCNVXF_S_D(r,t) FCNVXF_(0,1,r,t) | |
189 | #define FCNVXT_(s,d,r,t) f46(0xc,r,0,3,d,s,1,0,0,t) | |
190 | #define FCNVXT_S_S(r,t) FCNVXT_(0,0,r,t) | |
191 | #define FCNVXT_D_S(r,t) FCNVXT_(1,0,r,t) | |
192 | #define FCPY_(f,r,t) f49(0xe,r,0,2,0,f,0,0,0,0,0,t) | |
193 | #define FCPY_S(r,t) FCPY_(0,r,t) | |
194 | #define FCPY_D(r,t) FCPY_(1,r,t) | |
195 | #define FCPY_Q(r,t) f45(0xc,r,0,2,2,0,0,0,t) | |
196 | #define FDIV_(f,r1,r2,t) f52(0xe,r1,r2,3,0,f,3,0,0,0,0,t) | |
197 | #define FDIV_S(r1,r2,t) FDIV_(0,r1,r2,t) | |
198 | #define FDIV_D(r1,r2,t) FDIV_(1,r1,r2,t) | |
199 | #define FDIV_Q(r1,r2,t) f48(0xc,r1,r2,3,3,3,0,0,t) | |
200 | #define FID() f45(0xc,0,0,0,2,0,0,0,0) | |
201 | #define FLDDL(i,b,t) f3(0x14,b,t,i,1) | |
202 | #define FLDD(x,b,t) f39(0xb,b,x,t) | |
203 | #define FLDDI(i,b,t) f41(0xb,b,i,t) | |
204 | #define FLDWL(i,b,t) f43(0x17,b,t,i) | |
205 | #define FLDW(x,b,t) f39(0x9,b,x,t) | |
206 | #define FLDWI(i,b,t) f41(0x9,b,i,t) | |
207 | #define FMPY_(f,r1,r2,t) f52(0xe,r1,r2,2,0,f,3,0,0,0,0,t) | |
208 | #define FMPY_S(r1,r2,t) FMPY_(0,r1,r2,t) | |
209 | #define FMPY_D(r1,r2,t) FMPY_(1,r1,r2,t) | |
210 | #define FMPY_Q(r1,r2,t) f48(0xc,r1,r2,2,3,3,0,0,t) | |
211 | /* FIXME not disassembled */ | |
212 | #define FMPYADD_(f,r1,r2,ta,ra,tm) f53(0x6,r1,r2,ta,ra,f,tm) | |
213 | #define FMPYADD_S(r1,r2,ta,ra,tm) FMPYADD_(0,r1,r2,ta,ra,tm) | |
214 | #define FMPYADD_D(r1,r2,ta,ra,tm) FMPYADD_(1,r1,r2,ta,ra,tm) | |
215 | #define FMPYFADD_(f,r1,r2,ra,t) f54(0x2e,r1,r2,ra>>3,0,f,(ra)&7,0,0,0,t) | |
216 | #define FMPYFADD_S(r1,r2,ra,t) FMPYFADD_(0,r1,r2,ra,t) | |
217 | #define FMPYFADD_D(r1,r2,ra,t) FMPYFADD_(1,r1,r2,ra,t) | |
218 | #define FMPYNFADD_(f,r1,r2,ra,t) f54(0x2e,r1,r2,ra>>3,0,f,(ra)&7,0,0,1,t) | |
219 | #define FMPYNFADD_S(r1,r2,ra,t) FMPYNFADD_(0,r1,r2,ra,t) | |
220 | #define FMPYNFADD_D(r1,r2,ra,t) FMPYNFADD_(1,r1,r2,ra,t) | |
221 | #define FMPYSUB_(f,r1,r2,ta,ra,tm) f53(0x26,r1,r2,ta,ra,f,tm) | |
222 | #define FMPYSUB_S(r1,r2,ta,ra,tm) FMPYSUB_(0,r1,r2,ta,ra,tm) | |
223 | #define FMPYSUB_D(r1,r2,ta,ra,tm) FMPYSUB_(1,r1,r2,ta,ra,tm) | |
224 | #define FNEG_(f,r,t) f49(0xe,r,0,6,0,f,0,0,0,0,0,t) | |
225 | #define FNEG_S(r,t) FNEG_(0,r,t) | |
226 | #define FNEG_D(r,t) FNEG_(1,r,t) | |
227 | /* FIXME not disassembled */ | |
228 | #define FNEG_Q(r,t) f45(0xc,r,0,6,3,0,0,0,t) | |
229 | #define FNEGABS_(f,r,t) f49(0xe,r,0,7,0,f,0,0,0,0,0,t) | |
230 | #define FNEGABS_S(r,t) FNEGABS_(0,r,t) | |
231 | #define FNEGABS_D(r,t) FNEGABS_(1,r,t) | |
232 | #define FNEGABS_Q(r,t) f45(0xc,r,0,7,3,0,0,0,t) | |
233 | #define FRND_(f,r,t) f49(0xe,r,0,5,0,f,0,0,0,0,0,t) | |
234 | #define FRND_S(r,t) FRND_(0,r,t) | |
235 | #define FRND_D(r,t) FRND_(1,r,t) | |
236 | #define FRND_Q(r,t) f45(0xc,r,0,5,3,0,0,0,t) | |
237 | #define FSQRT_(f,r,t) f49(0xe,r,0,4,0,f,0,0,0,0,0,t) | |
238 | #define FSQRT_S(r,t) FSQRT_(0,r,t) | |
239 | #define FSQRT_D(r,t) FSQRT_(1,r,t) | |
240 | #define FSQRT_Q(r,t) f45(0xc,r,0,4,3,0,0,0,t) | |
241 | #define FSTDL(r,i,b) f3(0x1c,b,r,i,1) | |
242 | #define FSTD(r,x,b) f40(0xb,b,x,r) | |
243 | #define FSTDI(r,i,b) f42(0xb,b,i,r) | |
244 | #define FSTWL(r,i,b) f43(0x1f,b,r,i) | |
245 | #define FSTW(r,x,b) f40(0x9,b,x,r) | |
246 | #define FSTWI(r,i,b) f42(0x9,b,i,r) | |
247 | #define FSUB_(f,r1,r2,t) f52(0xe,r1,r2,1,0,f,3,0,0,0,0,t) | |
248 | #define FSUB_S(r1,r2,t) FSUB_(0,r1,r2,t) | |
249 | #define FSUB_D(r1,r2,t) FSUB_(1,r1,r2,t) | |
250 | #define FSUB_Q(r1,r2,t) f48(0xc,r1,r2,1,3,3,0,0,t) | |
251 | #define FTEST_(c) f47(0xc,0,0,0,0,2,0,1,c) | |
252 | #define FTEST() f47(0xc,0,0,1,0,2,0,1,0) | |
253 | #define FTEST_LT() FTEST_(FCMP_LT) | |
254 | #define FTEST_LE() FTEST_(FCMP_LE) | |
255 | #define FTEST_EQ() FTEST_(FCMP_EQ) | |
256 | #define FTEST_GE() FTEST_(FCMP_GE) | |
257 | #define FTEST_GT() FTEST_(FCMP_GT) | |
258 | #define FTEST_NE() FTEST_(FCMP_NE) | |
259 | #define FTEST_UNLT() FTEST_(FCMP_UNLT) | |
260 | #define FTEST_UNLE() FTEST_(FCMP_UNLE) | |
261 | #define FTEST_UNEQ() FTEST_(FCMP_UNEQ) | |
262 | #define FTEST_UNGE() FTEST_(FCMP_UNGE) | |
263 | #define FTEST_UNGT() FTEST_(FCMP_UNGT) | |
264 | #define FTEST_LTGT() FTEST_(FCMP_LTGT) | |
265 | #define FTEST_ORD() FTEST_(FCMP_ORD) | |
266 | #define FTEST_UNORD() FTEST_(FCMP_UNORD) | |
267 | #define XMPYU(r1,r2,t) f52(0xe,r1,r2,2,0,0,3,1,0,0,0,t) | |
268 | #define XMPYU_L_R(r1,r2,t) f52(0xe,r1,r2,2,1,0,3,1,0,0,0,t) | |
269 | #define XMPYU_R_L(r1,r2,t) f52(0xe,r1,r2,2,0,0,3,1,1,0,0,t) | |
270 | #define XMPYU_R_R(r1,r2,t) f52(0xe,r1,r2,2,1,0,3,1,1,0,0,t) | |
271 | #define negr_f(r0,r1) FNEG_S(r1,r0) | |
272 | #define negr_d(r0,r1) FNEG_D(r1,r0) | |
273 | #define sqrtr_f(r0,r1) FSQRT_S(r1,r0) | |
ba86ff93 PC |
274 | #define fmar_f(r0,r1,r2,r3) _fmar_f(_jit,r0,r1,r2,r3) |
275 | static void _fmar_f(jit_state_t*, | |
276 | jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); | |
277 | #define fmsr_f(r0,r1,r2,r3) _fmsr_f(_jit,r0,r1,r2,r3) | |
278 | static void _fmsr_f(jit_state_t*, | |
279 | jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); | |
280 | #define fnmar_f(r0,r1,r2,r3) _fnmar_f(_jit,r0,r1,r2,r3) | |
281 | static void _fnmar_f(jit_state_t*, | |
282 | jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); | |
283 | #define fnmsr_f(r0,r1,r2,r3) _fnmsr_f(_jit,r0,r1,r2,r3) | |
284 | static void _fnmsr_f(jit_state_t*, | |
285 | jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); | |
4a71579b | 286 | #define sqrtr_d(r0,r1) FSQRT_D(r1,r0) |
ba86ff93 PC |
287 | #define fmar_d(r0,r1,r2,r3) _fmar_d(_jit,r0,r1,r2,r3) |
288 | static void _fmar_d(jit_state_t*, | |
289 | jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); | |
290 | #define fmsr_d(r0,r1,r2,r3) _fmsr_d(_jit,r0,r1,r2,r3) | |
291 | static void _fmsr_d(jit_state_t*, | |
292 | jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); | |
293 | #define fnmar_d(r0,r1,r2,r3) _fnmar_d(_jit,r0,r1,r2,r3) | |
294 | static void _fnmar_d(jit_state_t*, | |
295 | jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); | |
296 | #define fnmsr_d(r0,r1,r2,r3) _fnmsr_d(_jit,r0,r1,r2,r3) | |
297 | static void _fnmsr_d(jit_state_t*, | |
298 | jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); | |
4a71579b PC |
299 | #define extr_f(r0,r1) _extr_f(_jit,r0,r1) |
300 | static void _extr_f(jit_state_t*,jit_int32_t,jit_int32_t); | |
301 | #define extr_d(r0,r1) _extr_d(_jit,r0,r1) | |
302 | static void _extr_d(jit_state_t*,jit_int32_t,jit_int32_t); | |
303 | #define extr_f_d(r0,r1) FCNVFF_S_D(r1,r0) | |
304 | #define extr_d_f(r0,r1) FCNVFF_D_S(r1,r0) | |
305 | #define truncr_f(r0,r1) truncr_f_i(r0,r1) | |
306 | #define truncr_f_i(r0,r1) _truncr_f_i(_jit,r0,r1) | |
307 | static void _truncr_f_i(jit_state_t*,jit_int32_t,jit_int32_t); | |
308 | #define truncr_d(r0,r1) truncr_d_i(r0,r1) | |
309 | #define truncr_d_i(r0,r1) _truncr_d_i(_jit,r0,r1) | |
310 | static void _truncr_d_i(jit_state_t*,jit_int32_t,jit_int32_t); | |
311 | #define movr_f(r0,r1) FCPY_S(r1,r0) | |
312 | #define movi_f(r0,i0) _movi_f(_jit,r0,i0) | |
313 | static void _movi_f(jit_state_t*,jit_int32_t,jit_float32_t*); | |
ba86ff93 PC |
314 | #define movi_w_f(r0, i0) _movi_w_f(_jit, r0, i0) |
315 | static void _movi_w_f(jit_state_t*, jit_int32_t, jit_word_t); | |
4a71579b PC |
316 | #define movr_d(r0,r1) FCPY_D(r1,r0) |
317 | #define movi_d(r0,i0) _movi_d(_jit,r0,i0) | |
318 | static void _movi_d(jit_state_t*,jit_int32_t,jit_float64_t*); | |
ba86ff93 PC |
319 | #define movi_ww_d(r0, i0, i1) _movi_ww_d(_jit, r0, i0, i1) |
320 | static void _movi_ww_d(jit_state_t*, jit_int32_t, jit_word_t, jit_word_t); | |
4a71579b PC |
321 | #define absr_f(r0,r1) FABS_S(r1,r0) |
322 | #define absr_d(r0,r1) FABS_D(r1,r0) | |
323 | #define addr_f(r0,r1,r2) FADD_S(r1,r2,r0) | |
324 | #define addi_f(r0,r1,i0) _addi_f(_jit,r0,r1,i0) | |
325 | static void _addi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*); | |
326 | #define addr_d(r0,r1,r2) FADD_D(r1,r2,r0) | |
327 | #define addi_d(r0,r1,i0) _addi_d(_jit,r0,r1,i0) | |
328 | static void _addi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*); | |
329 | #define subr_f(r0,r1,r2) FSUB_S(r1,r2,r0) | |
330 | #define subi_f(r0,r1,i0) _subi_f(_jit,r0,r1,i0) | |
331 | static void _subi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*); | |
332 | #define subr_d(r0,r1,r2) FSUB_D(r1,r2,r0) | |
333 | #define subi_d(r0,r1,i0) _subi_d(_jit,r0,r1,i0) | |
334 | static void _subi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*); | |
335 | #define rsbr_f(r0,r1,r2) subr_f(r0,r2,r1) | |
336 | #define rsbi_f(r0,r1,i0) _rsbi_f(_jit,r0,r1,i0) | |
337 | static void _rsbi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*); | |
338 | #define rsbr_d(r0,r1,r2) subr_d(r0,r2,r1) | |
339 | #define rsbi_d(r0,r1,i0) _rsbi_d(_jit,r0,r1,i0) | |
340 | static void _rsbi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*); | |
341 | #define mulr_f(r0,r1,r2) FMPY_S(r1,r2,r0) | |
342 | #define muli_f(r0,r1,i0) _muli_f(_jit,r0,r1,i0) | |
343 | static void _muli_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*); | |
344 | #define mulr_d(r0,r1,r2) FMPY_D(r1,r2,r0) | |
345 | #define muli_d(r0,r1,i0) _muli_d(_jit,r0,r1,i0) | |
346 | static void _muli_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*); | |
347 | #define divr_f(r0,r1,r2) FDIV_S(r1,r2,r0) | |
348 | #define divi_f(r0,r1,i0) _divi_f(_jit,r0,r1,i0) | |
349 | static void _divi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*); | |
350 | #define divr_d(r0,r1,r2) FDIV_D(r1,r2,r0) | |
351 | #define divi_d(r0,r1,i0) _divi_d(_jit,r0,r1,i0) | |
352 | static void _divi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*); | |
353 | #define cmpr_f(c,r0,r1,r2) _cmpr_f(_jit,c,r0,r1,r2) | |
354 | static void _cmpr_f(jit_state_t*,jit_word_t, | |
355 | jit_int32_t,jit_int32_t,jit_int32_t); | |
356 | #define cmpi_f(c,r0,r1,i0) _cmpi_f(_jit,c,r0,r1,i0) | |
357 | static void _cmpi_f(jit_state_t*,jit_word_t, | |
358 | jit_int32_t,jit_int32_t,jit_float32_t*); | |
359 | #define cmpr_d(c,r0,r1,r2) _cmpr_d(_jit,c,r0,r1,r2) | |
360 | static void _cmpr_d(jit_state_t*,jit_word_t, | |
361 | jit_int32_t,jit_int32_t,jit_int32_t); | |
362 | #define cmpi_d(c,r0,r1,i0) _cmpi_d(_jit,c,r0,r1,i0) | |
363 | static void _cmpi_d(jit_state_t*,jit_word_t, | |
364 | jit_int32_t,jit_int32_t,jit_float64_t*); | |
365 | #define ltr_f(r0,r1,r2) cmpr_f(FCMP_LT,r0,r1,r2) | |
366 | #define lti_f(r0,r1,i0) cmpi_f(FCMP_LT,r0,r1,i0) | |
367 | #define ltr_d(r0,r1,r2) cmpr_d(FCMP_LT,r0,r1,r2) | |
368 | #define lti_d(r0,r1,i0) cmpi_d(FCMP_LT,r0,r1,i0) | |
369 | #define ler_f(r0,r1,r2) cmpr_f(FCMP_LE,r0,r1,r2) | |
370 | #define lei_f(r0,r1,i0) cmpi_f(FCMP_LE,r0,r1,i0) | |
371 | #define ler_d(r0,r1,r2) cmpr_d(FCMP_LE,r0,r1,r2) | |
372 | #define lei_d(r0,r1,i0) cmpi_d(FCMP_LE,r0,r1,i0) | |
373 | #define eqr_f(r0,r1,r2) cmpr_f(FCMP_EQ,r0,r1,r2) | |
374 | #define eqi_f(r0,r1,i0) cmpi_f(FCMP_EQ,r0,r1,i0) | |
375 | #define eqr_d(r0,r1,r2) cmpr_d(FCMP_EQ,r0,r1,r2) | |
376 | #define eqi_d(r0,r1,i0) cmpi_d(FCMP_EQ,r0,r1,i0) | |
377 | #define ger_f(r0,r1,r2) cmpr_f(FCMP_GE,r0,r1,r2) | |
378 | #define gei_f(r0,r1,i0) cmpi_f(FCMP_GE,r0,r1,i0) | |
379 | #define ger_d(r0,r1,r2) cmpr_d(FCMP_GE,r0,r1,r2) | |
380 | #define gei_d(r0,r1,i0) cmpi_d(FCMP_GE,r0,r1,i0) | |
381 | #define gtr_f(r0,r1,r2) cmpr_f(FCMP_GT,r0,r1,r2) | |
382 | #define gti_f(r0,r1,i0) cmpi_f(FCMP_GT,r0,r1,i0) | |
383 | #define gtr_d(r0,r1,r2) cmpr_d(FCMP_GT,r0,r1,r2) | |
384 | #define gti_d(r0,r1,i0) cmpi_d(FCMP_GT,r0,r1,i0) | |
385 | #define ner_f(r0,r1,r2) cmpr_f(FCMP_NE,r0,r1,r2) | |
386 | #define nei_f(r0,r1,i0) cmpi_f(FCMP_NE,r0,r1,i0) | |
387 | #define ner_d(r0,r1,r2) cmpr_d(FCMP_NE,r0,r1,r2) | |
388 | #define nei_d(r0,r1,i0) cmpi_d(FCMP_NE,r0,r1,i0) | |
389 | #define unltr_f(r0,r1,r2) cmpr_f(FCMP_UNLT,r0,r1,r2) | |
390 | #define unlti_f(r0,r1,i0) cmpi_f(FCMP_UNLT,r0,r1,i0) | |
391 | #define unltr_d(r0,r1,r2) cmpr_d(FCMP_UNLT,r0,r1,r2) | |
392 | #define unlti_d(r0,r1,i0) cmpi_d(FCMP_UNLT,r0,r1,i0) | |
393 | #define unler_f(r0,r1,r2) cmpr_f(FCMP_UNLE,r0,r1,r2) | |
394 | #define unlei_f(r0,r1,i0) cmpi_f(FCMP_UNLE,r0,r1,i0) | |
395 | #define unler_d(r0,r1,r2) cmpr_d(FCMP_UNLE,r0,r1,r2) | |
396 | #define unlei_d(r0,r1,i0) cmpi_d(FCMP_UNLE,r0,r1,i0) | |
397 | #define uneqr_f(r0,r1,r2) cmpr_f(FCMP_UNEQ,r0,r1,r2) | |
398 | #define uneqi_f(r0,r1,i0) cmpi_f(FCMP_UNEQ,r0,r1,i0) | |
399 | #define uneqr_d(r0,r1,r2) cmpr_d(FCMP_UNEQ,r0,r1,r2) | |
400 | #define uneqi_d(r0,r1,i0) cmpi_d(FCMP_UNEQ,r0,r1,i0) | |
401 | #define unger_f(r0,r1,r2) cmpr_f(FCMP_UNGE,r0,r1,r2) | |
402 | #define ungei_f(r0,r1,i0) cmpi_f(FCMP_UNGE,r0,r1,i0) | |
403 | #define unger_d(r0,r1,r2) cmpr_d(FCMP_UNGE,r0,r1,r2) | |
404 | #define ungei_d(r0,r1,i0) cmpi_d(FCMP_UNGE,r0,r1,i0) | |
405 | #define ungtr_f(r0,r1,r2) cmpr_f(FCMP_UNGT,r0,r1,r2) | |
406 | #define ungti_f(r0,r1,i0) cmpi_f(FCMP_UNGT,r0,r1,i0) | |
407 | #define ungtr_d(r0,r1,r2) cmpr_d(FCMP_UNGT,r0,r1,r2) | |
408 | #define ungti_d(r0,r1,i0) cmpi_d(FCMP_UNGT,r0,r1,i0) | |
409 | #define ltgtr_f(r0,r1,r2) cmpr_f(FCMP_LTGT,r0,r1,r2) | |
410 | #define ltgti_f(r0,r1,i0) cmpi_f(FCMP_LTGT,r0,r1,i0) | |
411 | #define ltgtr_d(r0,r1,r2) cmpr_d(FCMP_LTGT,r0,r1,r2) | |
412 | #define ltgti_d(r0,r1,i0) cmpi_d(FCMP_LTGT,r0,r1,i0) | |
413 | #define ordr_f(r0,r1,r2) cmpr_f(FCMP_ORD,r0,r1,r2) | |
414 | #define ordi_f(r0,r1,i0) cmpi_f(FCMP_ORD,r0,r1,i0) | |
415 | #define ordr_d(r0,r1,r2) cmpr_d(FCMP_ORD,r0,r1,r2) | |
416 | #define ordi_d(r0,r1,i0) cmpi_d(FCMP_ORD,r0,r1,i0) | |
417 | #define unordr_f(r0,r1,r2) cmpr_f(FCMP_UNORD,r0,r1,r2) | |
418 | #define unordi_f(r0,r1,i0) cmpi_f(FCMP_UNORD,r0,r1,i0) | |
419 | #define unordr_d(r0,r1,r2) cmpr_d(FCMP_UNORD,r0,r1,r2) | |
420 | #define unordi_d(r0,r1,i0) cmpi_d(FCMP_UNORD,r0,r1,i0) | |
421 | #define ldr_f(r0,r1) FLDWI(0,r1,r0) | |
422 | #define ldi_f(r0,i0) _ldi_f(_jit,r0,i0) | |
423 | static void _ldi_f(jit_state_t*,jit_int32_t,jit_word_t); | |
424 | #if FLDXR | |
425 | # define ldxr_f(r0,r1,r2) FLDW(r2,r1,r0) | |
426 | # define ldxr_d(r0,r1,r2) FLDD(r2,r1,r0) | |
427 | #else | |
428 | #define ldxr_f(r0,r1,r2) _ldxr_f(_jit,r0,r1,r2) | |
429 | static void _ldxr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); | |
430 | #define ldxr_d(r0,r1,r2) _ldxr_d(_jit,r0,r1,r2) | |
431 | static void _ldxr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); | |
432 | #endif | |
433 | #define ldxi_f(r0,r1,i0) _ldxi_f(_jit,r0,r1,i0) | |
434 | static void _ldxi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); | |
435 | #define ldr_d(r0,r1) FLDDI(0,r1,r0) | |
436 | #define ldi_d(r0,i0) _ldi_d(_jit,r0,i0) | |
437 | static void _ldi_d(jit_state_t*,jit_int32_t,jit_word_t); | |
438 | #define ldxi_d(r0,r1,i0) _ldxi_d(_jit,r0,r1,i0) | |
439 | static void _ldxi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); | |
440 | #define str_f(r0,r1) FSTWI(r1,0,r0) | |
441 | #define sti_f(i0,r0) _sti_f(_jit,i0,r0) | |
442 | static void _sti_f(jit_state_t*,jit_word_t,jit_int32_t); | |
443 | #if FSTXR | |
444 | # define stxr_f(r0,r1,r2) FSTW(r2,r1,r0) | |
445 | # define stxr_d(r0,r1,r2) FSTD(r2,r1,r0) | |
446 | #else | |
447 | # define stxr_f(r0,r1,r2) _stxr_f(_jit,r0,r1,r2) | |
448 | static void _stxr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); | |
449 | # define stxr_d(r0,r1,r2) _stxr_d(_jit,r0,r1,r2) | |
450 | static void _stxr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); | |
451 | #endif | |
452 | #define stxi_f(i0,r0,r1) _stxi_f(_jit,i0,r0,r1) | |
453 | static void _stxi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); | |
454 | #define str_d(r0,r1) FSTDI(r1,0,r0) | |
455 | #define sti_d(i0,r0) _sti_d(_jit,i0,r0) | |
456 | static void _sti_d(jit_state_t*,jit_word_t,jit_int32_t); | |
457 | #define stxi_d(i0,r0,r1) _stxi_d(_jit,i0,r0,r1) | |
458 | static void _stxi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); | |
459 | #define bcmpr_f(c,i0,r0,r1) _bcmpr_f(_jit,c,i0,r0,r1) | |
460 | static jit_word_t _bcmpr_f(jit_state_t*,jit_word_t, | |
461 | jit_word_t,jit_int32_t,jit_int32_t); | |
462 | #define bcmpi_f(c,i0,r0,i1) _bcmpi_f(_jit,c,i0,r0,i1) | |
463 | static jit_word_t _bcmpi_f(jit_state_t*,jit_word_t, | |
464 | jit_word_t,jit_int32_t,jit_float32_t*); | |
465 | #define bcmpr_d(c,i0,r0,r1) _bcmpr_d(_jit,c,i0,r0,r1) | |
466 | static jit_word_t _bcmpr_d(jit_state_t*,jit_word_t, | |
467 | jit_word_t,jit_int32_t,jit_int32_t); | |
468 | #define bcmpi_d(c,i0,r0,i1) _bcmpi_d(_jit,c,i0,r0,i1) | |
469 | static jit_word_t _bcmpi_d(jit_state_t*,jit_word_t, | |
470 | jit_word_t,jit_int32_t,jit_float64_t*); | |
471 | #define bltr_f(i0,r0,r1) bcmpr_f(FCMP_LT,i0,r0,r1) | |
472 | #define blti_f(i0,r0,i1) bcmpi_f(FCMP_LT,i0,r0,i1) | |
473 | #define bltr_d(i0,r0,r1) bcmpr_d(FCMP_LT,i0,r0,r1) | |
474 | #define blti_d(i0,r0,i1) bcmpi_d(FCMP_LT,i0,r0,i1) | |
475 | #define bler_f(i0,r0,r1) bcmpr_f(FCMP_LE,i0,r0,r1) | |
476 | #define blei_f(i0,r0,i1) bcmpi_f(FCMP_LE,i0,r0,i1) | |
477 | #define bler_d(i0,r0,r1) bcmpr_d(FCMP_LE,i0,r0,r1) | |
478 | #define blei_d(i0,r0,i1) bcmpi_d(FCMP_LE,i0,r0,i1) | |
479 | #define beqr_f(i0,r0,r1) bcmpr_f(FCMP_EQ,i0,r0,r1) | |
480 | #define beqi_f(i0,r0,i1) bcmpi_f(FCMP_EQ,i0,r0,i1) | |
481 | #define beqr_d(i0,r0,r1) bcmpr_d(FCMP_EQ,i0,r0,r1) | |
482 | #define beqi_d(i0,r0,i1) bcmpi_d(FCMP_EQ,i0,r0,i1) | |
483 | #define bger_f(i0,r0,r1) bcmpr_f(FCMP_GE,i0,r0,r1) | |
484 | #define bgei_f(i0,r0,i1) bcmpi_f(FCMP_GE,i0,r0,i1) | |
485 | #define bger_d(i0,r0,r1) bcmpr_d(FCMP_GE,i0,r0,r1) | |
486 | #define bgei_d(i0,r0,i1) bcmpi_d(FCMP_GE,i0,r0,i1) | |
487 | #define bgtr_f(i0,r0,r1) bcmpr_f(FCMP_GT,i0,r0,r1) | |
488 | #define bgti_f(i0,r0,i1) bcmpi_f(FCMP_GT,i0,r0,i1) | |
489 | #define bgtr_d(i0,r0,r1) bcmpr_d(FCMP_GT,i0,r0,r1) | |
490 | #define bgti_d(i0,r0,i1) bcmpi_d(FCMP_GT,i0,r0,i1) | |
491 | #define bner_f(i0,r0,r1) bcmpr_f(FCMP_NE,i0,r0,r1) | |
492 | #define bnei_f(i0,r0,i1) bcmpi_f(FCMP_NE,i0,r0,i1) | |
493 | #define bner_d(i0,r0,r1) bcmpr_d(FCMP_NE,i0,r0,r1) | |
494 | #define bnei_d(i0,r0,i1) bcmpi_d(FCMP_NE,i0,r0,i1) | |
495 | #define bunltr_f(i0,r0,r1) bcmpr_f(FCMP_UNLT,i0,r0,r1) | |
496 | #define bunlti_f(i0,r0,i1) bcmpi_f(FCMP_UNLT,i0,r0,i1) | |
497 | #define bunltr_d(i0,r0,r1) bcmpr_d(FCMP_UNLT,i0,r0,r1) | |
498 | #define bunlti_d(i0,r0,i1) bcmpi_d(FCMP_UNLT,i0,r0,i1) | |
499 | #define bunler_f(i0,r0,r1) bcmpr_f(FCMP_UNLE,i0,r0,r1) | |
500 | #define bunlei_f(i0,r0,i1) bcmpi_f(FCMP_UNLE,i0,r0,i1) | |
501 | #define bunler_d(i0,r0,r1) bcmpr_d(FCMP_UNLE,i0,r0,r1) | |
502 | #define bunlei_d(i0,r0,i1) bcmpi_d(FCMP_UNLE,i0,r0,i1) | |
503 | #define buneqr_f(i0,r0,r1) bcmpr_f(FCMP_UNEQ,i0,r0,r1) | |
504 | #define buneqi_f(i0,r0,i1) bcmpi_f(FCMP_UNEQ,i0,r0,i1) | |
505 | #define buneqr_d(i0,r0,r1) bcmpr_d(FCMP_UNEQ,i0,r0,r1) | |
506 | #define buneqi_d(i0,r0,i1) bcmpi_d(FCMP_UNEQ,i0,r0,i1) | |
507 | #define bunger_f(i0,r0,r1) bcmpr_f(FCMP_UNGE,i0,r0,r1) | |
508 | #define bungei_f(i0,r0,i1) bcmpi_f(FCMP_UNGE,i0,r0,i1) | |
509 | #define bunger_d(i0,r0,r1) bcmpr_d(FCMP_UNGE,i0,r0,r1) | |
510 | #define bungei_d(i0,r0,i1) bcmpi_d(FCMP_UNGE,i0,r0,i1) | |
511 | #define bungtr_f(i0,r0,r1) bcmpr_f(FCMP_UNGT,i0,r0,r1) | |
512 | #define bungti_f(i0,r0,i1) bcmpi_f(FCMP_UNGT,i0,r0,i1) | |
513 | #define bungtr_d(i0,r0,r1) bcmpr_d(FCMP_UNGT,i0,r0,r1) | |
514 | #define bungti_d(i0,r0,i1) bcmpi_d(FCMP_UNGT,i0,r0,i1) | |
515 | #define bltgtr_f(i0,r0,r1) bcmpr_f(FCMP_LTGT,i0,r0,r1) | |
516 | #define bltgti_f(i0,r0,i1) bcmpi_f(FCMP_LTGT,i0,r0,i1) | |
517 | #define bltgtr_d(i0,r0,r1) bcmpr_d(FCMP_LTGT,i0,r0,r1) | |
518 | #define bltgti_d(i0,r0,i1) bcmpi_d(FCMP_LTGT,i0,r0,i1) | |
519 | #define bordr_f(i0,r0,r1) bcmpr_f(FCMP_ORD,i0,r0,r1) | |
520 | #define bordi_f(i0,r0,i1) bcmpi_f(FCMP_ORD,i0,r0,i1) | |
521 | #define bordr_d(i0,r0,r1) bcmpr_d(FCMP_ORD,i0,r0,r1) | |
522 | #define bordi_d(i0,r0,i1) bcmpi_d(FCMP_ORD,i0,r0,i1) | |
523 | #define bunordr_f(i0,r0,r1) bcmpr_f(FCMP_UNORD,i0,r0,r1) | |
524 | #define bunordi_f(i0,r0,i1) bcmpi_f(FCMP_UNORD,i0,r0,i1) | |
525 | #define bunordr_d(i0,r0,r1) bcmpr_d(FCMP_UNORD,i0,r0,r1) | |
526 | #define bunordi_d(i0,r0,i1) bcmpi_d(FCMP_UNORD,i0,r0,i1) | |
527 | #define vaarg_d(r0, r1) _vaarg_d(_jit, r0, r1) | |
528 | static void _vaarg_d(jit_state_t*, jit_int32_t, jit_int32_t); | |
529 | #endif | |
530 | ||
531 | #if CODE | |
532 | static void | |
533 | _f39(jit_state_t *_jit, jit_int32_t o, | |
534 | jit_int32_t b, jit_int32_t x, jit_int32_t t) | |
535 | { | |
536 | assert(!(o & ~0x3f)); | |
537 | assert(!(b & ~0x1f)); | |
538 | assert(!(x & ~0x1f)); | |
539 | assert(!(t & ~0x1f)); | |
540 | ii((o<<26)|(b<<21)|(x<<16)|t); | |
541 | } | |
542 | ||
543 | static void | |
544 | _f40(jit_state_t *_jit, jit_int32_t o, | |
545 | jit_int32_t b, jit_int32_t x, jit_int32_t r) | |
546 | { | |
547 | assert(!(o & ~0x3f)); | |
548 | assert(!(b & ~0x1f)); | |
549 | assert(!(x & ~0x1f)); | |
550 | assert(!(r & ~0x1f)); | |
551 | ii((o<<26)|(b<<21)|(x<<16)|(1<<9)|r); | |
552 | } | |
553 | ||
554 | static void | |
555 | _f41(jit_state_t *_jit, jit_int32_t o, | |
556 | jit_int32_t b, jit_int32_t x, jit_int32_t t) | |
557 | { | |
558 | assert(!(o & ~0x3f)); | |
559 | assert(!(b & ~0x1f)); | |
560 | assert(x >= -16 && x < 15); | |
561 | assert(!(t & ~0x1f)); | |
562 | ii((o<<26)|(b<<21)|(low_sign_unext(x,5)<<16)|(1<<12)|t); | |
563 | } | |
564 | ||
565 | static void | |
566 | _f42(jit_state_t *_jit, jit_int32_t o, | |
567 | jit_int32_t b, jit_int32_t i, jit_int32_t r) | |
568 | { | |
569 | assert(!(o & ~0x3f)); | |
570 | assert(!(b & ~0x1f)); | |
571 | assert(i >= -16 && i < 15); | |
572 | assert(!(r & ~0x1f)); | |
573 | ii((o<<26)|(b<<21)|(low_sign_unext(i,5)<<16)|(1<<12)|(1<<9)|r); | |
574 | } | |
575 | ||
576 | static void | |
577 | _f45(jit_state_t *_jit, jit_int32_t o, | |
578 | jit_int32_t r, jit_int32_t a, jit_int32_t b, jit_int32_t fmt, | |
579 | jit_int32_t c, jit_int32_t d, jit_int32_t e, jit_int32_t t) | |
580 | { | |
581 | assert(!(o & ~0x3f)); | |
582 | assert(!(r & ~0x1f)); | |
583 | assert(!(a & ~0x1f)); | |
584 | assert(!(b & ~0x7)); | |
585 | assert(!(fmt & ~0x3)); | |
586 | assert(!(c & ~0x3)); | |
587 | assert(!(d & ~0x7)); | |
588 | assert(!(e & ~0x1)); | |
589 | assert(!(t & ~0x1f)); | |
590 | ii((o<<26)|(r<<21)|(a<<16)|(fmt<<13)|(b<<11)|(c<<9)|(d<<6)|(e<<5)|t); | |
591 | } | |
592 | ||
593 | static void | |
594 | _f46(jit_state_t *_jit, jit_int32_t o, jit_int32_t r, | |
595 | jit_int32_t a, jit_int32_t s, jit_int32_t df, jit_int32_t sf, | |
596 | jit_int32_t b, jit_int32_t c, jit_int32_t d, jit_int32_t t) | |
597 | { | |
598 | assert(!(o & ~0x3f)); | |
599 | assert(!(r & ~0x1f)); | |
600 | assert(!(a & ~0x7)); | |
601 | assert(!(s & ~0x7)); | |
602 | assert(!(df & ~0x3)); | |
603 | assert(!(sf & ~0x3)); | |
604 | assert(!(b & ~0x3)); | |
605 | assert(!(c & ~0x7)); | |
606 | assert(!(d & ~0x1)); | |
607 | assert(!(t & ~0x1f)); | |
608 | ii((o<<26)|(r<<21)|(a<<18)|(s<<15)| | |
609 | (df<<13)|(sf<<11)|(b<<9)|(c<<6)|(d<<5)|t); | |
610 | } | |
611 | ||
612 | static void | |
613 | _f47_48(jit_state_t *_jit, jit_int32_t o, | |
614 | jit_int32_t r2, jit_int32_t r1, jit_int32_t y, jit_int32_t fmt, | |
615 | jit_int32_t a, jit_int32_t b, jit_int32_t c, jit_int32_t t) | |
616 | { | |
617 | assert(!(o & ~0x3f)); | |
618 | assert(!(r2 & ~0x1f)); | |
619 | assert(!(r1 & ~0x1f)); | |
620 | assert(!(y & ~0x7)); | |
621 | assert(!(fmt & ~0x3)); | |
622 | assert(!(a & ~0x3)); | |
623 | assert(!(b & ~0x7)); | |
624 | assert(!(c & ~0x1)); | |
625 | assert(!(t & ~0x1f)); | |
626 | ii((o<<26)|(r2<<21)|(r1<<16)|(y<<13)|(fmt<<11)|(a<<9)|(b<<6)|(c<<5)|t); | |
627 | } | |
628 | ||
629 | static void | |
630 | _f49_52(jit_state_t *_jit, jit_int32_t o, | |
631 | jit_int32_t r1, jit_int32_t r2, jit_int32_t y, | |
632 | jit_int32_t v, jit_int32_t f, jit_int32_t a, jit_int32_t b, | |
633 | jit_int32_t u, jit_int32_t c, jit_int32_t d, jit_int32_t t) | |
634 | { | |
635 | assert(!(o & ~0x3f)); | |
636 | assert(!(r1 & ~0x1f)); | |
637 | assert(!(r2 & ~0x3f)); | |
638 | assert(!(y & ~0x7)); | |
639 | assert(!(v & ~0x1)); | |
640 | assert(!(f & ~0x1)); | |
641 | assert(!(a & ~0x3)); | |
642 | assert(!(b & ~0x1)); | |
643 | assert(!(u & ~0x1)); | |
644 | assert(!(c & ~0x1)); | |
645 | assert(!(d & ~0x1)); | |
646 | assert(!(t & ~0x1f)); | |
647 | ii((o<<26)|(r1<<21)|(r2<<16)|(y<<13)|(v<<12)| | |
648 | (f<<11)|(a<<9)|(b<<8)|(u<<7)|(c<<6)|(d<<5)|t); | |
649 | } | |
650 | ||
651 | static void | |
652 | _f53(jit_state_t *_jit, jit_int32_t o, jit_int32_t r1, jit_int32_t r2, | |
653 | jit_int32_t ta, jit_int32_t ra, jit_int32_t f, jit_int32_t tm) | |
654 | { | |
655 | assert(!(o & ~0x3f)); | |
656 | assert(!(r1 & ~0x1f)); | |
657 | assert(!(r2 & ~0x1f)); | |
658 | assert(!(ta & ~0x1f)); | |
659 | assert(!(ra & ~0x1f)); | |
660 | assert(!(f & ~0x1)); | |
661 | assert(!(tm & ~0x1f)); | |
662 | assert(ra != tm || | |
663 | (ta == r1 || ta == r2 || ta == tm) || | |
664 | (f && ra == 1) || (!f && !ra)); | |
665 | ii((o<<26)|(r1<<21)|(r2<<16)|(ta<<11)|(ra<<6)|(f<<5)|tm); | |
666 | } | |
667 | ||
668 | static void | |
669 | _f54(jit_state_t *_jit, jit_int32_t o, jit_int32_t r1, jit_int32_t r2, | |
670 | jit_int32_t a, jit_int32_t b, jit_int32_t f, jit_int32_t c, | |
671 | jit_int32_t d, jit_int32_t e, jit_int32_t g, jit_int32_t t) | |
672 | { | |
673 | assert(!(o & ~0x3f)); | |
674 | assert(!(r1 & ~0x1f)); | |
675 | assert(!(r2 & ~0x1f)); | |
676 | assert(!(a & ~0x7)); | |
677 | assert(!(b & ~0x1)); | |
678 | assert(!(f & ~0x1)); | |
679 | assert(!(c & ~0x7)); | |
680 | assert(!(e & ~0x1)); | |
681 | assert(!(e & ~0x1)); | |
682 | assert(!(g & ~0x1)); | |
683 | assert(!(t & ~0x1f)); | |
684 | ii((o<<26)|(r1<<21)|(r2<<16)|(a<<13)| | |
685 | (b<<12)|(f<11)|(c<<8)|(d<<7)|(e<<6)|(g<<5)|t); | |
686 | } | |
687 | ||
688 | static void | |
689 | _extr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) | |
690 | { | |
691 | stxi(alloca_offset - 8, _FP_REGNO, r1); | |
692 | ldxi_f(r0, _FP_REGNO, alloca_offset - 8); | |
693 | FCNVXF_S_S(r0, r0); | |
694 | } | |
695 | ||
696 | static void | |
697 | _extr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) | |
698 | { | |
699 | stxi(alloca_offset - 8, _FP_REGNO, r1); | |
700 | ldxi_f(r0, _FP_REGNO, alloca_offset - 8); | |
701 | FCNVXF_S_D(r0, r0); | |
702 | } | |
703 | ||
704 | static void | |
705 | _truncr_f_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) | |
706 | { | |
707 | jit_int32_t reg; | |
708 | reg = jit_get_reg(jit_class_fpr); | |
709 | FCNVXT_S_S(r1, rn(reg)); | |
710 | stxi_f(alloca_offset - 8, _FP_REGNO, rn(reg)); | |
711 | ldxi(r0, _FP_REGNO, alloca_offset - 8); | |
712 | jit_unget_reg(reg); | |
713 | } | |
714 | ||
715 | static void | |
716 | _truncr_d_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) | |
717 | { | |
718 | jit_int32_t reg; | |
719 | reg = jit_get_reg(jit_class_fpr); | |
720 | FCNVXT_D_S(r1, rn(reg)); | |
721 | stxi_d(alloca_offset - 8, _FP_REGNO, rn(reg)); | |
722 | ldxi(r0, _FP_REGNO, alloca_offset - 8); | |
723 | jit_unget_reg(reg); | |
724 | } | |
725 | ||
ba86ff93 PC |
726 | static void |
727 | _fmar_f(jit_state_t *_jit, | |
728 | jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) | |
729 | { | |
730 | #if 1 | |
731 | jit_int32_t reg; | |
732 | if (r0 != r3) { | |
733 | mulr_f(r0, r1, r2); | |
734 | addr_f(r0, r0, r3); | |
735 | } | |
736 | else { | |
737 | reg = jit_get_reg(jit_class_fpr); | |
738 | mulr_f(rn(reg), r1, r2); | |
739 | addr_f(r0, rn(reg), r3); | |
740 | jit_unget_reg(reg); | |
741 | } | |
742 | #else | |
743 | FMPYFADD_S(r1, r2, r3, r0); | |
744 | #endif | |
745 | } | |
746 | ||
747 | static void | |
748 | _fmsr_f(jit_state_t *_jit, | |
749 | jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) | |
750 | { | |
751 | jit_int32_t reg; | |
752 | if (r0 != r3) { | |
753 | mulr_f(r0, r1, r2); | |
754 | subr_f(r0, r0, r3); | |
755 | } | |
756 | else { | |
757 | reg = jit_get_reg(jit_class_fpr); | |
758 | mulr_f(rn(reg), r1, r2); | |
759 | subr_f(r0, rn(reg), r3); | |
760 | jit_unget_reg(reg); | |
761 | } | |
762 | } | |
763 | ||
764 | static void | |
765 | _fnmar_f(jit_state_t *_jit, | |
766 | jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) | |
767 | { | |
768 | jit_int32_t t0; | |
769 | t0 = jit_get_reg(jit_class_fpr); | |
770 | negr_f(rn(t0), r1); | |
771 | mulr_f(rn(t0), rn(t0), r2); | |
772 | subr_f(r0, rn(t0), r3); | |
773 | jit_unget_reg(t0); | |
774 | } | |
775 | ||
776 | static void | |
777 | _fnmsr_f(jit_state_t *_jit, | |
778 | jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) | |
779 | { | |
780 | jit_int32_t t0; | |
781 | t0 = jit_get_reg(jit_class_fpr); | |
782 | negr_f(rn(t0), r1); | |
783 | mulr_f(rn(t0), rn(t0), r2); | |
784 | addr_f(r0, rn(t0), r3); | |
785 | jit_unget_reg(t0); | |
786 | } | |
787 | ||
4a71579b PC |
788 | static void |
789 | _movi_f(jit_state_t *_jit, jit_int32_t r0, jit_float32_t *i0) | |
790 | { | |
791 | union { | |
792 | jit_int32_t i; | |
793 | jit_float32_t f; | |
794 | } data; | |
795 | jit_int32_t reg; | |
796 | ||
797 | if (_jitc->no_data) { | |
798 | data.f = *i0; | |
799 | reg = jit_get_reg(jit_class_gpr); | |
800 | movi(rn(reg), data.i); | |
801 | stxi_i(alloca_offset - 8, _FP_REGNO, rn(reg)); | |
802 | jit_unget_reg(reg); | |
803 | ldxi_f(r0, _FP_REGNO, alloca_offset - 8); | |
804 | } | |
805 | else | |
806 | ldi_f(r0, (jit_word_t)i0); | |
807 | } | |
808 | ||
ba86ff93 PC |
809 | static void |
810 | _movi_w_f(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) | |
811 | { | |
812 | jit_int32_t reg; | |
813 | reg = jit_get_reg(jit_class_gpr); | |
814 | movi(rn(reg), i0); | |
815 | movr_w_f(r0, rn(reg)); | |
816 | jit_unget_reg(reg); | |
817 | } | |
818 | ||
819 | static void | |
820 | _fmar_d(jit_state_t *_jit, | |
821 | jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) | |
822 | { | |
823 | #if 1 | |
824 | jit_int32_t reg; | |
825 | if (r0 != r3) { | |
826 | mulr_d(r0, r1, r2); | |
827 | addr_d(r0, r0, r3); | |
828 | } | |
829 | else { | |
830 | reg = jit_get_reg(jit_class_fpr); | |
831 | mulr_d(rn(reg), r1, r2); | |
832 | addr_d(r0, rn(reg), r3); | |
833 | jit_unget_reg(reg); | |
834 | } | |
835 | #else | |
836 | FMPYFADD_D(r1, r2, r3, r0); | |
837 | #endif | |
838 | } | |
839 | ||
840 | static void | |
841 | _fmsr_d(jit_state_t *_jit, | |
842 | jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) | |
843 | { | |
844 | jit_int32_t reg; | |
845 | if (r0 != r3) { | |
846 | mulr_d(r0, r1, r2); | |
847 | subr_d(r0, r0, r3); | |
848 | } | |
849 | else { | |
850 | reg = jit_get_reg(jit_class_fpr); | |
851 | mulr_d(rn(reg), r1, r2); | |
852 | subr_d(r0, rn(reg), r3); | |
853 | jit_unget_reg(reg); | |
854 | } | |
855 | } | |
856 | ||
857 | static void | |
858 | _fnmar_d(jit_state_t *_jit, | |
859 | jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) | |
860 | { | |
861 | jit_int32_t t0; | |
862 | t0 = jit_get_reg(jit_class_fpr); | |
863 | negr_d(rn(t0), r1); | |
864 | mulr_d(rn(t0), rn(t0), r2); | |
865 | subr_d(r0, rn(t0), r3); | |
866 | jit_unget_reg(t0); | |
867 | } | |
868 | ||
869 | static void | |
870 | _fnmsr_d(jit_state_t *_jit, | |
871 | jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) | |
872 | { | |
873 | jit_int32_t t0; | |
874 | t0 = jit_get_reg(jit_class_fpr); | |
875 | negr_d(rn(t0), r1); | |
876 | mulr_d(rn(t0), rn(t0), r2); | |
877 | addr_d(r0, rn(t0), r3); | |
878 | jit_unget_reg(t0); | |
879 | } | |
880 | ||
4a71579b PC |
881 | static void |
882 | _movi_d(jit_state_t *_jit, jit_int32_t r0, jit_float64_t *i0) | |
883 | { | |
884 | union { | |
885 | jit_int32_t ii[2]; | |
886 | jit_word_t w; | |
887 | jit_float64_t d; | |
888 | } data; | |
889 | jit_int32_t reg; | |
890 | ||
891 | data.d = *i0; | |
892 | if (_jitc->no_data) { | |
893 | data.d = *i0; | |
894 | reg = jit_get_reg(jit_class_gpr); | |
895 | movi(rn(reg), data.ii[0]); | |
896 | stxi_i(alloca_offset - 8, _FP_REGNO, rn(reg)); | |
897 | movi(rn(reg), data.ii[1]); | |
898 | stxi_i(alloca_offset - 4, _FP_REGNO, rn(reg)); | |
899 | jit_unget_reg(reg); | |
900 | ldxi_d(r0, _FP_REGNO, alloca_offset - 8); | |
901 | } | |
902 | else | |
903 | ldi_d(r0, (jit_word_t)i0); | |
904 | } | |
905 | ||
ba86ff93 PC |
906 | static void |
907 | _movi_ww_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0, jit_word_t i1) | |
908 | { | |
909 | jit_int32_t t0, t1; | |
910 | t0 = jit_get_reg(jit_class_gpr); | |
911 | t1 = jit_get_reg(jit_class_gpr); | |
912 | movi(rn(t0), i0); | |
913 | movi(rn(t1), i1); | |
914 | movr_ww_d(r0, rn(t0), rn(t1)); | |
915 | jit_unget_reg(t1); | |
916 | jit_unget_reg(t0); | |
917 | } | |
918 | ||
4a71579b PC |
919 | #define fpr_opi(name, type, size) \ |
920 | static void \ | |
921 | _##name##i_##type(jit_state_t *_jit, \ | |
922 | jit_int32_t r0, jit_int32_t r1, \ | |
923 | jit_float##size##_t *i0) \ | |
924 | { \ | |
925 | jit_int32_t reg = jit_get_reg(jit_class_fpr); \ | |
926 | movi_##type(rn(reg), i0); \ | |
927 | name##r_##type(r0, r1, rn(reg)); \ | |
928 | jit_unget_reg(reg); \ | |
929 | } | |
930 | #define fopi(name) fpr_opi(name, f, 32) | |
931 | #define dopi(name) fpr_opi(name, d, 64) | |
932 | ||
933 | fopi(add) | |
934 | dopi(add) | |
935 | fopi(sub) | |
936 | dopi(sub) | |
937 | fopi(rsb) | |
938 | dopi(rsb) | |
939 | fopi(mul) | |
940 | dopi(mul) | |
941 | fopi(div) | |
942 | dopi(div) | |
943 | ||
944 | static void | |
945 | _cmpr_f(jit_state_t *_jit, jit_word_t c, | |
946 | jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) | |
947 | { | |
948 | LDI(0, r0); | |
949 | FCMP_S_(r1, r2, c); | |
950 | FTEST(); | |
951 | LDI(1, r0); | |
952 | } | |
953 | ||
954 | static void | |
955 | _cmpi_f(jit_state_t *_jit, jit_word_t c, | |
956 | jit_int32_t r0, jit_int32_t r1, jit_float32_t *i0) | |
957 | { | |
958 | jit_int32_t reg = jit_get_reg(jit_class_fpr); | |
959 | movi_f(rn(reg), i0); | |
960 | cmpr_f(c, r0, r1, rn(reg)); | |
961 | jit_unget_reg(reg); | |
962 | } | |
963 | ||
964 | static void | |
965 | _cmpr_d(jit_state_t *_jit, jit_word_t c, | |
966 | jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) | |
967 | { | |
968 | LDI(0, r0); | |
969 | FCMP_D_(r1, r2, c); | |
970 | FTEST(); | |
971 | LDI(1, r0); | |
972 | } | |
973 | ||
974 | static void | |
975 | _cmpi_d(jit_state_t *_jit, jit_word_t c, | |
976 | jit_int32_t r0, jit_int32_t r1, jit_float64_t *i0) | |
977 | { | |
978 | jit_int32_t reg = jit_get_reg(jit_class_fpr); | |
979 | movi_d(rn(reg), i0); | |
980 | cmpr_d(c, r0, r1, rn(reg)); | |
981 | jit_unget_reg(reg); | |
982 | } | |
983 | ||
984 | static void | |
985 | _ldi_f(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) | |
986 | { | |
987 | jit_int32_t reg; | |
988 | assert(!(i0 & 3)); | |
989 | if (i0 >= -8192 && i0 <= 8191 && !(re_assemble_16(i0) & 6)) | |
990 | FLDWL(i0, _R0_REGNO, r0); | |
991 | else { | |
992 | reg = jit_get_reg(jit_class_gpr); | |
993 | movi(rn(reg), i0); | |
994 | ldr_f(r0, rn(reg)); | |
995 | jit_unget_reg(reg); | |
996 | } | |
997 | } | |
998 | ||
999 | #if !FLDXR | |
1000 | static void | |
1001 | _ldxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) | |
1002 | { | |
1003 | jit_int32_t reg; | |
1004 | reg = jit_get_reg(jit_class_gpr); | |
1005 | addr(rn(reg), r1, r2); | |
1006 | ldr_f(r0, rn(reg)); | |
1007 | jit_unget_reg(reg); | |
1008 | } | |
1009 | ||
1010 | static void | |
1011 | _ldxr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) | |
1012 | { | |
1013 | jit_int32_t reg; | |
1014 | reg = jit_get_reg(jit_class_gpr); | |
1015 | addr(rn(reg), r1, r2); | |
1016 | ldr_d(r0, rn(reg)); | |
1017 | jit_unget_reg(reg); | |
1018 | } | |
1019 | #endif | |
1020 | ||
1021 | static void | |
1022 | _ldxi_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) | |
1023 | { | |
1024 | jit_int32_t reg; | |
1025 | if (i0 >= -16 && i0 <= 15) | |
1026 | FLDWI(i0, r1, r0); | |
1027 | /* |im11a|0|t|i| */ | |
1028 | else if (FLDXR && i0 >= -8192 && i0 <= 8191 && !(re_assemble_16(i0) & 6)) | |
1029 | FLDWL(i0, r1, r0); | |
1030 | else { | |
1031 | reg = jit_get_reg(jit_class_gpr); | |
1032 | movi(rn(reg), i0); | |
1033 | ldxr_f(r0, r1, rn(reg)); | |
1034 | jit_unget_reg(reg); | |
1035 | } | |
1036 | } | |
1037 | ||
1038 | static void | |
1039 | _ldi_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) | |
1040 | { | |
1041 | jit_int32_t reg; | |
1042 | assert(!(i0 & 7)); | |
1043 | if (i0 >= -8192 && i0 <= 8191 && !(re_assemble_16(i0) & 14)) | |
1044 | FLDDL(i0, _R0_REGNO, r0); | |
1045 | else { | |
1046 | reg = jit_get_reg(jit_class_gpr); | |
1047 | movi(rn(reg), i0); | |
1048 | ldr_d(r0, rn(reg)); | |
1049 | jit_unget_reg(reg); | |
1050 | } | |
1051 | } | |
1052 | ||
1053 | static void | |
1054 | _ldxi_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) | |
1055 | { | |
1056 | jit_int32_t reg; | |
1057 | if (i0 >= -16 && i0 <= 15) | |
1058 | FLDDI(i0, r1, r0); | |
1059 | /* |im10a|m|a|1|i| */ | |
1060 | else if (FLDXR && i0 >= -8192 && i0 <= 8191 && !(re_assemble_16(i0) & 14)) | |
1061 | FLDDL(i0, r1, r0); | |
1062 | else { | |
1063 | reg = jit_get_reg(jit_class_gpr); | |
1064 | movi(rn(reg), i0); | |
1065 | ldxr_d(r0, r1, rn(reg)); | |
1066 | jit_unget_reg(reg); | |
1067 | } | |
1068 | } | |
1069 | ||
1070 | static void | |
1071 | _sti_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0) | |
1072 | { | |
1073 | jit_int32_t reg; | |
1074 | assert(!(i0 & 3)); | |
1075 | if (i0 >= -8192 && i0 <= 8191 && !(re_assemble_16(i0) & 6)) | |
1076 | FSTWL(r0, i0, _R0_REGNO); | |
1077 | else { | |
1078 | reg = jit_get_reg(jit_class_gpr); | |
1079 | movi(rn(reg), i0); | |
1080 | str_f(rn(reg), r0); | |
1081 | jit_unget_reg(reg); | |
1082 | } | |
1083 | } | |
1084 | ||
1085 | #if !FSTXR | |
1086 | static void | |
1087 | _stxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) | |
1088 | { | |
1089 | jit_int32_t reg; | |
1090 | reg = jit_get_reg(jit_class_gpr); | |
1091 | addr(rn(reg), r0, r1); | |
1092 | str_f(rn(reg), r2); | |
1093 | jit_unget_reg(reg); | |
1094 | } | |
1095 | ||
1096 | static void | |
1097 | _stxr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) | |
1098 | { | |
1099 | jit_int32_t reg; | |
1100 | reg = jit_get_reg(jit_class_gpr); | |
1101 | addr(rn(reg), r0, r1); | |
1102 | str_d(rn(reg), r2); | |
1103 | jit_unget_reg(reg); | |
1104 | } | |
1105 | #endif | |
1106 | ||
1107 | static void | |
1108 | _stxi_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) | |
1109 | { | |
1110 | jit_int32_t reg; | |
1111 | if (i0 >= -16 && i0 <= 15) | |
1112 | FSTWI(r1, i0, r0); | |
1113 | /* |im11a|0|t|i| */ | |
1114 | else if (FSTXR && i0 >= -8192 && i0 <= 8191 && !(re_assemble_16(i0) & 6)) | |
1115 | FSTWL(r1, i0, r0); | |
1116 | else { | |
1117 | reg = jit_get_reg(jit_class_gpr); | |
1118 | #if FSTXR | |
1119 | movi(rn(reg), i0); | |
1120 | stxr_f(rn(reg), r0, r1); | |
1121 | #else | |
1122 | addi(rn(reg), r0, i0); | |
1123 | str_f(rn(reg), r1); | |
1124 | #endif | |
1125 | jit_unget_reg(reg); | |
1126 | } | |
1127 | } | |
1128 | ||
1129 | static void | |
1130 | _sti_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0) | |
1131 | { | |
1132 | jit_int32_t reg; | |
1133 | assert(!(i0 & 7)); | |
1134 | if (i0 >= -8192 && i0 <= 8191 && !(re_assemble_16(i0) & 14)) | |
1135 | FSTDL(r0, i0, _R0_REGNO); | |
1136 | else { | |
1137 | reg = jit_get_reg(jit_class_gpr); | |
1138 | movi(rn(reg), i0); | |
1139 | str_d(rn(reg), r0); | |
1140 | jit_unget_reg(reg); | |
1141 | } | |
1142 | } | |
1143 | ||
1144 | static void | |
1145 | _stxi_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) | |
1146 | { | |
1147 | jit_int32_t reg; | |
1148 | if (i0 >= -16 && i0 <= 15) | |
1149 | FSTDI(r1, i0, r0); | |
1150 | /* |im10a|m|a|1|i| */ | |
1151 | else if (FSTXR && i0 >= -8192 && i0 <= 8191 && !(re_assemble_16(i0) & 14)) | |
1152 | FSTDL(r1, i0, r0); | |
1153 | else { | |
1154 | reg = jit_get_reg(jit_class_gpr); | |
1155 | #if FSTXR | |
1156 | movi(rn(reg), i0); | |
1157 | stxr_d(rn(reg), r0, r1); | |
1158 | #else | |
1159 | addi(rn(reg), r0, i0); | |
1160 | str_d(rn(reg), r1); | |
1161 | #endif | |
1162 | jit_unget_reg(reg); | |
1163 | } | |
1164 | } | |
1165 | ||
1166 | static jit_word_t | |
1167 | _bcmpr_f(jit_state_t *_jit, jit_word_t c, | |
1168 | jit_word_t i0, jit_int32_t r0, jit_int32_t r1) | |
1169 | { | |
1170 | jit_word_t w; | |
1171 | FCMP_S_(r0, r1, c); | |
1172 | FTEST(); | |
1173 | w = _jit->pc.w; | |
1174 | B_N(((i0 - w) >> 2) - 2, _R0_REGNO); | |
1175 | NOP(); | |
1176 | return (w); | |
1177 | } | |
1178 | ||
1179 | static jit_word_t | |
1180 | _bcmpi_f(jit_state_t *_jit, jit_word_t c, | |
1181 | jit_word_t i0, jit_int32_t r0, jit_float32_t *i1) | |
1182 | { | |
1183 | jit_word_t w; | |
1184 | jit_int32_t reg; | |
1185 | reg = jit_get_reg(jit_class_fpr|jit_class_nospill); | |
1186 | movi_f(rn(reg), i1); | |
1187 | FCMP_S_(r0, rn(reg), c); | |
1188 | FTEST(); | |
1189 | w = _jit->pc.w; | |
1190 | B_N(((i0 - w) >> 2) - 2, _R0_REGNO); | |
1191 | NOP(); | |
1192 | jit_unget_reg(reg); | |
1193 | return (w); | |
1194 | } | |
1195 | ||
1196 | static jit_word_t | |
1197 | _bcmpr_d(jit_state_t *_jit, jit_word_t c, | |
1198 | jit_word_t i0, jit_int32_t r0, jit_int32_t r1) | |
1199 | { | |
1200 | jit_word_t w; | |
1201 | FCMP_D_(r0, r1, c); | |
1202 | FTEST(); | |
1203 | w = _jit->pc.w; | |
1204 | B_N(((i0 - w) >> 2) - 2, _R0_REGNO); | |
1205 | NOP(); | |
1206 | return (w); | |
1207 | } | |
1208 | ||
1209 | static jit_word_t | |
1210 | _bcmpi_d(jit_state_t *_jit, jit_word_t c, | |
1211 | jit_word_t i0, jit_int32_t r0, jit_float64_t *i1) | |
1212 | { | |
1213 | jit_word_t w; | |
1214 | jit_int32_t reg; | |
1215 | reg = jit_get_reg(jit_class_fpr|jit_class_nospill); | |
1216 | movi_d(rn(reg), i1); | |
1217 | FCMP_D_(r0, rn(reg), c); | |
1218 | FTEST(); | |
1219 | w = _jit->pc.w; | |
1220 | B_N(((i0 - w) >> 2) - 2, _R0_REGNO); | |
1221 | NOP(); | |
1222 | jit_unget_reg(reg); | |
1223 | return (w); | |
1224 | } | |
1225 | ||
1226 | static void | |
1227 | _vaarg_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) | |
1228 | { | |
1229 | jit_int32_t reg; | |
1230 | ||
1231 | assert(_jitc->function->self.call & jit_call_varargs); | |
1232 | ||
1233 | /* Align pointer if required. */ | |
1234 | reg = jit_get_reg(jit_class_gpr); | |
1235 | andi(rn(reg), r1, 7); | |
1236 | subr(r1, r1, rn(reg)); | |
1237 | jit_unget_reg(reg); | |
1238 | ||
1239 | /* Adjust vararg stack pointer. */ | |
1240 | subi(r1, r1, 8); | |
1241 | ||
1242 | /* Load argument. */ | |
1243 | ldr_d(r0, r1); | |
1244 | } | |
1245 | #endif |