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