?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
WIP FPC-III support
[linux/fpc-iii.git] / arch / parisc / math-emu / cnv_float.h
blobef783a383c5a675604338c1d89946178acb096b4
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)
Linux with added FPC-III support