1 | /* SPDX-License-Identifier: GPL-2.0-or-later */ |
2 | /* |
3 | * Linux/PA-RISC Project (http://www.parisc-linux.org/) |
4 | * |
5 | * Floating-point emulation code |
6 | * Copyright (C) 2001 Hewlett-Packard (Paul Bame) <bame@debian.org> |
7 | */ |
8 | |
9 | #ifdef __NO_PA_HDRS |
10 | PA header file -- do not include this header file for non-PA builds. |
11 | #endif |
12 | |
13 | /* |
14 | * Some more constants |
15 | */ |
16 | #define SGL_FX_MAX_EXP 30 |
17 | #define DBL_FX_MAX_EXP 62 |
18 | #define QUAD_FX_MAX_EXP 126 |
19 | |
20 | #define Dintp1(object) (object) |
21 | #define Dintp2(object) (object) |
22 | |
23 | #define Duintp1(object) (object) |
24 | #define Duintp2(object) (object) |
25 | |
26 | #define Qintp0(object) (object) |
27 | #define Qintp1(object) (object) |
28 | #define Qintp2(object) (object) |
29 | #define Qintp3(object) (object) |
30 | |
31 | |
32 | /* |
33 | * These macros will be used specifically by the convert instructions. |
34 | * |
35 | * |
36 | * Single format macros |
37 | */ |
38 | |
39 | #define Sgl_to_dbl_exponent(src_exponent,dest) \ |
40 | Deposit_dexponent(dest,src_exponent+(DBL_BIAS-SGL_BIAS)) |
41 | |
42 | #define Sgl_to_dbl_mantissa(src_mantissa,destA,destB) \ |
43 | Deposit_dmantissap1(destA,src_mantissa>>3); \ |
44 | Dmantissap2(destB) = src_mantissa << 29 |
45 | |
46 | #define Sgl_isinexact_to_fix(sgl_value,exponent) \ |
47 | ((exponent < (SGL_P - 1)) ? \ |
48 | (Sall(sgl_value) << (SGL_EXP_LENGTH + 1 + exponent)) : FALSE) |
49 | |
50 | #define Int_isinexact_to_sgl(int_value) ((int_value << 33 - SGL_EXP_LENGTH) != 0) |
51 | |
52 | #define Sgl_roundnearest_from_int(int_value,sgl_value) \ |
53 | if (int_value & 1<<(SGL_EXP_LENGTH - 2)) /* round bit */ \ |
54 | if (((int_value << 34 - SGL_EXP_LENGTH) != 0) || Slow(sgl_value)) \ |
55 | Sall(sgl_value)++ |
56 | |
57 | #define Dint_isinexact_to_sgl(dint_valueA,dint_valueB) \ |
58 | (((Dintp1(dint_valueA) << 33 - SGL_EXP_LENGTH) != 0) || Dintp2(dint_valueB)) |
59 | |
60 | #define Sgl_roundnearest_from_dint(dint_valueA,dint_valueB,sgl_value) \ |
61 | if (Dintp1(dint_valueA) & 1<<(SGL_EXP_LENGTH - 2)) \ |
62 | if (((Dintp1(dint_valueA) << 34 - SGL_EXP_LENGTH) != 0) || \ |
63 | Dintp2(dint_valueB) || Slow(sgl_value)) Sall(sgl_value)++ |
64 | |
65 | #define Dint_isinexact_to_dbl(dint_value) \ |
66 | (Dintp2(dint_value) << 33 - DBL_EXP_LENGTH) |
67 | |
68 | #define Dbl_roundnearest_from_dint(dint_opndB,dbl_opndA,dbl_opndB) \ |
69 | if (Dintp2(dint_opndB) & 1<<(DBL_EXP_LENGTH - 2)) \ |
70 | if ((Dintp2(dint_opndB) << 34 - DBL_EXP_LENGTH) || Dlowp2(dbl_opndB)) \ |
71 | if ((++Dallp2(dbl_opndB))==0) Dallp1(dbl_opndA)++ |
72 | |
73 | #define Sgl_isone_roundbit(sgl_value,exponent) \ |
74 | ((Sall(sgl_value) << (SGL_EXP_LENGTH + 1 + exponent)) >> 31) |
75 | |
76 | #define Sgl_isone_stickybit(sgl_value,exponent) \ |
77 | (exponent < (SGL_P - 2) ? \ |
78 | Sall(sgl_value) << (SGL_EXP_LENGTH + 2 + exponent) : FALSE) |
79 | |
80 | |
81 | /* |
82 | * Double format macros |
83 | */ |
84 | |
85 | #define Dbl_to_sgl_exponent(src_exponent,dest) \ |
86 | dest = src_exponent + (SGL_BIAS - DBL_BIAS) |
87 | |
88 | #define Dbl_to_sgl_mantissa(srcA,srcB,dest,inexact,guard,sticky,odd) \ |
89 | Shiftdouble(Dmantissap1(srcA),Dmantissap2(srcB),29,dest); \ |
90 | guard = Dbit3p2(srcB); \ |
91 | sticky = Dallp2(srcB)<<4; \ |
92 | inexact = guard | sticky; \ |
93 | odd = Dbit2p2(srcB) |
94 | |
95 | #define Dbl_to_sgl_denormalized(srcA,srcB,exp,dest,inexact,guard,sticky,odd,tiny) \ |
96 | Deposit_dexponent(srcA,1); \ |
97 | tiny = TRUE; \ |
98 | if (exp >= -2) { \ |
99 | if (exp == 0) { \ |
100 | inexact = Dallp2(srcB) << 3; \ |
101 | guard = inexact >> 31; \ |
102 | sticky = inexact << 1; \ |
103 | Shiftdouble(Dmantissap1(srcA),Dmantissap2(srcB),29,dest); \ |
104 | odd = dest << 31; \ |
105 | if (inexact) { \ |
106 | switch(Rounding_mode()) { \ |
107 | case ROUNDPLUS: \ |
108 | if (Dbl_iszero_sign(srcA)) { \ |
109 | dest++; \ |
110 | if (Sgl_isone_hidden(dest)) \ |
111 | tiny = FALSE; \ |
112 | dest--; \ |
113 | } \ |
114 | break; \ |
115 | case ROUNDMINUS: \ |
116 | if (Dbl_isone_sign(srcA)) { \ |
117 | dest++; \ |
118 | if (Sgl_isone_hidden(dest)) \ |
119 | tiny = FALSE; \ |
120 | dest--; \ |
121 | } \ |
122 | break; \ |
123 | case ROUNDNEAREST: \ |
124 | if (guard && (sticky || odd)) { \ |
125 | dest++; \ |
126 | if (Sgl_isone_hidden(dest)) \ |
127 | tiny = FALSE; \ |
128 | dest--; \ |
129 | } \ |
130 | break; \ |
131 | } \ |
132 | } \ |
133 | /* shift right by one to get correct result */ \ |
134 | guard = odd; \ |
135 | sticky = inexact; \ |
136 | inexact |= guard; \ |
137 | dest >>= 1; \ |
138 | Deposit_dsign(srcA,0); \ |
139 | Shiftdouble(Dallp1(srcA),Dallp2(srcB),30,dest); \ |
140 | odd = dest << 31; \ |
141 | } \ |
142 | else { \ |
143 | inexact = Dallp2(srcB) << (2 + exp); \ |
144 | guard = inexact >> 31; \ |
145 | sticky = inexact << 1; \ |
146 | Deposit_dsign(srcA,0); \ |
147 | if (exp == -2) dest = Dallp1(srcA); \ |
148 | else Variable_shift_double(Dallp1(srcA),Dallp2(srcB),30-exp,dest); \ |
149 | odd = dest << 31; \ |
150 | } \ |
151 | } \ |
152 | else { \ |
153 | Deposit_dsign(srcA,0); \ |
154 | if (exp > (1 - SGL_P)) { \ |
155 | dest = Dallp1(srcA) >> (- 2 - exp); \ |
156 | inexact = Dallp1(srcA) << (34 + exp); \ |
157 | guard = inexact >> 31; \ |
158 | sticky = (inexact << 1) | Dallp2(srcB); \ |
159 | inexact |= Dallp2(srcB); \ |
160 | odd = dest << 31; \ |
161 | } \ |
162 | else { \ |
163 | dest = 0; \ |
164 | inexact = Dallp1(srcA) | Dallp2(srcB); \ |
165 | if (exp == (1 - SGL_P)) { \ |
166 | guard = Dhidden(srcA); \ |
167 | sticky = Dmantissap1(srcA) | Dallp2(srcB); \ |
168 | } \ |
169 | else { \ |
170 | guard = 0; \ |
171 | sticky = inexact; \ |
172 | } \ |
173 | odd = 0; \ |
174 | } \ |
175 | } \ |
176 | exp = 0 |
177 | |
178 | #define Dbl_isinexact_to_fix(dbl_valueA,dbl_valueB,exponent) \ |
179 | (exponent < (DBL_P-33) ? \ |
180 | Dallp2(dbl_valueB) || Dallp1(dbl_valueA) << (DBL_EXP_LENGTH+1+exponent) : \ |
181 | (exponent < (DBL_P-1) ? Dallp2(dbl_valueB) << (exponent + (33-DBL_P)) : \ |
182 | FALSE)) |
183 | |
184 | #define Dbl_isoverflow_to_int(exponent,dbl_valueA,dbl_valueB) \ |
185 | ((exponent > SGL_FX_MAX_EXP + 1) || Dsign(dbl_valueA)==0 || \ |
186 | Dmantissap1(dbl_valueA)!=0 || (Dallp2(dbl_valueB)>>21)!=0 ) |
187 | |
188 | #define Dbl_isone_roundbit(dbl_valueA,dbl_valueB,exponent) \ |
189 | ((exponent < (DBL_P - 33) ? \ |
190 | Dallp1(dbl_valueA) >> ((30 - DBL_EXP_LENGTH) - exponent) : \ |
191 | Dallp2(dbl_valueB) >> ((DBL_P - 2) - exponent)) & 1) |
192 | |
193 | #define Dbl_isone_stickybit(dbl_valueA,dbl_valueB,exponent) \ |
194 | (exponent < (DBL_P-34) ? \ |
195 | (Dallp2(dbl_valueB) || Dallp1(dbl_valueA)<<(DBL_EXP_LENGTH+2+exponent)) : \ |
196 | (exponent<(DBL_P-2) ? (Dallp2(dbl_valueB) << (exponent + (34-DBL_P))) : \ |
197 | FALSE)) |
198 | |
199 | |
200 | /* Int macros */ |
201 | |
202 | #define Int_from_sgl_mantissa(sgl_value,exponent) \ |
203 | Sall(sgl_value) = \ |
204 | (unsigned)(Sall(sgl_value) << SGL_EXP_LENGTH)>>(31 - exponent) |
205 | |
206 | #define Int_from_dbl_mantissa(dbl_valueA,dbl_valueB,exponent) \ |
207 | Shiftdouble(Dallp1(dbl_valueA),Dallp2(dbl_valueB),22,Dallp1(dbl_valueA)); \ |
208 | if (exponent < 31) Dallp1(dbl_valueA) >>= 30 - exponent; \ |
209 | else Dallp1(dbl_valueA) <<= 1 |
210 | |
211 | #define Int_negate(int_value) int_value = -int_value |
212 | |
213 | |
214 | /* Dint macros */ |
215 | |
216 | #define Dint_from_sgl_mantissa(sgl_value,exponent,dresultA,dresultB) \ |
217 | {Sall(sgl_value) <<= SGL_EXP_LENGTH; /* left-justify */ \ |
218 | if (exponent <= 31) { \ |
219 | Dintp1(dresultA) = 0; \ |
220 | Dintp2(dresultB) = (unsigned)Sall(sgl_value) >> (31 - exponent); \ |
221 | } \ |
222 | else { \ |
223 | Dintp1(dresultA) = Sall(sgl_value) >> (63 - exponent); \ |
224 | Dintp2(dresultB) = Sall(sgl_value) << (exponent - 31); \ |
225 | }} |
226 | |
227 | |
228 | #define Dint_from_dbl_mantissa(dbl_valueA,dbl_valueB,exponent,destA,destB) \ |
229 | {if (exponent < 32) { \ |
230 | Dintp1(destA) = 0; \ |
231 | if (exponent <= 20) \ |
232 | Dintp2(destB) = Dallp1(dbl_valueA) >> 20-exponent; \ |
233 | else Variable_shift_double(Dallp1(dbl_valueA),Dallp2(dbl_valueB), \ |
234 | 52-exponent,Dintp2(destB)); \ |
235 | } \ |
236 | else { \ |
237 | if (exponent <= 52) { \ |
238 | Dintp1(destA) = Dallp1(dbl_valueA) >> 52-exponent; \ |
239 | if (exponent == 52) Dintp2(destB) = Dallp2(dbl_valueB); \ |
240 | else Variable_shift_double(Dallp1(dbl_valueA),Dallp2(dbl_valueB), \ |
241 | 52-exponent,Dintp2(destB)); \ |
242 | } \ |
243 | else { \ |
244 | Variable_shift_double(Dallp1(dbl_valueA),Dallp2(dbl_valueB), \ |
245 | 84-exponent,Dintp1(destA)); \ |
246 | Dintp2(destB) = Dallp2(dbl_valueB) << exponent-52; \ |
247 | } \ |
248 | }} |
249 | |
250 | #define Dint_setzero(dresultA,dresultB) \ |
251 | Dintp1(dresultA) = 0; \ |
252 | Dintp2(dresultB) = 0 |
253 | |
254 | #define Dint_setone_sign(dresultA,dresultB) \ |
255 | Dintp1(dresultA) = ~Dintp1(dresultA); \ |
256 | if ((Dintp2(dresultB) = -Dintp2(dresultB)) == 0) Dintp1(dresultA)++ |
257 | |
258 | #define Dint_set_minint(dresultA,dresultB) \ |
259 | Dintp1(dresultA) = (unsigned int)1<<31; \ |
260 | Dintp2(dresultB) = 0 |
261 | |
262 | #define Dint_isone_lowp2(dresultB) (Dintp2(dresultB) & 01) |
263 | |
264 | #define Dint_increment(dresultA,dresultB) \ |
265 | if ((++Dintp2(dresultB))==0) Dintp1(dresultA)++ |
266 | |
267 | #define Dint_decrement(dresultA,dresultB) \ |
268 | if ((Dintp2(dresultB)--)==0) Dintp1(dresultA)-- |
269 | |
270 | #define Dint_negate(dresultA,dresultB) \ |
271 | Dintp1(dresultA) = ~Dintp1(dresultA); \ |
272 | if ((Dintp2(dresultB) = -Dintp2(dresultB))==0) Dintp1(dresultA)++ |
273 | |
274 | #define Dint_copyfromptr(src,destA,destB) \ |
275 | Dintp1(destA) = src->wd0; \ |
276 | Dintp2(destB) = src->wd1 |
277 | #define Dint_copytoptr(srcA,srcB,dest) \ |
278 | dest->wd0 = Dintp1(srcA); \ |
279 | dest->wd1 = Dintp2(srcB) |
280 | |
281 | |
282 | /* other macros */ |
283 | |
284 | #define Find_ms_one_bit(value, position) \ |
285 | { \ |
286 | int var; \ |
287 | for (var=8; var >=1; var >>= 1) { \ |
288 | if (value >> 32 - position) \ |
289 | position -= var; \ |
290 | else position += var; \ |
291 | } \ |
292 | if ((value >> 32 - position) == 0) \ |
293 | position--; \ |
294 | else position -= 2; \ |
295 | } |
296 | |
297 | |
298 | /* |
299 | * Unsigned int macros |
300 | */ |
301 | #define Duint_copyfromptr(src,destA,destB) \ |
302 | Dint_copyfromptr(src,destA,destB) |
303 | #define Duint_copytoptr(srcA,srcB,dest) \ |
304 | Dint_copytoptr(srcA,srcB,dest) |
305 | |
306 | #define Suint_isinexact_to_sgl(int_value) \ |
307 | (int_value << 32 - SGL_EXP_LENGTH) |
308 | |
309 | #define Sgl_roundnearest_from_suint(suint_value,sgl_value) \ |
310 | if (suint_value & 1<<(SGL_EXP_LENGTH - 1)) /* round bit */ \ |
311 | if ((suint_value << 33 - SGL_EXP_LENGTH) || Slow(sgl_value)) \ |
312 | Sall(sgl_value)++ |
313 | |
314 | #define Duint_isinexact_to_sgl(duint_valueA,duint_valueB) \ |
315 | ((Duintp1(duint_valueA) << 32 - SGL_EXP_LENGTH) || Duintp2(duint_valueB)) |
316 | |
317 | #define Sgl_roundnearest_from_duint(duint_valueA,duint_valueB,sgl_value) \ |
318 | if (Duintp1(duint_valueA) & 1<<(SGL_EXP_LENGTH - 1)) \ |
319 | if ((Duintp1(duint_valueA) << 33 - SGL_EXP_LENGTH) || \ |
320 | Duintp2(duint_valueB) || Slow(sgl_value)) Sall(sgl_value)++ |
321 | |
322 | #define Duint_isinexact_to_dbl(duint_value) \ |
323 | (Duintp2(duint_value) << 32 - DBL_EXP_LENGTH) |
324 | |
325 | #define Dbl_roundnearest_from_duint(duint_opndB,dbl_opndA,dbl_opndB) \ |
326 | if (Duintp2(duint_opndB) & 1<<(DBL_EXP_LENGTH - 1)) \ |
327 | if ((Duintp2(duint_opndB) << 33 - DBL_EXP_LENGTH) || Dlowp2(dbl_opndB)) \ |
328 | if ((++Dallp2(dbl_opndB))==0) Dallp1(dbl_opndA)++ |
329 | |
330 | #define Suint_from_sgl_mantissa(src,exponent,result) \ |
331 | Sall(result) = (unsigned)(Sall(src) << SGL_EXP_LENGTH)>>(31 - exponent) |
332 | |
333 | #define Sgl_isinexact_to_unsigned(sgl_value,exponent) \ |
334 | Sgl_isinexact_to_fix(sgl_value,exponent) |
335 | |
336 | #define Duint_from_sgl_mantissa(sgl_value,exponent,dresultA,dresultB) \ |
337 | {unsigned int val = Sall(sgl_value) << SGL_EXP_LENGTH; \ |
338 | if (exponent <= 31) { \ |
339 | Dintp1(dresultA) = 0; \ |
340 | Dintp2(dresultB) = val >> (31 - exponent); \ |
341 | } \ |
342 | else { \ |
343 | Dintp1(dresultA) = val >> (63 - exponent); \ |
344 | Dintp2(dresultB) = exponent <= 62 ? val << (exponent - 31) : 0; \ |
345 | } \ |
346 | } |
347 | |
348 | #define Duint_setzero(dresultA,dresultB) \ |
349 | Dint_setzero(dresultA,dresultB) |
350 | |
351 | #define Duint_increment(dresultA,dresultB) Dint_increment(dresultA,dresultB) |
352 | |
353 | #define Duint_isone_lowp2(dresultB) Dint_isone_lowp2(dresultB) |
354 | |
355 | #define Suint_from_dbl_mantissa(srcA,srcB,exponent,dest) \ |
356 | Shiftdouble(Dallp1(srcA),Dallp2(srcB),21,dest); \ |
357 | dest = (unsigned)dest >> 31 - exponent |
358 | |
359 | #define Dbl_isinexact_to_unsigned(dbl_valueA,dbl_valueB,exponent) \ |
360 | Dbl_isinexact_to_fix(dbl_valueA,dbl_valueB,exponent) |
361 | |
362 | #define Duint_from_dbl_mantissa(dbl_valueA,dbl_valueB,exponent,destA,destB) \ |
363 | Dint_from_dbl_mantissa(dbl_valueA,dbl_valueB,exponent,destA,destB) |
364 | |