~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/parisc/math-emu/fcnvfu.c

Version: ~ [ linux-5.6 ] ~ [ linux-5.5.13 ] ~ [ linux-5.4.28 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.113 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.174 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.217 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.217 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.82 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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/fcnvfu.c              $Revision: 1.1 $
 26  *
 27  *  Purpose:
 28  *      Floating-point to Unsigned Fixed-point Converts
 29  *
 30  *  External Interfaces:
 31  *      dbl_to_dbl_fcnvfu(srcptr,nullptr,dstptr,status)
 32  *      dbl_to_sgl_fcnvfu(srcptr,nullptr,dstptr,status)
 33  *      sgl_to_dbl_fcnvfu(srcptr,nullptr,dstptr,status)
 34  *      sgl_to_sgl_fcnvfu(srcptr,nullptr,dstptr,status)
 35  *
 36  *  Internal Interfaces:
 37  *
 38  *  Theory:
 39  *      <<please update with a overview of the operation of this file>>
 40  *
 41  * END_DESC
 42 */
 43 
 44 
 45 #include "float.h"
 46 #include "sgl_float.h"
 47 #include "dbl_float.h"
 48 #include "cnv_float.h"
 49 
 50 /************************************************************************
 51  *  Floating-point to Unsigned Fixed-point Converts                     *
 52  ************************************************************************/
 53 
 54 /*
 55  *  Single Floating-point to Single Unsigned Fixed 
 56  */
 57 /*ARGSUSED*/
 58 int
 59 sgl_to_sgl_fcnvfu(
 60                         sgl_floating_point *srcptr,
 61                         unsigned int *nullptr,
 62                         unsigned int *dstptr,
 63                         unsigned int *status)
 64 {
 65         register unsigned int src, result;
 66         register int src_exponent;
 67         register boolean inexact = FALSE;
 68 
 69         src = *srcptr;
 70         src_exponent = Sgl_exponent(src) - SGL_BIAS;
 71 
 72         /* 
 73          * Test for overflow
 74          */
 75         if (src_exponent > SGL_FX_MAX_EXP + 1) {
 76                 if (Sgl_isone_sign(src)) {
 77                         result = 0;
 78                 } else {
 79                         result = 0xffffffff;
 80                 }
 81                 if (Is_invalidtrap_enabled()) {
 82                         return(INVALIDEXCEPTION);
 83                 }
 84                 Set_invalidflag();
 85                 *dstptr = result;
 86                 return(NOEXCEPTION);
 87         }
 88         /*
 89          * Generate result
 90          */
 91         if (src_exponent >= 0) {
 92                 /* 
 93                  * Check sign.
 94                  * If negative, trap unimplemented.
 95                  */
 96                 if (Sgl_isone_sign(src)) {
 97                         result = 0;
 98                         if (Is_invalidtrap_enabled()) {
 99                                 return(INVALIDEXCEPTION);
100                         }
101                         Set_invalidflag();
102                         *dstptr = result;
103                         return(NOEXCEPTION);
104                 }
105                 Sgl_clear_signexponent_set_hidden(src);
106                 Suint_from_sgl_mantissa(src,src_exponent,result);
107 
108                 /* check for inexact */
109                 if (Sgl_isinexact_to_unsigned(src,src_exponent)) {
110                         inexact = TRUE;
111                         /*  round result  */
112                         switch (Rounding_mode()) {
113                         case ROUNDPLUS:
114                                 result++;
115                                 break;
116                         case ROUNDMINUS: /* never negative */
117                                 break;
118                         case ROUNDNEAREST:
119                                 if (Sgl_isone_roundbit(src,src_exponent) &&
120                                     (Sgl_isone_stickybit(src,src_exponent) ||
121                                      (result & 1))) {
122                                         result++;
123                                 }
124                                 break;
125                         }
126                 }
127         } else {
128                 result = 0;
129 
130                 /* check for inexact */
131                 if (Sgl_isnotzero_exponentmantissa(src)) {
132                         inexact = TRUE;
133                         /*  round result  */
134                         switch (Rounding_mode()) {
135                         case ROUNDPLUS:
136                                 if (Sgl_iszero_sign(src)) {
137                                         result++;
138                                 }
139                                 break;
140                         case ROUNDMINUS:
141                                 if (Sgl_isone_sign(src)) {
142                                         result = 0;
143                                         if (Is_invalidtrap_enabled()) {
144                                                 return(INVALIDEXCEPTION);
145                                         }
146                                         Set_invalidflag();
147                                         inexact = FALSE;
148                                 }
149                                 break;
150                         case ROUNDNEAREST:
151                                 if (src_exponent == -1 &&
152                                     Sgl_isnotzero_mantissa(src)) {
153                                         if (Sgl_isone_sign(src)) {
154                                                 result = 0;
155                                                 if (Is_invalidtrap_enabled()) {
156                                                         return(INVALIDEXCEPTION);
157                                                 }
158                                                 Set_invalidflag();
159                                                 inexact = FALSE;
160                                         }
161                                         else result++;
162                                 }
163                                 break;
164                         }
165                 }
166         }
167         *dstptr = result;
168         if (inexact) {
169                 if (Is_inexacttrap_enabled()) return(INEXACTEXCEPTION);
170                 else Set_inexactflag();
171         }
172         return(NOEXCEPTION);
173 }
174 
175 /*
176  *  Single Floating-point to Double Unsigned Fixed 
177  */
178 /*ARGSUSED*/
179 int
180 sgl_to_dbl_fcnvfu(
181                     sgl_floating_point *srcptr,
182                     unsigned int *nullptr,
183                     dbl_unsigned *dstptr,
184                     unsigned int *status)
185 {
186         register int src_exponent;
187         register unsigned int src, resultp1, resultp2;
188         register boolean inexact = FALSE;
189 
190         src = *srcptr;
191         src_exponent = Sgl_exponent(src) - SGL_BIAS;
192 
193         /* 
194          * Test for overflow
195          */
196         if (src_exponent > DBL_FX_MAX_EXP + 1) {
197                 if (Sgl_isone_sign(src)) {
198                         resultp1 = resultp2 = 0;
199                 } else {
200                         resultp1 = resultp2 = 0xffffffff;
201                 }
202                 if (Is_invalidtrap_enabled()) {
203                         return(INVALIDEXCEPTION);
204                 }
205                 Set_invalidflag();
206                 Duint_copytoptr(resultp1,resultp2,dstptr);
207                 return(NOEXCEPTION);
208         }
209         /*
210          * Generate result
211          */
212         if (src_exponent >= 0) {
213                 /* 
214                  * Check sign.
215                  * If negative, trap unimplemented.
216                  */
217                 if (Sgl_isone_sign(src)) {
218                         resultp1 = resultp2 = 0;
219                         if (Is_invalidtrap_enabled()) {
220                                 return(INVALIDEXCEPTION);
221                         }
222                         Set_invalidflag();
223                         Duint_copytoptr(resultp1,resultp2,dstptr);
224                         return(NOEXCEPTION);
225                 }
226                 Sgl_clear_signexponent_set_hidden(src);
227                 Duint_from_sgl_mantissa(src,src_exponent,resultp1,resultp2);
228 
229                 /* check for inexact */
230                 if (Sgl_isinexact_to_unsigned(src,src_exponent)) {
231                         inexact = TRUE;
232                         /*  round result  */
233                         switch (Rounding_mode()) {
234                         case ROUNDPLUS:
235                                 Duint_increment(resultp1,resultp2);
236                                 break;
237                         case ROUNDMINUS: /* never negative */
238                                 break;
239                         case ROUNDNEAREST:
240                                 if (Sgl_isone_roundbit(src,src_exponent) &&
241                                     (Sgl_isone_stickybit(src,src_exponent) || 
242                                      Duint_isone_lowp2(resultp2))) {
243                                         Duint_increment(resultp1,resultp2);
244                                 }
245                                 break;
246                         }
247                 }
248         } else {
249                 Duint_setzero(resultp1,resultp2);
250 
251                 /* check for inexact */
252                 if (Sgl_isnotzero_exponentmantissa(src)) {
253                         inexact = TRUE;
254                         /*  round result  */
255                         switch (Rounding_mode()) {
256                         case ROUNDPLUS:
257                                 if (Sgl_iszero_sign(src)) {
258                                         Duint_increment(resultp1,resultp2);
259                                 }
260                                 break;
261                         case ROUNDMINUS:
262                                 if (Sgl_isone_sign(src)) {
263                                         resultp1 = resultp2 = 0;
264                                         if (Is_invalidtrap_enabled()) {
265                                                 return(INVALIDEXCEPTION);
266                                         }
267                                         Set_invalidflag();
268                                         inexact = FALSE;
269                                 }
270                                 break;
271                         case ROUNDNEAREST:
272                                 if (src_exponent == -1 &&
273                                     Sgl_isnotzero_mantissa(src)) {
274                                         if (Sgl_isone_sign(src)) {
275                                                 resultp1 = 0;
276                                                 resultp2 = 0;
277                                                 if (Is_invalidtrap_enabled()) {
278                                                         return(INVALIDEXCEPTION);
279                                                 }
280                                                 Set_invalidflag();
281                                                 inexact = FALSE;
282                                         }
283                                         else Duint_increment(resultp1,resultp2);
284                                 }
285                         }
286                 }
287         }
288         Duint_copytoptr(resultp1,resultp2,dstptr);
289         if (inexact) {
290                 if (Is_inexacttrap_enabled()) return(INEXACTEXCEPTION);
291                 else Set_inexactflag();
292         }
293         return(NOEXCEPTION);
294 }
295 
296 /*
297  *  Double Floating-point to Single Unsigned Fixed 
298  */
299 /*ARGSUSED*/
300 int
301 dbl_to_sgl_fcnvfu (dbl_floating_point * srcptr, unsigned int *nullptr,
302                    unsigned int *dstptr, unsigned int *status)
303 {
304         register unsigned int srcp1, srcp2, result;
305         register int src_exponent;
306         register boolean inexact = FALSE;
307 
308         Dbl_copyfromptr(srcptr,srcp1,srcp2);
309         src_exponent = Dbl_exponent(srcp1) - DBL_BIAS;
310 
311         /* 
312          * Test for overflow
313          */
314         if (src_exponent > SGL_FX_MAX_EXP + 1) {
315                 if (Dbl_isone_sign(srcp1)) {
316                         result = 0;
317                 } else {
318                         result = 0xffffffff;
319                 }
320                 if (Is_invalidtrap_enabled()) {
321                         return(INVALIDEXCEPTION);
322                 }
323                 Set_invalidflag();
324                 *dstptr = result;
325                 return(NOEXCEPTION);
326         }
327         /*
328          * Generate result
329          */
330         if (src_exponent >= 0) {
331                 /* 
332                  * Check sign.
333                  * If negative, trap unimplemented.
334                  */
335                 if (Dbl_isone_sign(srcp1)) {
336                         result = 0;
337                         if (Is_invalidtrap_enabled()) {
338                                 return(INVALIDEXCEPTION);
339                         }
340                         Set_invalidflag();
341                         *dstptr = result;
342                         return(NOEXCEPTION);
343                 }
344                 Dbl_clear_signexponent_set_hidden(srcp1);
345                 Suint_from_dbl_mantissa(srcp1,srcp2,src_exponent,result);
346 
347                 /* check for inexact */
348                 if (Dbl_isinexact_to_unsigned(srcp1,srcp2,src_exponent)) {
349                         inexact = TRUE;
350                         /*  round result  */
351                         switch (Rounding_mode()) {
352                         case ROUNDPLUS:
353                              result++;
354                              break;
355                         case ROUNDMINUS: /* never negative */
356                              break;
357                         case ROUNDNEAREST:
358                              if(Dbl_isone_roundbit(srcp1,srcp2,src_exponent) &&
359                                 (Dbl_isone_stickybit(srcp1,srcp2,src_exponent)||
360                                  result&1))
361                                    result++;
362                              break;
363                         }
364                         /* check for overflow */
365                         if (result == 0) {
366                                 result = 0xffffffff;
367                                 if (Is_invalidtrap_enabled()) {
368                                         return(INVALIDEXCEPTION);
369                                 }
370                                 Set_invalidflag();
371                                 *dstptr = result;
372                                 return(NOEXCEPTION);
373                         }
374                 }
375         } else {
376                 result = 0;
377 
378                 /* check for inexact */
379                 if (Dbl_isnotzero_exponentmantissa(srcp1,srcp2)) {
380                         inexact = TRUE;
381                         /*  round result  */
382                         switch (Rounding_mode()) {
383                         case ROUNDPLUS:
384                                 if (Dbl_iszero_sign(srcp1)) result++;
385                                 break;
386                         case ROUNDMINUS:
387                                 if (Dbl_isone_sign(srcp1)) {
388                                         result = 0;
389                                         if (Is_invalidtrap_enabled()) {
390                                                 return(INVALIDEXCEPTION);
391                                         }
392                                         Set_invalidflag();
393                                         inexact = FALSE;
394                                 }
395                                 break;
396                         case ROUNDNEAREST:
397                                 if (src_exponent == -1 &&
398                                     Dbl_isnotzero_mantissa(srcp1,srcp2))
399                                         if (Dbl_isone_sign(srcp1)) {
400                                                 result = 0;
401                                                 if (Is_invalidtrap_enabled()) {
402                                                         return(INVALIDEXCEPTION);
403                                                 }
404                                                 Set_invalidflag();
405                                                 inexact = FALSE;
406                                         }
407                                         else result++;
408                         }
409                 }
410         }
411         *dstptr = result;
412         if (inexact) {
413                 if (Is_inexacttrap_enabled()) return(INEXACTEXCEPTION);
414                 else Set_inexactflag();
415         }
416         return(NOEXCEPTION);
417 }
418 
419 /*
420  *  Double Floating-point to Double Unsigned Fixed 
421  */
422 /*ARGSUSED*/
423 int
424 dbl_to_dbl_fcnvfu (dbl_floating_point * srcptr, unsigned int *nullptr,
425                    dbl_unsigned * dstptr, unsigned int *status)
426 {
427         register int src_exponent;
428         register unsigned int srcp1, srcp2, resultp1, resultp2;
429         register boolean inexact = FALSE;
430 
431         Dbl_copyfromptr(srcptr,srcp1,srcp2);
432         src_exponent = Dbl_exponent(srcp1) - DBL_BIAS;
433 
434         /* 
435          * Test for overflow
436          */
437         if (src_exponent > DBL_FX_MAX_EXP + 1) {
438                 if (Dbl_isone_sign(srcp1)) {
439                         resultp1 = resultp2 = 0;
440                 } else {
441                         resultp1 = resultp2 = 0xffffffff;
442                 }
443                 if (Is_invalidtrap_enabled()) {
444                         return(INVALIDEXCEPTION);
445                 }
446                 Set_invalidflag();
447                 Duint_copytoptr(resultp1,resultp2,dstptr);
448                 return(NOEXCEPTION);
449         }
450  
451         /*
452          * Generate result
453          */
454         if (src_exponent >= 0) {
455                 /* 
456                  * Check sign.
457                  * If negative, trap unimplemented.
458                  */
459                 if (Dbl_isone_sign(srcp1)) {
460                         resultp1 = resultp2 = 0;
461                         if (Is_invalidtrap_enabled()) {
462                                 return(INVALIDEXCEPTION);
463                         }
464                         Set_invalidflag();
465                         Duint_copytoptr(resultp1,resultp2,dstptr);
466                         return(NOEXCEPTION);
467                 }
468                 Dbl_clear_signexponent_set_hidden(srcp1);
469                 Duint_from_dbl_mantissa(srcp1,srcp2,src_exponent,resultp1,
470                   resultp2);
471 
472                 /* check for inexact */
473                 if (Dbl_isinexact_to_unsigned(srcp1,srcp2,src_exponent)) {
474                         inexact = TRUE;
475                         /*  round result  */
476                         switch (Rounding_mode()) {
477                         case ROUNDPLUS:
478                                 Duint_increment(resultp1,resultp2);
479                                 break;
480                         case ROUNDMINUS: /* never negative */
481                                 break;
482                         case ROUNDNEAREST:
483                                 if(Dbl_isone_roundbit(srcp1,srcp2,src_exponent))
484                                   if(Dbl_isone_stickybit(srcp1,srcp2,src_exponent) || 
485                                      Duint_isone_lowp2(resultp2))
486                                         Duint_increment(resultp1,resultp2);
487                         } 
488                 }
489         } else {
490                 Duint_setzero(resultp1,resultp2);
491 
492                 /* check for inexact */
493                 if (Dbl_isnotzero_exponentmantissa(srcp1,srcp2)) {
494                         inexact = TRUE;
495                         /*  round result  */
496                         switch (Rounding_mode()) {
497                         case ROUNDPLUS:
498                                 if (Dbl_iszero_sign(srcp1)) {
499                                         Duint_increment(resultp1,resultp2);
500                                 }
501                                 break;
502                         case ROUNDMINUS:
503                                 if (Dbl_isone_sign(srcp1)) {
504                                         resultp1 = resultp2 = 0;
505                                         if (Is_invalidtrap_enabled()) {
506                                                 return(INVALIDEXCEPTION);
507                                         }
508                                         Set_invalidflag();
509                                         inexact = FALSE;
510                                 }
511                                 break;
512                         case ROUNDNEAREST:
513                                 if (src_exponent == -1 &&
514                                     Dbl_isnotzero_mantissa(srcp1,srcp2))
515                                         if (Dbl_iszero_sign(srcp1)) {
516                                                 Duint_increment(resultp1,resultp2);
517                                         } else {
518                                                 resultp1 = 0;
519                                                 resultp2 = 0;
520                                                 if (Is_invalidtrap_enabled()) {
521                                                         return(INVALIDEXCEPTION);
522                                                 }
523                                                 Set_invalidflag();
524                                                 inexact = FALSE;
525                                         }
526                         }
527                 }
528         }
529         Duint_copytoptr(resultp1,resultp2,dstptr);
530         if (inexact) {
531                 if (Is_inexacttrap_enabled()) return(INEXACTEXCEPTION);
532                 else Set_inexactflag();
533         }
534         return(NOEXCEPTION);
535 }
536 
537 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp