GNU Linux-libre 4.19.314-gnu1
[releases.git] / arch / parisc / math-emu / fcnvxf.c
1 /*
2  * Linux/PA-RISC Project (http://www.parisc-linux.org/)
3  *
4  * Floating-point emulation code
5  *  Copyright (C) 2001 Hewlett-Packard (Paul Bame) <bame@debian.org>
6  *
7  *    This program is free software; you can redistribute it and/or modify
8  *    it under the terms of the GNU General Public License as published by
9  *    the Free Software Foundation; either version 2, or (at your option)
10  *    any later version.
11  *
12  *    This program is distributed in the hope that it will be useful,
13  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
14  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  *    GNU General Public License for more details.
16  *
17  *    You should have received a copy of the GNU General Public License
18  *    along with this program; if not, write to the Free Software
19  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
20  */
21 /*
22  * BEGIN_DESC
23  *
24  *  File:
25  *      @(#)    pa/spmath/fcnvxf.c              $Revision: 1.1 $
26  *
27  *  Purpose:
28  *      Single Fixed-point to Single Floating-point
29  *      Single Fixed-point to Double Floating-point 
30  *      Double Fixed-point to Single Floating-point 
31  *      Double Fixed-point to Double Floating-point 
32  *
33  *  External Interfaces:
34  *      dbl_to_dbl_fcnvxf(srcptr,nullptr,dstptr,status)
35  *      dbl_to_sgl_fcnvxf(srcptr,nullptr,dstptr,status)
36  *      sgl_to_dbl_fcnvxf(srcptr,nullptr,dstptr,status)
37  *      sgl_to_sgl_fcnvxf(srcptr,nullptr,dstptr,status)
38  *
39  *  Internal Interfaces:
40  *
41  *  Theory:
42  *      <<please update with a overview of the operation of this file>>
43  *
44  * END_DESC
45 */
46
47
48 #include "float.h"
49 #include "sgl_float.h"
50 #include "dbl_float.h"
51 #include "cnv_float.h"
52
53 /*
54  *  Convert single fixed-point to single floating-point format
55  */
56
57 int
58 sgl_to_sgl_fcnvxf(
59                     int *srcptr,
60                     unsigned int *nullptr,
61                     sgl_floating_point *dstptr,
62                     unsigned int *status)
63 {
64         register int src, dst_exponent;
65         register unsigned int result = 0;
66
67         src = *srcptr;
68         /* 
69          * set sign bit of result and get magnitude of source 
70          */
71         if (src < 0) {
72                 Sgl_setone_sign(result);  
73                 Int_negate(src);
74         }
75         else {
76                 Sgl_setzero_sign(result);
77                 /* Check for zero */ 
78                 if (src == 0) { 
79                         Sgl_setzero(result); 
80                         *dstptr = result;
81                         return(NOEXCEPTION); 
82                 } 
83         }
84         /*
85          * Generate exponent and normalized mantissa
86          */
87         dst_exponent = 16;    /* initialize for normalization */
88         /*
89          * Check word for most significant bit set.  Returns
90          * a value in dst_exponent indicating the bit position,
91          * between -1 and 30.
92          */
93         Find_ms_one_bit(src,dst_exponent);
94         /*  left justify source, with msb at bit position 1  */
95         if (dst_exponent >= 0) src <<= dst_exponent;
96         else src = 1 << 30;
97         Sgl_set_mantissa(result, src >> (SGL_EXP_LENGTH-1));
98         Sgl_set_exponent(result, 30+SGL_BIAS - dst_exponent);
99
100         /* check for inexact */
101         if (Int_isinexact_to_sgl(src)) {
102                 switch (Rounding_mode()) {
103                         case ROUNDPLUS: 
104                                 if (Sgl_iszero_sign(result)) 
105                                         Sgl_increment(result);
106                                 break;
107                         case ROUNDMINUS: 
108                                 if (Sgl_isone_sign(result)) 
109                                         Sgl_increment(result);
110                                 break;
111                         case ROUNDNEAREST:
112                                 Sgl_roundnearest_from_int(src,result);
113                 }
114                 if (Is_inexacttrap_enabled()) {
115                         *dstptr = result;
116                         return(INEXACTEXCEPTION);
117                 }
118                 else Set_inexactflag();
119         }
120         *dstptr = result;
121         return(NOEXCEPTION);
122 }
123
124 /*
125  *  Single Fixed-point to Double Floating-point 
126  */
127
128 int
129 sgl_to_dbl_fcnvxf(
130                     int *srcptr,
131                     unsigned int *nullptr,
132                     dbl_floating_point *dstptr,
133                     unsigned int *status)
134 {
135         register int src, dst_exponent;
136         register unsigned int resultp1 = 0, resultp2 = 0;
137
138         src = *srcptr;
139         /* 
140          * set sign bit of result and get magnitude of source 
141          */
142         if (src < 0) {
143                 Dbl_setone_sign(resultp1);  
144                 Int_negate(src);
145         }
146         else {
147                 Dbl_setzero_sign(resultp1);
148                 /* Check for zero */
149                 if (src == 0) {
150                         Dbl_setzero(resultp1,resultp2);
151                         Dbl_copytoptr(resultp1,resultp2,dstptr);
152                         return(NOEXCEPTION);
153                 }
154         }
155         /*
156          * Generate exponent and normalized mantissa
157          */
158         dst_exponent = 16;    /* initialize for normalization */
159         /*
160          * Check word for most significant bit set.  Returns
161          * a value in dst_exponent indicating the bit position,
162          * between -1 and 30.
163          */
164         Find_ms_one_bit(src,dst_exponent);
165         /*  left justify source, with msb at bit position 1  */
166         if (dst_exponent >= 0) src <<= dst_exponent;
167         else src = 1 << 30;
168         Dbl_set_mantissap1(resultp1, src >> DBL_EXP_LENGTH - 1);
169         Dbl_set_mantissap2(resultp2, src << (33-DBL_EXP_LENGTH));
170         Dbl_set_exponent(resultp1, (30+DBL_BIAS) - dst_exponent);
171         Dbl_copytoptr(resultp1,resultp2,dstptr);
172         return(NOEXCEPTION);
173 }
174
175 /*
176  *  Double Fixed-point to Single Floating-point 
177  */
178
179 int
180 dbl_to_sgl_fcnvxf(
181                         dbl_integer *srcptr,
182                         unsigned int *nullptr,
183                         sgl_floating_point *dstptr,
184                         unsigned int *status)
185 {
186         int dst_exponent, srcp1;
187         unsigned int result = 0, srcp2;
188
189         Dint_copyfromptr(srcptr,srcp1,srcp2);
190         /* 
191          * set sign bit of result and get magnitude of source 
192          */
193         if (srcp1 < 0) {
194                 Sgl_setone_sign(result);  
195                 Dint_negate(srcp1,srcp2);
196         }
197         else {
198                 Sgl_setzero_sign(result);
199                 /* Check for zero */
200                 if (srcp1 == 0 && srcp2 == 0) {
201                         Sgl_setzero(result);
202                         *dstptr = result;
203                         return(NOEXCEPTION);
204                 }
205         }
206         /*
207          * Generate exponent and normalized mantissa
208          */
209         dst_exponent = 16;    /* initialize for normalization */
210         if (srcp1 == 0) {
211                 /*
212                  * Check word for most significant bit set.  Returns
213                  * a value in dst_exponent indicating the bit position,
214                  * between -1 and 30.
215                  */
216                 Find_ms_one_bit(srcp2,dst_exponent);
217                 /*  left justify source, with msb at bit position 1  */
218                 if (dst_exponent >= 0) {
219                         srcp1 = srcp2 << dst_exponent;    
220                         srcp2 = 0;
221                 }
222                 else {
223                         srcp1 = srcp2 >> 1;
224                         srcp2 <<= 31; 
225                 }
226                 /*
227                  *  since msb set is in second word, need to 
228                  *  adjust bit position count
229                  */
230                 dst_exponent += 32;
231         }
232         else {
233                 /*
234                  * Check word for most significant bit set.  Returns
235                  * a value in dst_exponent indicating the bit position,
236                  * between -1 and 30.
237                  *
238                  */
239                 Find_ms_one_bit(srcp1,dst_exponent);
240                 /*  left justify source, with msb at bit position 1  */
241                 if (dst_exponent > 0) {
242                         Variable_shift_double(srcp1,srcp2,(32-dst_exponent),
243                          srcp1); 
244                         srcp2 <<= dst_exponent;
245                 }
246                 /*
247                  * If dst_exponent = 0, we don't need to shift anything.
248                  * If dst_exponent = -1, src = - 2**63 so we won't need to 
249                  * shift srcp2.
250                  */
251                 else srcp1 >>= -(dst_exponent);
252         }
253         Sgl_set_mantissa(result, srcp1 >> SGL_EXP_LENGTH - 1);
254         Sgl_set_exponent(result, (62+SGL_BIAS) - dst_exponent);
255
256         /* check for inexact */
257         if (Dint_isinexact_to_sgl(srcp1,srcp2)) {
258                 switch (Rounding_mode()) {
259                         case ROUNDPLUS: 
260                                 if (Sgl_iszero_sign(result)) 
261                                         Sgl_increment(result);
262                                 break;
263                         case ROUNDMINUS: 
264                                 if (Sgl_isone_sign(result)) 
265                                         Sgl_increment(result);
266                                 break;
267                         case ROUNDNEAREST:
268                                 Sgl_roundnearest_from_dint(srcp1,srcp2,result);
269                 }
270                 if (Is_inexacttrap_enabled()) {
271                         *dstptr = result;
272                         return(INEXACTEXCEPTION);
273                 }
274                 else Set_inexactflag();
275         }
276         *dstptr = result;
277         return(NOEXCEPTION);
278 }
279
280 /*
281  *  Double Fixed-point to Double Floating-point 
282  */
283
284 int
285 dbl_to_dbl_fcnvxf(
286                     dbl_integer *srcptr,
287                     unsigned int *nullptr,
288                     dbl_floating_point *dstptr,
289                     unsigned int *status)
290 {
291         register int srcp1, dst_exponent;
292         register unsigned int srcp2, resultp1 = 0, resultp2 = 0;
293
294         Dint_copyfromptr(srcptr,srcp1,srcp2);
295         /* 
296          * set sign bit of result and get magnitude of source 
297          */
298         if (srcp1 < 0) {
299                 Dbl_setone_sign(resultp1);
300                 Dint_negate(srcp1,srcp2);
301         }
302         else {
303                 Dbl_setzero_sign(resultp1);
304                 /* Check for zero */
305                 if (srcp1 == 0 && srcp2 ==0) {
306                         Dbl_setzero(resultp1,resultp2);
307                         Dbl_copytoptr(resultp1,resultp2,dstptr);
308                         return(NOEXCEPTION);
309                 }
310         }
311         /*
312          * Generate exponent and normalized mantissa
313          */
314         dst_exponent = 16;    /* initialize for normalization */
315         if (srcp1 == 0) {
316                 /*
317                  * Check word for most significant bit set.  Returns
318                  * a value in dst_exponent indicating the bit position,
319                  * between -1 and 30.
320                  */
321                 Find_ms_one_bit(srcp2,dst_exponent);
322                 /*  left justify source, with msb at bit position 1  */
323                 if (dst_exponent >= 0) {
324                         srcp1 = srcp2 << dst_exponent;    
325                         srcp2 = 0;
326                 }
327                 else {
328                         srcp1 = srcp2 >> 1;
329                         srcp2 <<= 31;
330                 }
331                 /*
332                  *  since msb set is in second word, need to 
333                  *  adjust bit position count
334                  */
335                 dst_exponent += 32;
336         }
337         else {
338                 /*
339                  * Check word for most significant bit set.  Returns
340                  * a value in dst_exponent indicating the bit position,
341                  * between -1 and 30.
342                  */
343                 Find_ms_one_bit(srcp1,dst_exponent);
344                 /*  left justify source, with msb at bit position 1  */
345                 if (dst_exponent > 0) {
346                         Variable_shift_double(srcp1,srcp2,(32-dst_exponent),
347                          srcp1); 
348                         srcp2 <<= dst_exponent;
349                 }
350                 /*
351                  * If dst_exponent = 0, we don't need to shift anything.
352                  * If dst_exponent = -1, src = - 2**63 so we won't need to 
353                  * shift srcp2.
354                  */
355                 else srcp1 >>= -(dst_exponent);
356         }
357         Dbl_set_mantissap1(resultp1, srcp1 >> (DBL_EXP_LENGTH-1));
358         Shiftdouble(srcp1,srcp2,DBL_EXP_LENGTH-1,resultp2);
359         Dbl_set_exponent(resultp1, (62+DBL_BIAS) - dst_exponent);
360
361         /* check for inexact */
362         if (Dint_isinexact_to_dbl(srcp2)) {
363                 switch (Rounding_mode()) {
364                         case ROUNDPLUS: 
365                                 if (Dbl_iszero_sign(resultp1)) {
366                                         Dbl_increment(resultp1,resultp2);
367                                 }
368                                 break;
369                         case ROUNDMINUS: 
370                                 if (Dbl_isone_sign(resultp1)) {
371                                         Dbl_increment(resultp1,resultp2);
372                                 }
373                                 break;
374                         case ROUNDNEAREST:
375                                 Dbl_roundnearest_from_dint(srcp2,resultp1,
376                                 resultp2);
377                 }
378                 if (Is_inexacttrap_enabled()) {
379                         Dbl_copytoptr(resultp1,resultp2,dstptr);
380                         return(INEXACTEXCEPTION);
381                 }
382                 else Set_inexactflag();
383         }
384         Dbl_copytoptr(resultp1,resultp2,dstptr);
385         return(NOEXCEPTION);
386 }