| /* |
| * Linux/PA-RISC Project (http://www.parisc-linux.org/) |
| * |
| * Floating-point emulation code |
| * Copyright (C) 2001 Hewlett-Packard (Paul Bame) <bame@debian.org> |
| * |
| * 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 |
| */ |
| |
| #ifdef __NO_PA_HDRS |
| PA header file -- do not include this header file for non-PA builds. |
| #endif |
| |
| /* |
| * Some more constants |
| */ |
| #define SGL_FX_MAX_EXP 30 |
| #define DBL_FX_MAX_EXP 62 |
| #define QUAD_FX_MAX_EXP 126 |
| |
| #define Dintp1(object) (object) |
| #define Dintp2(object) (object) |
| |
| #define Duintp1(object) (object) |
| #define Duintp2(object) (object) |
| |
| #define Qintp0(object) (object) |
| #define Qintp1(object) (object) |
| #define Qintp2(object) (object) |
| #define Qintp3(object) (object) |
| |
| |
| /* |
| * These macros will be used specifically by the convert instructions. |
| * |
| * |
| * Single format macros |
| */ |
| |
| #define Sgl_to_dbl_exponent(src_exponent,dest) \ |
| Deposit_dexponent(dest,src_exponent+(DBL_BIAS-SGL_BIAS)) |
| |
| #define Sgl_to_dbl_mantissa(src_mantissa,destA,destB) \ |
| Deposit_dmantissap1(destA,src_mantissa>>3); \ |
| Dmantissap2(destB) = src_mantissa << 29 |
| |
| #define Sgl_isinexact_to_fix(sgl_value,exponent) \ |
| ((exponent < (SGL_P - 1)) ? \ |
| (Sall(sgl_value) << (SGL_EXP_LENGTH + 1 + exponent)) : FALSE) |
| |
| #define Int_isinexact_to_sgl(int_value) ((int_value << 33 - SGL_EXP_LENGTH) != 0) |
| |
| #define Sgl_roundnearest_from_int(int_value,sgl_value) \ |
| if (int_value & 1<<(SGL_EXP_LENGTH - 2)) /* round bit */ \ |
| if (((int_value << 34 - SGL_EXP_LENGTH) != 0) || Slow(sgl_value)) \ |
| Sall(sgl_value)++ |
| |
| #define Dint_isinexact_to_sgl(dint_valueA,dint_valueB) \ |
| (((Dintp1(dint_valueA) << 33 - SGL_EXP_LENGTH) != 0) || Dintp2(dint_valueB)) |
| |
| #define Sgl_roundnearest_from_dint(dint_valueA,dint_valueB,sgl_value) \ |
| if (Dintp1(dint_valueA) & 1<<(SGL_EXP_LENGTH - 2)) \ |
| if (((Dintp1(dint_valueA) << 34 - SGL_EXP_LENGTH) != 0) || \ |
| Dintp2(dint_valueB) || Slow(sgl_value)) Sall(sgl_value)++ |
| |
| #define Dint_isinexact_to_dbl(dint_value) \ |
| (Dintp2(dint_value) << 33 - DBL_EXP_LENGTH) |
| |
| #define Dbl_roundnearest_from_dint(dint_opndB,dbl_opndA,dbl_opndB) \ |
| if (Dintp2(dint_opndB) & 1<<(DBL_EXP_LENGTH - 2)) \ |
| if ((Dintp2(dint_opndB) << 34 - DBL_EXP_LENGTH) || Dlowp2(dbl_opndB)) \ |
| if ((++Dallp2(dbl_opndB))==0) Dallp1(dbl_opndA)++ |
| |
| #define Sgl_isone_roundbit(sgl_value,exponent) \ |
| ((Sall(sgl_value) << (SGL_EXP_LENGTH + 1 + exponent)) >> 31) |
| |
| #define Sgl_isone_stickybit(sgl_value,exponent) \ |
| (exponent < (SGL_P - 2) ? \ |
| Sall(sgl_value) << (SGL_EXP_LENGTH + 2 + exponent) : FALSE) |
| |
| |
| /* |
| * Double format macros |
| */ |
| |
| #define Dbl_to_sgl_exponent(src_exponent,dest) \ |
| dest = src_exponent + (SGL_BIAS - DBL_BIAS) |
| |
| #define Dbl_to_sgl_mantissa(srcA,srcB,dest,inexact,guard,sticky,odd) \ |
| Shiftdouble(Dmantissap1(srcA),Dmantissap2(srcB),29,dest); \ |
| guard = Dbit3p2(srcB); \ |
| sticky = Dallp2(srcB)<<4; \ |
| inexact = guard | sticky; \ |
| odd = Dbit2p2(srcB) |
| |
| #define Dbl_to_sgl_denormalized(srcA,srcB,exp,dest,inexact,guard,sticky,odd,tiny) \ |
| Deposit_dexponent(srcA,1); \ |
| tiny = TRUE; \ |
| if (exp >= -2) { \ |
| if (exp == 0) { \ |
| inexact = Dallp2(srcB) << 3; \ |
| guard = inexact >> 31; \ |
| sticky = inexact << 1; \ |
| Shiftdouble(Dmantissap1(srcA),Dmantissap2(srcB),29,dest); \ |
| odd = dest << 31; \ |
| if (inexact) { \ |
| switch(Rounding_mode()) { \ |
| case ROUNDPLUS: \ |
| if (Dbl_iszero_sign(srcA)) { \ |
| dest++; \ |
| if (Sgl_isone_hidden(dest)) \ |
| tiny = FALSE; \ |
| dest--; \ |
| } \ |
| break; \ |
| case ROUNDMINUS: \ |
| if (Dbl_isone_sign(srcA)) { \ |
| dest++; \ |
| if (Sgl_isone_hidden(dest)) \ |
| tiny = FALSE; \ |
| dest--; \ |
| } \ |
| break; \ |
| case ROUNDNEAREST: \ |
| if (guard && (sticky || odd)) { \ |
| dest++; \ |
| if (Sgl_isone_hidden(dest)) \ |
| tiny = FALSE; \ |
| dest--; \ |
| } \ |
| break; \ |
| } \ |
| } \ |
| /* shift right by one to get correct result */ \ |
| guard = odd; \ |
| sticky = inexact; \ |
| inexact |= guard; \ |
| dest >>= 1; \ |
| Deposit_dsign(srcA,0); \ |
| Shiftdouble(Dallp1(srcA),Dallp2(srcB),30,dest); \ |
| odd = dest << 31; \ |
| } \ |
| else { \ |
| inexact = Dallp2(srcB) << (2 + exp); \ |
| guard = inexact >> 31; \ |
| sticky = inexact << 1; \ |
| Deposit_dsign(srcA,0); \ |
| if (exp == -2) dest = Dallp1(srcA); \ |
| else Variable_shift_double(Dallp1(srcA),Dallp2(srcB),30-exp,dest); \ |
| odd = dest << 31; \ |
| } \ |
| } \ |
| else { \ |
| Deposit_dsign(srcA,0); \ |
| if (exp > (1 - SGL_P)) { \ |
| dest = Dallp1(srcA) >> (- 2 - exp); \ |
| inexact = Dallp1(srcA) << (34 + exp); \ |
| guard = inexact >> 31; \ |
| sticky = (inexact << 1) | Dallp2(srcB); \ |
| inexact |= Dallp2(srcB); \ |
| odd = dest << 31; \ |
| } \ |
| else { \ |
| dest = 0; \ |
| inexact = Dallp1(srcA) | Dallp2(srcB); \ |
| if (exp == (1 - SGL_P)) { \ |
| guard = Dhidden(srcA); \ |
| sticky = Dmantissap1(srcA) | Dallp2(srcB); \ |
| } \ |
| else { \ |
| guard = 0; \ |
| sticky = inexact; \ |
| } \ |
| odd = 0; \ |
| } \ |
| } \ |
| exp = 0 |
| |
| #define Dbl_isinexact_to_fix(dbl_valueA,dbl_valueB,exponent) \ |
| (exponent < (DBL_P-33) ? \ |
| Dallp2(dbl_valueB) || Dallp1(dbl_valueA) << (DBL_EXP_LENGTH+1+exponent) : \ |
| (exponent < (DBL_P-1) ? Dallp2(dbl_valueB) << (exponent + (33-DBL_P)) : \ |
| FALSE)) |
| |
| #define Dbl_isoverflow_to_int(exponent,dbl_valueA,dbl_valueB) \ |
| ((exponent > SGL_FX_MAX_EXP + 1) || Dsign(dbl_valueA)==0 || \ |
| Dmantissap1(dbl_valueA)!=0 || (Dallp2(dbl_valueB)>>21)!=0 ) |
| |
| #define Dbl_isone_roundbit(dbl_valueA,dbl_valueB,exponent) \ |
| ((exponent < (DBL_P - 33) ? \ |
| Dallp1(dbl_valueA) >> ((30 - DBL_EXP_LENGTH) - exponent) : \ |
| Dallp2(dbl_valueB) >> ((DBL_P - 2) - exponent)) & 1) |
| |
| #define Dbl_isone_stickybit(dbl_valueA,dbl_valueB,exponent) \ |
| (exponent < (DBL_P-34) ? \ |
| (Dallp2(dbl_valueB) || Dallp1(dbl_valueA)<<(DBL_EXP_LENGTH+2+exponent)) : \ |
| (exponent<(DBL_P-2) ? (Dallp2(dbl_valueB) << (exponent + (34-DBL_P))) : \ |
| FALSE)) |
| |
| |
| /* Int macros */ |
| |
| #define Int_from_sgl_mantissa(sgl_value,exponent) \ |
| Sall(sgl_value) = \ |
| (unsigned)(Sall(sgl_value) << SGL_EXP_LENGTH)>>(31 - exponent) |
| |
| #define Int_from_dbl_mantissa(dbl_valueA,dbl_valueB,exponent) \ |
| Shiftdouble(Dallp1(dbl_valueA),Dallp2(dbl_valueB),22,Dallp1(dbl_valueA)); \ |
| if (exponent < 31) Dallp1(dbl_valueA) >>= 30 - exponent; \ |
| else Dallp1(dbl_valueA) <<= 1 |
| |
| #define Int_negate(int_value) int_value = -int_value |
| |
| |
| /* Dint macros */ |
| |
| #define Dint_from_sgl_mantissa(sgl_value,exponent,dresultA,dresultB) \ |
| {Sall(sgl_value) <<= SGL_EXP_LENGTH; /* left-justify */ \ |
| if (exponent <= 31) { \ |
| Dintp1(dresultA) = 0; \ |
| Dintp2(dresultB) = (unsigned)Sall(sgl_value) >> (31 - exponent); \ |
| } \ |
| else { \ |
| Dintp1(dresultA) = Sall(sgl_value) >> (63 - exponent); \ |
| Dintp2(dresultB) = Sall(sgl_value) << (exponent - 31); \ |
| }} |
| |
| |
| #define Dint_from_dbl_mantissa(dbl_valueA,dbl_valueB,exponent,destA,destB) \ |
| {if (exponent < 32) { \ |
| Dintp1(destA) = 0; \ |
| if (exponent <= 20) \ |
| Dintp2(destB) = Dallp1(dbl_valueA) >> 20-exponent; \ |
| else Variable_shift_double(Dallp1(dbl_valueA),Dallp2(dbl_valueB), \ |
| 52-exponent,Dintp2(destB)); \ |
| } \ |
| else { \ |
| if (exponent <= 52) { \ |
| Dintp1(destA) = Dallp1(dbl_valueA) >> 52-exponent; \ |
| if (exponent == 52) Dintp2(destB) = Dallp2(dbl_valueB); \ |
| else Variable_shift_double(Dallp1(dbl_valueA),Dallp2(dbl_valueB), \ |
| 52-exponent,Dintp2(destB)); \ |
| } \ |
| else { \ |
| Variable_shift_double(Dallp1(dbl_valueA),Dallp2(dbl_valueB), \ |
| 84-exponent,Dintp1(destA)); \ |
| Dintp2(destB) = Dallp2(dbl_valueB) << exponent-52; \ |
| } \ |
| }} |
| |
| #define Dint_setzero(dresultA,dresultB) \ |
| Dintp1(dresultA) = 0; \ |
| Dintp2(dresultB) = 0 |
| |
| #define Dint_setone_sign(dresultA,dresultB) \ |
| Dintp1(dresultA) = ~Dintp1(dresultA); \ |
| if ((Dintp2(dresultB) = -Dintp2(dresultB)) == 0) Dintp1(dresultA)++ |
| |
| #define Dint_set_minint(dresultA,dresultB) \ |
| Dintp1(dresultA) = (unsigned int)1<<31; \ |
| Dintp2(dresultB) = 0 |
| |
| #define Dint_isone_lowp2(dresultB) (Dintp2(dresultB) & 01) |
| |
| #define Dint_increment(dresultA,dresultB) \ |
| if ((++Dintp2(dresultB))==0) Dintp1(dresultA)++ |
| |
| #define Dint_decrement(dresultA,dresultB) \ |
| if ((Dintp2(dresultB)--)==0) Dintp1(dresultA)-- |
| |
| #define Dint_negate(dresultA,dresultB) \ |
| Dintp1(dresultA) = ~Dintp1(dresultA); \ |
| if ((Dintp2(dresultB) = -Dintp2(dresultB))==0) Dintp1(dresultA)++ |
| |
| #define Dint_copyfromptr(src,destA,destB) \ |
| Dintp1(destA) = src->wd0; \ |
| Dintp2(destB) = src->wd1 |
| #define Dint_copytoptr(srcA,srcB,dest) \ |
| dest->wd0 = Dintp1(srcA); \ |
| dest->wd1 = Dintp2(srcB) |
| |
| |
| /* other macros */ |
| |
| #define Find_ms_one_bit(value, position) \ |
| { \ |
| int var; \ |
| for (var=8; var >=1; var >>= 1) { \ |
| if (value >> 32 - position) \ |
| position -= var; \ |
| else position += var; \ |
| } \ |
| if ((value >> 32 - position) == 0) \ |
| position--; \ |
| else position -= 2; \ |
| } |
| |
| |
| /* |
| * Unsigned int macros |
| */ |
| #define Duint_copyfromptr(src,destA,destB) \ |
| Dint_copyfromptr(src,destA,destB) |
| #define Duint_copytoptr(srcA,srcB,dest) \ |
| Dint_copytoptr(srcA,srcB,dest) |
| |
| #define Suint_isinexact_to_sgl(int_value) \ |
| (int_value << 32 - SGL_EXP_LENGTH) |
| |
| #define Sgl_roundnearest_from_suint(suint_value,sgl_value) \ |
| if (suint_value & 1<<(SGL_EXP_LENGTH - 1)) /* round bit */ \ |
| if ((suint_value << 33 - SGL_EXP_LENGTH) || Slow(sgl_value)) \ |
| Sall(sgl_value)++ |
| |
| #define Duint_isinexact_to_sgl(duint_valueA,duint_valueB) \ |
| ((Duintp1(duint_valueA) << 32 - SGL_EXP_LENGTH) || Duintp2(duint_valueB)) |
| |
| #define Sgl_roundnearest_from_duint(duint_valueA,duint_valueB,sgl_value) \ |
| if (Duintp1(duint_valueA) & 1<<(SGL_EXP_LENGTH - 1)) \ |
| if ((Duintp1(duint_valueA) << 33 - SGL_EXP_LENGTH) || \ |
| Duintp2(duint_valueB) || Slow(sgl_value)) Sall(sgl_value)++ |
| |
| #define Duint_isinexact_to_dbl(duint_value) \ |
| (Duintp2(duint_value) << 32 - DBL_EXP_LENGTH) |
| |
| #define Dbl_roundnearest_from_duint(duint_opndB,dbl_opndA,dbl_opndB) \ |
| if (Duintp2(duint_opndB) & 1<<(DBL_EXP_LENGTH - 1)) \ |
| if ((Duintp2(duint_opndB) << 33 - DBL_EXP_LENGTH) || Dlowp2(dbl_opndB)) \ |
| if ((++Dallp2(dbl_opndB))==0) Dallp1(dbl_opndA)++ |
| |
| #define Suint_from_sgl_mantissa(src,exponent,result) \ |
| Sall(result) = (unsigned)(Sall(src) << SGL_EXP_LENGTH)>>(31 - exponent) |
| |
| #define Sgl_isinexact_to_unsigned(sgl_value,exponent) \ |
| Sgl_isinexact_to_fix(sgl_value,exponent) |
| |
| #define Duint_from_sgl_mantissa(sgl_value,exponent,dresultA,dresultB) \ |
| {unsigned int val = Sall(sgl_value) << SGL_EXP_LENGTH; \ |
| if (exponent <= 31) { \ |
| Dintp1(dresultA) = 0; \ |
| Dintp2(dresultB) = val >> (31 - exponent); \ |
| } \ |
| else { \ |
| Dintp1(dresultA) = val >> (63 - exponent); \ |
| Dintp2(dresultB) = exponent <= 62 ? val << (exponent - 31) : 0; \ |
| } \ |
| } |
| |
| #define Duint_setzero(dresultA,dresultB) \ |
| Dint_setzero(dresultA,dresultB) |
| |
| #define Duint_increment(dresultA,dresultB) Dint_increment(dresultA,dresultB) |
| |
| #define Duint_isone_lowp2(dresultB) Dint_isone_lowp2(dresultB) |
| |
| #define Suint_from_dbl_mantissa(srcA,srcB,exponent,dest) \ |
| Shiftdouble(Dallp1(srcA),Dallp2(srcB),21,dest); \ |
| dest = (unsigned)dest >> 31 - exponent |
| |
| #define Dbl_isinexact_to_unsigned(dbl_valueA,dbl_valueB,exponent) \ |
| Dbl_isinexact_to_fix(dbl_valueA,dbl_valueB,exponent) |
| |
| #define Duint_from_dbl_mantissa(dbl_valueA,dbl_valueB,exponent,destA,destB) \ |
| Dint_from_dbl_mantissa(dbl_valueA,dbl_valueB,exponent,destA,destB) |
