mirror of https://gitee.com/openkylin/linux.git
377 lines
13 KiB
C
377 lines
13 KiB
C
/*
|
|
* 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)
|
|
|
|
#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) || Slow(sgl_value)) \
|
|
Sall(sgl_value)++
|
|
|
|
#define Dint_isinexact_to_sgl(dint_valueA,dint_valueB) \
|
|
((Dintp1(dint_valueA) << 33 - SGL_EXP_LENGTH) || 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) || \
|
|
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)
|