| /* |
| * Linux/PA-RISC Project (http://www.parisc-linux.org/) |
| * |
| * Floating-point emulation code |
| * Copyright (C) 2001 Hewlett-Packard (Paul Bame) <[email protected]> |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License as published by |
| * the Free Software Foundation; either version 2, or (at your option) |
| * any later version. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with this program; if not, write to the Free Software |
| * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| */ |
| /* |
| * BEGIN_DESC |
| * |
| * File: |
| * @(#) pa/spmath/fcnvff.c $Revision: 1.1 $ |
| * |
| * Purpose: |
| * Single Floating-point to Double Floating-point |
| * Double Floating-point to Single Floating-point |
| * |
| * External Interfaces: |
| * dbl_to_sgl_fcnvff(srcptr,nullptr,dstptr,status) |
| * sgl_to_dbl_fcnvff(srcptr,nullptr,dstptr,status) |
| * |
| * Internal Interfaces: |
| * |
| * Theory: |
| * <<please update with a overview of the operation of this file>> |
| * |
| * END_DESC |
| */ |
| |
| |
| #include "float.h" |
| #include "sgl_float.h" |
| #include "dbl_float.h" |
| #include "cnv_float.h" |
| |
| /* |
| * Single Floating-point to Double Floating-point |
| */ |
| /*ARGSUSED*/ |
| int |
| sgl_to_dbl_fcnvff( |
| sgl_floating_point *srcptr, |
| unsigned int *nullptr, |
| dbl_floating_point *dstptr, |
| unsigned int *status) |
| { |
| register unsigned int src, resultp1, resultp2; |
| register int src_exponent; |
| |
| src = *srcptr; |
| src_exponent = Sgl_exponent(src); |
| Dbl_allp1(resultp1) = Sgl_all(src); /* set sign of result */ |
| /* |
| * Test for NaN or infinity |
| */ |
| if (src_exponent == SGL_INFINITY_EXPONENT) { |
| /* |
| * determine if NaN or infinity |
| */ |
| if (Sgl_iszero_mantissa(src)) { |
| /* |
| * is infinity; want to return double infinity |
| */ |
| Dbl_setinfinity_exponentmantissa(resultp1,resultp2); |
| Dbl_copytoptr(resultp1,resultp2,dstptr); |
| return(NOEXCEPTION); |
| } |
| else { |
| /* |
| * is NaN; signaling or quiet? |
| */ |
| if (Sgl_isone_signaling(src)) { |
| /* trap if INVALIDTRAP enabled */ |
| if (Is_invalidtrap_enabled()) |
| return(INVALIDEXCEPTION); |
| /* make NaN quiet */ |
| else { |
| Set_invalidflag(); |
| Sgl_set_quiet(src); |
| } |
| } |
| /* |
| * NaN is quiet, return as double NaN |
| */ |
| Dbl_setinfinity_exponent(resultp1); |
| Sgl_to_dbl_mantissa(src,resultp1,resultp2); |
| Dbl_copytoptr(resultp1,resultp2,dstptr); |
| return(NOEXCEPTION); |
| } |
| } |
| /* |
| * Test for zero or denormalized |
| */ |
| if (src_exponent == 0) { |
| /* |
| * determine if zero or denormalized |
| */ |
| if (Sgl_isnotzero_mantissa(src)) { |
| /* |
| * is denormalized; want to normalize |
| */ |
| Sgl_clear_signexponent(src); |
| Sgl_leftshiftby1(src); |
| Sgl_normalize(src,src_exponent); |
| Sgl_to_dbl_exponent(src_exponent,resultp1); |
| Sgl_to_dbl_mantissa(src,resultp1,resultp2); |
| } |
| else { |
| Dbl_setzero_exponentmantissa(resultp1,resultp2); |
| } |
| Dbl_copytoptr(resultp1,resultp2,dstptr); |
| return(NOEXCEPTION); |
| } |
| /* |
| * No special cases, just complete the conversion |
| */ |
| Sgl_to_dbl_exponent(src_exponent, resultp1); |
| Sgl_to_dbl_mantissa(Sgl_mantissa(src), resultp1,resultp2); |
| Dbl_copytoptr(resultp1,resultp2,dstptr); |
| return(NOEXCEPTION); |
| } |
| |
| /* |
| * Double Floating-point to Single Floating-point |
| */ |
| /*ARGSUSED*/ |
| int |
| dbl_to_sgl_fcnvff( |
| dbl_floating_point *srcptr, |
| unsigned int *nullptr, |
| sgl_floating_point *dstptr, |
| unsigned int *status) |
| { |
| register unsigned int srcp1, srcp2, result; |
| register int src_exponent, dest_exponent, dest_mantissa; |
| register boolean inexact = FALSE, guardbit = FALSE, stickybit = FALSE; |
| register boolean lsb_odd = FALSE; |
| boolean is_tiny; |
| |
| Dbl_copyfromptr(srcptr,srcp1,srcp2); |
| src_exponent = Dbl_exponent(srcp1); |
| Sgl_all(result) = Dbl_allp1(srcp1); /* set sign of result */ |
| /* |
| * Test for NaN or infinity |
| */ |
| if (src_exponent == DBL_INFINITY_EXPONENT) { |
| /* |
| * determine if NaN or infinity |
| */ |
| if (Dbl_iszero_mantissa(srcp1,srcp2)) { |
| /* |
| * is infinity; want to return single infinity |
| */ |
| Sgl_setinfinity_exponentmantissa(result); |
| *dstptr = result; |
| return(NOEXCEPTION); |
| } |
| /* |
| * is NaN; signaling or quiet? |
| */ |
| if (Dbl_isone_signaling(srcp1)) { |
| /* trap if INVALIDTRAP enabled */ |
| if (Is_invalidtrap_enabled()) return(INVALIDEXCEPTION); |
| else { |
| Set_invalidflag(); |
| /* make NaN quiet */ |
| Dbl_set_quiet(srcp1); |
| } |
| } |
| /* |
| * NaN is quiet, return as single NaN |
| */ |
| Sgl_setinfinity_exponent(result); |
| Sgl_set_mantissa(result,Dallp1(srcp1)<<3 | Dallp2(srcp2)>>29); |
| if (Sgl_iszero_mantissa(result)) Sgl_set_quiet(result); |
| *dstptr = result; |
| return(NOEXCEPTION); |
| } |
| /* |
| * Generate result |
| */ |
| Dbl_to_sgl_exponent(src_exponent,dest_exponent); |
| if (dest_exponent > 0) { |
| Dbl_to_sgl_mantissa(srcp1,srcp2,dest_mantissa,inexact,guardbit, |
| stickybit,lsb_odd); |
| } |
| else { |
| if (Dbl_iszero_exponentmantissa(srcp1,srcp2)){ |
| Sgl_setzero_exponentmantissa(result); |
| *dstptr = result; |
| return(NOEXCEPTION); |
| } |
| if (Is_underflowtrap_enabled()) { |
| Dbl_to_sgl_mantissa(srcp1,srcp2,dest_mantissa,inexact, |
| guardbit,stickybit,lsb_odd); |
| } |
| else { |
| /* compute result, determine inexact info, |
| * and set Underflowflag if appropriate |
| */ |
| Dbl_to_sgl_denormalized(srcp1,srcp2,dest_exponent, |
| dest_mantissa,inexact,guardbit,stickybit,lsb_odd, |
| is_tiny); |
| } |
| } |
| /* |
| * Now round result if not exact |
| */ |
| if (inexact) { |
| switch (Rounding_mode()) { |
| case ROUNDPLUS: |
| if (Sgl_iszero_sign(result)) dest_mantissa++; |
| break; |
| case ROUNDMINUS: |
| if (Sgl_isone_sign(result)) dest_mantissa++; |
| break; |
| case ROUNDNEAREST: |
| if (guardbit) { |
| if (stickybit || lsb_odd) dest_mantissa++; |
| } |
| } |
| } |
| Sgl_set_exponentmantissa(result,dest_mantissa); |
| |
| /* |
| * check for mantissa overflow after rounding |
| */ |
| if ((dest_exponent>0 || Is_underflowtrap_enabled()) && |
| Sgl_isone_hidden(result)) dest_exponent++; |
| |
| /* |
| * Test for overflow |
| */ |
| if (dest_exponent >= SGL_INFINITY_EXPONENT) { |
| /* trap if OVERFLOWTRAP enabled */ |
| if (Is_overflowtrap_enabled()) { |
| /* |
| * Check for gross overflow |
| */ |
| if (dest_exponent >= SGL_INFINITY_EXPONENT+SGL_WRAP) |
| return(UNIMPLEMENTEDEXCEPTION); |
| |
| /* |
| * Adjust bias of result |
| */ |
| Sgl_setwrapped_exponent(result,dest_exponent,ovfl); |
| *dstptr = result; |
| if (inexact) |
| if (Is_inexacttrap_enabled()) |
| return(OVERFLOWEXCEPTION|INEXACTEXCEPTION); |
| else Set_inexactflag(); |
| return(OVERFLOWEXCEPTION); |
| } |
| Set_overflowflag(); |
| inexact = TRUE; |
| /* set result to infinity or largest number */ |
| Sgl_setoverflow(result); |
| } |
| /* |
| * Test for underflow |
| */ |
| else if (dest_exponent <= 0) { |
| /* trap if UNDERFLOWTRAP enabled */ |
| if (Is_underflowtrap_enabled()) { |
| /* |
| * Check for gross underflow |
| */ |
| if (dest_exponent <= -(SGL_WRAP)) |
| return(UNIMPLEMENTEDEXCEPTION); |
| /* |
| * Adjust bias of result |
| */ |
| Sgl_setwrapped_exponent(result,dest_exponent,unfl); |
| *dstptr = result; |
| if (inexact) |
| if (Is_inexacttrap_enabled()) |
| return(UNDERFLOWEXCEPTION|INEXACTEXCEPTION); |
| else Set_inexactflag(); |
| return(UNDERFLOWEXCEPTION); |
| } |
| /* |
| * result is denormalized or signed zero |
| */ |
| if (inexact && is_tiny) Set_underflowflag(); |
| |
| } |
| else Sgl_set_exponent(result,dest_exponent); |
| *dstptr = result; |
| /* |
| * Trap if inexact trap is enabled |
| */ |
| if (inexact) |
| if (Is_inexacttrap_enabled()) return(INEXACTEXCEPTION); |
| else Set_inexactflag(); |
| return(NOEXCEPTION); |
| } |
