dbl_float.h 35 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834
  1. /* SPDX-License-Identifier: GPL-2.0-or-later */
  2. /*
  3. * Linux/PA-RISC Project (http://www.parisc-linux.org/)
  4. *
  5. * Floating-point emulation code
  6. * Copyright (C) 2001 Hewlett-Packard (Paul Bame) <bame@debian.org>
  7. */
  8. #ifdef __NO_PA_HDRS
  9. PA header file -- do not include this header file for non-PA builds.
  10. #endif
  11. /* 32-bit word grabbing functions */
  12. #define Dbl_firstword(value) Dallp1(value)
  13. #define Dbl_secondword(value) Dallp2(value)
  14. #define Dbl_thirdword(value) dummy_location
  15. #define Dbl_fourthword(value) dummy_location
  16. #define Dbl_sign(object) Dsign(object)
  17. #define Dbl_exponent(object) Dexponent(object)
  18. #define Dbl_signexponent(object) Dsignexponent(object)
  19. #define Dbl_mantissap1(object) Dmantissap1(object)
  20. #define Dbl_mantissap2(object) Dmantissap2(object)
  21. #define Dbl_exponentmantissap1(object) Dexponentmantissap1(object)
  22. #define Dbl_allp1(object) Dallp1(object)
  23. #define Dbl_allp2(object) Dallp2(object)
  24. /* dbl_and_signs ANDs the sign bits of each argument and puts the result
  25. * into the first argument. dbl_or_signs ors those same sign bits */
  26. #define Dbl_and_signs( src1dst, src2) \
  27. Dallp1(src1dst) = (Dallp1(src2)|~((unsigned int)1<<31)) & Dallp1(src1dst)
  28. #define Dbl_or_signs( src1dst, src2) \
  29. Dallp1(src1dst) = (Dallp1(src2)&((unsigned int)1<<31)) | Dallp1(src1dst)
  30. /* The hidden bit is always the low bit of the exponent */
  31. #define Dbl_clear_exponent_set_hidden(srcdst) Deposit_dexponent(srcdst,1)
  32. #define Dbl_clear_signexponent_set_hidden(srcdst) \
  33. Deposit_dsignexponent(srcdst,1)
  34. #define Dbl_clear_sign(srcdst) Dallp1(srcdst) &= ~((unsigned int)1<<31)
  35. #define Dbl_clear_signexponent(srcdst) \
  36. Dallp1(srcdst) &= Dmantissap1((unsigned int)-1)
  37. /* Exponent field for doubles has already been cleared and may be
  38. * included in the shift. Here we need to generate two double width
  39. * variable shifts. The insignificant bits can be ignored.
  40. * MTSAR f(varamount)
  41. * VSHD srcdst.high,srcdst.low => srcdst.low
  42. * VSHD 0,srcdst.high => srcdst.high
  43. * This is very difficult to model with C expressions since the shift amount
  44. * could exceed 32. */
  45. /* varamount must be less than 64 */
  46. #define Dbl_rightshift(srcdstA, srcdstB, varamount) \
  47. {if((varamount) >= 32) { \
  48. Dallp2(srcdstB) = Dallp1(srcdstA) >> (varamount-32); \
  49. Dallp1(srcdstA)=0; \
  50. } \
  51. else if(varamount > 0) { \
  52. Variable_shift_double(Dallp1(srcdstA), Dallp2(srcdstB), \
  53. (varamount), Dallp2(srcdstB)); \
  54. Dallp1(srcdstA) >>= varamount; \
  55. } }
  56. /* varamount must be less than 64 */
  57. #define Dbl_rightshift_exponentmantissa(srcdstA, srcdstB, varamount) \
  58. {if((varamount) >= 32) { \
  59. Dallp2(srcdstB) = Dexponentmantissap1(srcdstA) >> (varamount-32); \
  60. Dallp1(srcdstA) &= ((unsigned int)1<<31); /* clear expmant field */ \
  61. } \
  62. else if(varamount > 0) { \
  63. Variable_shift_double(Dexponentmantissap1(srcdstA), Dallp2(srcdstB), \
  64. (varamount), Dallp2(srcdstB)); \
  65. Deposit_dexponentmantissap1(srcdstA, \
  66. (Dexponentmantissap1(srcdstA)>>varamount)); \
  67. } }
  68. /* varamount must be less than 64 */
  69. #define Dbl_leftshift(srcdstA, srcdstB, varamount) \
  70. {if((varamount) >= 32) { \
  71. Dallp1(srcdstA) = Dallp2(srcdstB) << (varamount-32); \
  72. Dallp2(srcdstB)=0; \
  73. } \
  74. else { \
  75. if ((varamount) > 0) { \
  76. Dallp1(srcdstA) = (Dallp1(srcdstA) << (varamount)) | \
  77. (Dallp2(srcdstB) >> (32-(varamount))); \
  78. Dallp2(srcdstB) <<= varamount; \
  79. } \
  80. } }
  81. #define Dbl_leftshiftby1_withextent(lefta,leftb,right,resulta,resultb) \
  82. Shiftdouble(Dallp1(lefta), Dallp2(leftb), 31, Dallp1(resulta)); \
  83. Shiftdouble(Dallp2(leftb), Extall(right), 31, Dallp2(resultb))
  84. #define Dbl_rightshiftby1_withextent(leftb,right,dst) \
  85. Extall(dst) = (Dallp2(leftb) << 31) | ((unsigned int)Extall(right) >> 1) | \
  86. Extlow(right)
  87. #define Dbl_arithrightshiftby1(srcdstA,srcdstB) \
  88. Shiftdouble(Dallp1(srcdstA),Dallp2(srcdstB),1,Dallp2(srcdstB));\
  89. Dallp1(srcdstA) = (int)Dallp1(srcdstA) >> 1
  90. /* Sign extend the sign bit with an integer destination */
  91. #define Dbl_signextendedsign(value) Dsignedsign(value)
  92. #define Dbl_isone_hidden(dbl_value) (Is_dhidden(dbl_value)!=0)
  93. /* Singles and doubles may include the sign and exponent fields. The
  94. * hidden bit and the hidden overflow must be included. */
  95. #define Dbl_increment(dbl_valueA,dbl_valueB) \
  96. if( (Dallp2(dbl_valueB) += 1) == 0 ) Dallp1(dbl_valueA) += 1
  97. #define Dbl_increment_mantissa(dbl_valueA,dbl_valueB) \
  98. if( (Dmantissap2(dbl_valueB) += 1) == 0 ) \
  99. Deposit_dmantissap1(dbl_valueA,dbl_valueA+1)
  100. #define Dbl_decrement(dbl_valueA,dbl_valueB) \
  101. if( Dallp2(dbl_valueB) == 0 ) Dallp1(dbl_valueA) -= 1; \
  102. Dallp2(dbl_valueB) -= 1
  103. #define Dbl_isone_sign(dbl_value) (Is_dsign(dbl_value)!=0)
  104. #define Dbl_isone_hiddenoverflow(dbl_value) (Is_dhiddenoverflow(dbl_value)!=0)
  105. #define Dbl_isone_lowmantissap1(dbl_valueA) (Is_dlowp1(dbl_valueA)!=0)
  106. #define Dbl_isone_lowmantissap2(dbl_valueB) (Is_dlowp2(dbl_valueB)!=0)
  107. #define Dbl_isone_signaling(dbl_value) (Is_dsignaling(dbl_value)!=0)
  108. #define Dbl_is_signalingnan(dbl_value) (Dsignalingnan(dbl_value)==0xfff)
  109. #define Dbl_isnotzero(dbl_valueA,dbl_valueB) \
  110. (Dallp1(dbl_valueA) || Dallp2(dbl_valueB))
  111. #define Dbl_isnotzero_hiddenhigh7mantissa(dbl_value) \
  112. (Dhiddenhigh7mantissa(dbl_value)!=0)
  113. #define Dbl_isnotzero_exponent(dbl_value) (Dexponent(dbl_value)!=0)
  114. #define Dbl_isnotzero_mantissa(dbl_valueA,dbl_valueB) \
  115. (Dmantissap1(dbl_valueA) || Dmantissap2(dbl_valueB))
  116. #define Dbl_isnotzero_mantissap1(dbl_valueA) (Dmantissap1(dbl_valueA)!=0)
  117. #define Dbl_isnotzero_mantissap2(dbl_valueB) (Dmantissap2(dbl_valueB)!=0)
  118. #define Dbl_isnotzero_exponentmantissa(dbl_valueA,dbl_valueB) \
  119. (Dexponentmantissap1(dbl_valueA) || Dmantissap2(dbl_valueB))
  120. #define Dbl_isnotzero_low4p2(dbl_value) (Dlow4p2(dbl_value)!=0)
  121. #define Dbl_iszero(dbl_valueA,dbl_valueB) (Dallp1(dbl_valueA)==0 && \
  122. Dallp2(dbl_valueB)==0)
  123. #define Dbl_iszero_allp1(dbl_value) (Dallp1(dbl_value)==0)
  124. #define Dbl_iszero_allp2(dbl_value) (Dallp2(dbl_value)==0)
  125. #define Dbl_iszero_hidden(dbl_value) (Is_dhidden(dbl_value)==0)
  126. #define Dbl_iszero_hiddenoverflow(dbl_value) (Is_dhiddenoverflow(dbl_value)==0)
  127. #define Dbl_iszero_hiddenhigh3mantissa(dbl_value) \
  128. (Dhiddenhigh3mantissa(dbl_value)==0)
  129. #define Dbl_iszero_hiddenhigh7mantissa(dbl_value) \
  130. (Dhiddenhigh7mantissa(dbl_value)==0)
  131. #define Dbl_iszero_sign(dbl_value) (Is_dsign(dbl_value)==0)
  132. #define Dbl_iszero_exponent(dbl_value) (Dexponent(dbl_value)==0)
  133. #define Dbl_iszero_mantissa(dbl_valueA,dbl_valueB) \
  134. (Dmantissap1(dbl_valueA)==0 && Dmantissap2(dbl_valueB)==0)
  135. #define Dbl_iszero_exponentmantissa(dbl_valueA,dbl_valueB) \
  136. (Dexponentmantissap1(dbl_valueA)==0 && Dmantissap2(dbl_valueB)==0)
  137. #define Dbl_isinfinity_exponent(dbl_value) \
  138. (Dexponent(dbl_value)==DBL_INFINITY_EXPONENT)
  139. #define Dbl_isnotinfinity_exponent(dbl_value) \
  140. (Dexponent(dbl_value)!=DBL_INFINITY_EXPONENT)
  141. #define Dbl_isinfinity(dbl_valueA,dbl_valueB) \
  142. (Dexponent(dbl_valueA)==DBL_INFINITY_EXPONENT && \
  143. Dmantissap1(dbl_valueA)==0 && Dmantissap2(dbl_valueB)==0)
  144. #define Dbl_isnan(dbl_valueA,dbl_valueB) \
  145. (Dexponent(dbl_valueA)==DBL_INFINITY_EXPONENT && \
  146. (Dmantissap1(dbl_valueA)!=0 || Dmantissap2(dbl_valueB)!=0))
  147. #define Dbl_isnotnan(dbl_valueA,dbl_valueB) \
  148. (Dexponent(dbl_valueA)!=DBL_INFINITY_EXPONENT || \
  149. (Dmantissap1(dbl_valueA)==0 && Dmantissap2(dbl_valueB)==0))
  150. #define Dbl_islessthan(dbl_op1a,dbl_op1b,dbl_op2a,dbl_op2b) \
  151. (Dallp1(dbl_op1a) < Dallp1(dbl_op2a) || \
  152. (Dallp1(dbl_op1a) == Dallp1(dbl_op2a) && \
  153. Dallp2(dbl_op1b) < Dallp2(dbl_op2b)))
  154. #define Dbl_isgreaterthan(dbl_op1a,dbl_op1b,dbl_op2a,dbl_op2b) \
  155. (Dallp1(dbl_op1a) > Dallp1(dbl_op2a) || \
  156. (Dallp1(dbl_op1a) == Dallp1(dbl_op2a) && \
  157. Dallp2(dbl_op1b) > Dallp2(dbl_op2b)))
  158. #define Dbl_isnotlessthan(dbl_op1a,dbl_op1b,dbl_op2a,dbl_op2b) \
  159. (Dallp1(dbl_op1a) > Dallp1(dbl_op2a) || \
  160. (Dallp1(dbl_op1a) == Dallp1(dbl_op2a) && \
  161. Dallp2(dbl_op1b) >= Dallp2(dbl_op2b)))
  162. #define Dbl_isnotgreaterthan(dbl_op1a,dbl_op1b,dbl_op2a,dbl_op2b) \
  163. (Dallp1(dbl_op1a) < Dallp1(dbl_op2a) || \
  164. (Dallp1(dbl_op1a) == Dallp1(dbl_op2a) && \
  165. Dallp2(dbl_op1b) <= Dallp2(dbl_op2b)))
  166. #define Dbl_isequal(dbl_op1a,dbl_op1b,dbl_op2a,dbl_op2b) \
  167. ((Dallp1(dbl_op1a) == Dallp1(dbl_op2a)) && \
  168. (Dallp2(dbl_op1b) == Dallp2(dbl_op2b)))
  169. #define Dbl_leftshiftby8(dbl_valueA,dbl_valueB) \
  170. Shiftdouble(Dallp1(dbl_valueA),Dallp2(dbl_valueB),24,Dallp1(dbl_valueA)); \
  171. Dallp2(dbl_valueB) <<= 8
  172. #define Dbl_leftshiftby7(dbl_valueA,dbl_valueB) \
  173. Shiftdouble(Dallp1(dbl_valueA),Dallp2(dbl_valueB),25,Dallp1(dbl_valueA)); \
  174. Dallp2(dbl_valueB) <<= 7
  175. #define Dbl_leftshiftby4(dbl_valueA,dbl_valueB) \
  176. Shiftdouble(Dallp1(dbl_valueA),Dallp2(dbl_valueB),28,Dallp1(dbl_valueA)); \
  177. Dallp2(dbl_valueB) <<= 4
  178. #define Dbl_leftshiftby3(dbl_valueA,dbl_valueB) \
  179. Shiftdouble(Dallp1(dbl_valueA),Dallp2(dbl_valueB),29,Dallp1(dbl_valueA)); \
  180. Dallp2(dbl_valueB) <<= 3
  181. #define Dbl_leftshiftby2(dbl_valueA,dbl_valueB) \
  182. Shiftdouble(Dallp1(dbl_valueA),Dallp2(dbl_valueB),30,Dallp1(dbl_valueA)); \
  183. Dallp2(dbl_valueB) <<= 2
  184. #define Dbl_leftshiftby1(dbl_valueA,dbl_valueB) \
  185. Shiftdouble(Dallp1(dbl_valueA),Dallp2(dbl_valueB),31,Dallp1(dbl_valueA)); \
  186. Dallp2(dbl_valueB) <<= 1
  187. #define Dbl_rightshiftby8(dbl_valueA,dbl_valueB) \
  188. Shiftdouble(Dallp1(dbl_valueA),Dallp2(dbl_valueB),8,Dallp2(dbl_valueB)); \
  189. Dallp1(dbl_valueA) >>= 8
  190. #define Dbl_rightshiftby4(dbl_valueA,dbl_valueB) \
  191. Shiftdouble(Dallp1(dbl_valueA),Dallp2(dbl_valueB),4,Dallp2(dbl_valueB)); \
  192. Dallp1(dbl_valueA) >>= 4
  193. #define Dbl_rightshiftby2(dbl_valueA,dbl_valueB) \
  194. Shiftdouble(Dallp1(dbl_valueA),Dallp2(dbl_valueB),2,Dallp2(dbl_valueB)); \
  195. Dallp1(dbl_valueA) >>= 2
  196. #define Dbl_rightshiftby1(dbl_valueA,dbl_valueB) \
  197. Shiftdouble(Dallp1(dbl_valueA),Dallp2(dbl_valueB),1,Dallp2(dbl_valueB)); \
  198. Dallp1(dbl_valueA) >>= 1
  199. /* This magnitude comparison uses the signless first words and
  200. * the regular part2 words. The comparison is graphically:
  201. *
  202. * 1st greater? -------------
  203. * |
  204. * 1st less?-----------------+---------
  205. * | |
  206. * 2nd greater or equal----->| |
  207. * False True
  208. */
  209. #define Dbl_ismagnitudeless(leftB,rightB,signlessleft,signlessright) \
  210. ((signlessleft <= signlessright) && \
  211. ( (signlessleft < signlessright) || (Dallp2(leftB)<Dallp2(rightB)) ))
  212. #define Dbl_copytoint_exponentmantissap1(src,dest) \
  213. dest = Dexponentmantissap1(src)
  214. /* A quiet NaN has the high mantissa bit clear and at least on other (in this
  215. * case the adjacent bit) bit set. */
  216. #define Dbl_set_quiet(dbl_value) Deposit_dhigh2mantissa(dbl_value,1)
  217. #define Dbl_set_exponent(dbl_value, exp) Deposit_dexponent(dbl_value,exp)
  218. #define Dbl_set_mantissa(desta,destb,valuea,valueb) \
  219. Deposit_dmantissap1(desta,valuea); \
  220. Dmantissap2(destb) = Dmantissap2(valueb)
  221. #define Dbl_set_mantissap1(desta,valuea) \
  222. Deposit_dmantissap1(desta,valuea)
  223. #define Dbl_set_mantissap2(destb,valueb) \
  224. Dmantissap2(destb) = Dmantissap2(valueb)
  225. #define Dbl_set_exponentmantissa(desta,destb,valuea,valueb) \
  226. Deposit_dexponentmantissap1(desta,valuea); \
  227. Dmantissap2(destb) = Dmantissap2(valueb)
  228. #define Dbl_set_exponentmantissap1(dest,value) \
  229. Deposit_dexponentmantissap1(dest,value)
  230. #define Dbl_copyfromptr(src,desta,destb) \
  231. Dallp1(desta) = src->wd0; \
  232. Dallp2(destb) = src->wd1
  233. #define Dbl_copytoptr(srca,srcb,dest) \
  234. dest->wd0 = Dallp1(srca); \
  235. dest->wd1 = Dallp2(srcb)
  236. /* An infinity is represented with the max exponent and a zero mantissa */
  237. #define Dbl_setinfinity_exponent(dbl_value) \
  238. Deposit_dexponent(dbl_value,DBL_INFINITY_EXPONENT)
  239. #define Dbl_setinfinity_exponentmantissa(dbl_valueA,dbl_valueB) \
  240. Deposit_dexponentmantissap1(dbl_valueA, \
  241. (DBL_INFINITY_EXPONENT << (32-(1+DBL_EXP_LENGTH)))); \
  242. Dmantissap2(dbl_valueB) = 0
  243. #define Dbl_setinfinitypositive(dbl_valueA,dbl_valueB) \
  244. Dallp1(dbl_valueA) \
  245. = (DBL_INFINITY_EXPONENT << (32-(1+DBL_EXP_LENGTH))); \
  246. Dmantissap2(dbl_valueB) = 0
  247. #define Dbl_setinfinitynegative(dbl_valueA,dbl_valueB) \
  248. Dallp1(dbl_valueA) = ((unsigned int)1<<31) | \
  249. (DBL_INFINITY_EXPONENT << (32-(1+DBL_EXP_LENGTH))); \
  250. Dmantissap2(dbl_valueB) = 0
  251. #define Dbl_setinfinity(dbl_valueA,dbl_valueB,sign) \
  252. Dallp1(dbl_valueA) = ((unsigned int)sign << 31) | \
  253. (DBL_INFINITY_EXPONENT << (32-(1+DBL_EXP_LENGTH))); \
  254. Dmantissap2(dbl_valueB) = 0
  255. #define Dbl_sethigh4bits(dbl_value, extsign) Deposit_dhigh4p1(dbl_value,extsign)
  256. #define Dbl_set_sign(dbl_value,sign) Deposit_dsign(dbl_value,sign)
  257. #define Dbl_invert_sign(dbl_value) Deposit_dsign(dbl_value,~Dsign(dbl_value))
  258. #define Dbl_setone_sign(dbl_value) Deposit_dsign(dbl_value,1)
  259. #define Dbl_setone_lowmantissap2(dbl_value) Deposit_dlowp2(dbl_value,1)
  260. #define Dbl_setzero_sign(dbl_value) Dallp1(dbl_value) &= 0x7fffffff
  261. #define Dbl_setzero_exponent(dbl_value) \
  262. Dallp1(dbl_value) &= 0x800fffff
  263. #define Dbl_setzero_mantissa(dbl_valueA,dbl_valueB) \
  264. Dallp1(dbl_valueA) &= 0xfff00000; \
  265. Dallp2(dbl_valueB) = 0
  266. #define Dbl_setzero_mantissap1(dbl_value) Dallp1(dbl_value) &= 0xfff00000
  267. #define Dbl_setzero_mantissap2(dbl_value) Dallp2(dbl_value) = 0
  268. #define Dbl_setzero_exponentmantissa(dbl_valueA,dbl_valueB) \
  269. Dallp1(dbl_valueA) &= 0x80000000; \
  270. Dallp2(dbl_valueB) = 0
  271. #define Dbl_setzero_exponentmantissap1(dbl_valueA) \
  272. Dallp1(dbl_valueA) &= 0x80000000
  273. #define Dbl_setzero(dbl_valueA,dbl_valueB) \
  274. Dallp1(dbl_valueA) = 0; Dallp2(dbl_valueB) = 0
  275. #define Dbl_setzerop1(dbl_value) Dallp1(dbl_value) = 0
  276. #define Dbl_setzerop2(dbl_value) Dallp2(dbl_value) = 0
  277. #define Dbl_setnegativezero(dbl_value) \
  278. Dallp1(dbl_value) = (unsigned int)1 << 31; Dallp2(dbl_value) = 0
  279. #define Dbl_setnegativezerop1(dbl_value) Dallp1(dbl_value) = (unsigned int)1<<31
  280. /* Use the following macro for both overflow & underflow conditions */
  281. #define ovfl -
  282. #define unfl +
  283. #define Dbl_setwrapped_exponent(dbl_value,exponent,op) \
  284. Deposit_dexponent(dbl_value,(exponent op DBL_WRAP))
  285. #define Dbl_setlargestpositive(dbl_valueA,dbl_valueB) \
  286. Dallp1(dbl_valueA) = ((DBL_EMAX+DBL_BIAS) << (32-(1+DBL_EXP_LENGTH))) \
  287. | ((1<<(32-(1+DBL_EXP_LENGTH))) - 1 ); \
  288. Dallp2(dbl_valueB) = 0xFFFFFFFF
  289. #define Dbl_setlargestnegative(dbl_valueA,dbl_valueB) \
  290. Dallp1(dbl_valueA) = ((DBL_EMAX+DBL_BIAS) << (32-(1+DBL_EXP_LENGTH))) \
  291. | ((1<<(32-(1+DBL_EXP_LENGTH))) - 1 ) \
  292. | ((unsigned int)1<<31); \
  293. Dallp2(dbl_valueB) = 0xFFFFFFFF
  294. #define Dbl_setlargest_exponentmantissa(dbl_valueA,dbl_valueB) \
  295. Deposit_dexponentmantissap1(dbl_valueA, \
  296. (((DBL_EMAX+DBL_BIAS) << (32-(1+DBL_EXP_LENGTH))) \
  297. | ((1<<(32-(1+DBL_EXP_LENGTH))) - 1 ))); \
  298. Dallp2(dbl_valueB) = 0xFFFFFFFF
  299. #define Dbl_setnegativeinfinity(dbl_valueA,dbl_valueB) \
  300. Dallp1(dbl_valueA) = ((1<<DBL_EXP_LENGTH) | DBL_INFINITY_EXPONENT) \
  301. << (32-(1+DBL_EXP_LENGTH)) ; \
  302. Dallp2(dbl_valueB) = 0
  303. #define Dbl_setlargest(dbl_valueA,dbl_valueB,sign) \
  304. Dallp1(dbl_valueA) = ((unsigned int)sign << 31) | \
  305. ((DBL_EMAX+DBL_BIAS) << (32-(1+DBL_EXP_LENGTH))) | \
  306. ((1 << (32-(1+DBL_EXP_LENGTH))) - 1 ); \
  307. Dallp2(dbl_valueB) = 0xFFFFFFFF
  308. /* The high bit is always zero so arithmetic or logical shifts will work. */
  309. #define Dbl_right_align(srcdstA,srcdstB,shift,extent) \
  310. if( shift >= 32 ) \
  311. { \
  312. /* Big shift requires examining the portion shift off \
  313. the end to properly set inexact. */ \
  314. if(shift < 64) \
  315. { \
  316. if(shift > 32) \
  317. { \
  318. Variable_shift_double(Dallp1(srcdstA),Dallp2(srcdstB), \
  319. shift-32, Extall(extent)); \
  320. if(Dallp2(srcdstB) << 64 - (shift)) Ext_setone_low(extent); \
  321. } \
  322. else Extall(extent) = Dallp2(srcdstB); \
  323. Dallp2(srcdstB) = Dallp1(srcdstA) >> (shift - 32); \
  324. } \
  325. else \
  326. { \
  327. Extall(extent) = Dallp1(srcdstA); \
  328. if(Dallp2(srcdstB)) Ext_setone_low(extent); \
  329. Dallp2(srcdstB) = 0; \
  330. } \
  331. Dallp1(srcdstA) = 0; \
  332. } \
  333. else \
  334. { \
  335. /* Small alignment is simpler. Extension is easily set. */ \
  336. if (shift > 0) \
  337. { \
  338. Extall(extent) = Dallp2(srcdstB) << 32 - (shift); \
  339. Variable_shift_double(Dallp1(srcdstA),Dallp2(srcdstB),shift, \
  340. Dallp2(srcdstB)); \
  341. Dallp1(srcdstA) >>= shift; \
  342. } \
  343. else Extall(extent) = 0; \
  344. }
  345. /*
  346. * Here we need to shift the result right to correct for an overshift
  347. * (due to the exponent becoming negative) during normalization.
  348. */
  349. #define Dbl_fix_overshift(srcdstA,srcdstB,shift,extent) \
  350. Extall(extent) = Dallp2(srcdstB) << 32 - (shift); \
  351. Dallp2(srcdstB) = (Dallp1(srcdstA) << 32 - (shift)) | \
  352. (Dallp2(srcdstB) >> (shift)); \
  353. Dallp1(srcdstA) = Dallp1(srcdstA) >> shift
  354. #define Dbl_hiddenhigh3mantissa(dbl_value) Dhiddenhigh3mantissa(dbl_value)
  355. #define Dbl_hidden(dbl_value) Dhidden(dbl_value)
  356. #define Dbl_lowmantissap2(dbl_value) Dlowp2(dbl_value)
  357. /* The left argument is never smaller than the right argument */
  358. #define Dbl_subtract(lefta,leftb,righta,rightb,resulta,resultb) \
  359. if( Dallp2(rightb) > Dallp2(leftb) ) Dallp1(lefta)--; \
  360. Dallp2(resultb) = Dallp2(leftb) - Dallp2(rightb); \
  361. Dallp1(resulta) = Dallp1(lefta) - Dallp1(righta)
  362. /* Subtract right augmented with extension from left augmented with zeros and
  363. * store into result and extension. */
  364. #define Dbl_subtract_withextension(lefta,leftb,righta,rightb,extent,resulta,resultb) \
  365. Dbl_subtract(lefta,leftb,righta,rightb,resulta,resultb); \
  366. if( (Extall(extent) = 0-Extall(extent)) ) \
  367. { \
  368. if((Dallp2(resultb)--) == 0) Dallp1(resulta)--; \
  369. }
  370. #define Dbl_addition(lefta,leftb,righta,rightb,resulta,resultb) \
  371. /* If the sum of the low words is less than either source, then \
  372. * an overflow into the next word occurred. */ \
  373. Dallp1(resulta) = Dallp1(lefta) + Dallp1(righta); \
  374. if((Dallp2(resultb) = Dallp2(leftb) + Dallp2(rightb)) < Dallp2(rightb)) \
  375. Dallp1(resulta)++
  376. #define Dbl_xortointp1(left,right,result) \
  377. result = Dallp1(left) XOR Dallp1(right)
  378. #define Dbl_xorfromintp1(left,right,result) \
  379. Dallp1(result) = left XOR Dallp1(right)
  380. #define Dbl_swap_lower(left,right) \
  381. Dallp2(left) = Dallp2(left) XOR Dallp2(right); \
  382. Dallp2(right) = Dallp2(left) XOR Dallp2(right); \
  383. Dallp2(left) = Dallp2(left) XOR Dallp2(right)
  384. /* Need to Initialize */
  385. #define Dbl_makequietnan(desta,destb) \
  386. Dallp1(desta) = ((DBL_EMAX+DBL_BIAS)+1)<< (32-(1+DBL_EXP_LENGTH)) \
  387. | (1<<(32-(1+DBL_EXP_LENGTH+2))); \
  388. Dallp2(destb) = 0
  389. #define Dbl_makesignalingnan(desta,destb) \
  390. Dallp1(desta) = ((DBL_EMAX+DBL_BIAS)+1)<< (32-(1+DBL_EXP_LENGTH)) \
  391. | (1<<(32-(1+DBL_EXP_LENGTH+1))); \
  392. Dallp2(destb) = 0
  393. #define Dbl_normalize(dbl_opndA,dbl_opndB,exponent) \
  394. while(Dbl_iszero_hiddenhigh7mantissa(dbl_opndA)) { \
  395. Dbl_leftshiftby8(dbl_opndA,dbl_opndB); \
  396. exponent -= 8; \
  397. } \
  398. if(Dbl_iszero_hiddenhigh3mantissa(dbl_opndA)) { \
  399. Dbl_leftshiftby4(dbl_opndA,dbl_opndB); \
  400. exponent -= 4; \
  401. } \
  402. while(Dbl_iszero_hidden(dbl_opndA)) { \
  403. Dbl_leftshiftby1(dbl_opndA,dbl_opndB); \
  404. exponent -= 1; \
  405. }
  406. #define Twoword_add(src1dstA,src1dstB,src2A,src2B) \
  407. /* \
  408. * want this macro to generate: \
  409. * ADD src1dstB,src2B,src1dstB; \
  410. * ADDC src1dstA,src2A,src1dstA; \
  411. */ \
  412. if ((src1dstB) + (src2B) < (src1dstB)) Dallp1(src1dstA)++; \
  413. Dallp1(src1dstA) += (src2A); \
  414. Dallp2(src1dstB) += (src2B)
  415. #define Twoword_subtract(src1dstA,src1dstB,src2A,src2B) \
  416. /* \
  417. * want this macro to generate: \
  418. * SUB src1dstB,src2B,src1dstB; \
  419. * SUBB src1dstA,src2A,src1dstA; \
  420. */ \
  421. if ((src1dstB) < (src2B)) Dallp1(src1dstA)--; \
  422. Dallp1(src1dstA) -= (src2A); \
  423. Dallp2(src1dstB) -= (src2B)
  424. #define Dbl_setoverflow(resultA,resultB) \
  425. /* set result to infinity or largest number */ \
  426. switch (Rounding_mode()) { \
  427. case ROUNDPLUS: \
  428. if (Dbl_isone_sign(resultA)) { \
  429. Dbl_setlargestnegative(resultA,resultB); \
  430. } \
  431. else { \
  432. Dbl_setinfinitypositive(resultA,resultB); \
  433. } \
  434. break; \
  435. case ROUNDMINUS: \
  436. if (Dbl_iszero_sign(resultA)) { \
  437. Dbl_setlargestpositive(resultA,resultB); \
  438. } \
  439. else { \
  440. Dbl_setinfinitynegative(resultA,resultB); \
  441. } \
  442. break; \
  443. case ROUNDNEAREST: \
  444. Dbl_setinfinity_exponentmantissa(resultA,resultB); \
  445. break; \
  446. case ROUNDZERO: \
  447. Dbl_setlargest_exponentmantissa(resultA,resultB); \
  448. }
  449. #define Dbl_denormalize(opndp1,opndp2,exponent,guard,sticky,inexact) \
  450. Dbl_clear_signexponent_set_hidden(opndp1); \
  451. if (exponent >= (1-DBL_P)) { \
  452. if (exponent >= -31) { \
  453. guard = (Dallp2(opndp2) >> -exponent) & 1; \
  454. if (exponent < 0) sticky |= Dallp2(opndp2) << (32+exponent); \
  455. if (exponent > -31) { \
  456. Variable_shift_double(opndp1,opndp2,1-exponent,opndp2); \
  457. Dallp1(opndp1) >>= 1-exponent; \
  458. } \
  459. else { \
  460. Dallp2(opndp2) = Dallp1(opndp1); \
  461. Dbl_setzerop1(opndp1); \
  462. } \
  463. } \
  464. else { \
  465. guard = (Dallp1(opndp1) >> -32-exponent) & 1; \
  466. if (exponent == -32) sticky |= Dallp2(opndp2); \
  467. else sticky |= (Dallp2(opndp2) | Dallp1(opndp1) << 64+exponent); \
  468. Dallp2(opndp2) = Dallp1(opndp1) >> -31-exponent; \
  469. Dbl_setzerop1(opndp1); \
  470. } \
  471. inexact = guard | sticky; \
  472. } \
  473. else { \
  474. guard = 0; \
  475. sticky |= (Dallp1(opndp1) | Dallp2(opndp2)); \
  476. Dbl_setzero(opndp1,opndp2); \
  477. inexact = sticky; \
  478. }
  479. /*
  480. * The fused multiply add instructions requires a double extended format,
  481. * with 106 bits of mantissa.
  482. */
  483. #define DBLEXT_THRESHOLD 106
  484. #define Dblext_setzero(valA,valB,valC,valD) \
  485. Dextallp1(valA) = 0; Dextallp2(valB) = 0; \
  486. Dextallp3(valC) = 0; Dextallp4(valD) = 0
  487. #define Dblext_isnotzero_mantissap3(valC) (Dextallp3(valC)!=0)
  488. #define Dblext_isnotzero_mantissap4(valD) (Dextallp3(valD)!=0)
  489. #define Dblext_isone_lowp2(val) (Dextlowp2(val)!=0)
  490. #define Dblext_isone_highp3(val) (Dexthighp3(val)!=0)
  491. #define Dblext_isnotzero_low31p3(val) (Dextlow31p3(val)!=0)
  492. #define Dblext_iszero(valA,valB,valC,valD) (Dextallp1(valA)==0 && \
  493. Dextallp2(valB)==0 && Dextallp3(valC)==0 && Dextallp4(valD)==0)
  494. #define Dblext_copy(srca,srcb,srcc,srcd,desta,destb,destc,destd) \
  495. Dextallp1(desta) = Dextallp4(srca); \
  496. Dextallp2(destb) = Dextallp4(srcb); \
  497. Dextallp3(destc) = Dextallp4(srcc); \
  498. Dextallp4(destd) = Dextallp4(srcd)
  499. #define Dblext_swap_lower(leftp2,leftp3,leftp4,rightp2,rightp3,rightp4) \
  500. Dextallp2(leftp2) = Dextallp2(leftp2) XOR Dextallp2(rightp2); \
  501. Dextallp2(rightp2) = Dextallp2(leftp2) XOR Dextallp2(rightp2); \
  502. Dextallp2(leftp2) = Dextallp2(leftp2) XOR Dextallp2(rightp2); \
  503. Dextallp3(leftp3) = Dextallp3(leftp3) XOR Dextallp3(rightp3); \
  504. Dextallp3(rightp3) = Dextallp3(leftp3) XOR Dextallp3(rightp3); \
  505. Dextallp3(leftp3) = Dextallp3(leftp3) XOR Dextallp3(rightp3); \
  506. Dextallp4(leftp4) = Dextallp4(leftp4) XOR Dextallp4(rightp4); \
  507. Dextallp4(rightp4) = Dextallp4(leftp4) XOR Dextallp4(rightp4); \
  508. Dextallp4(leftp4) = Dextallp4(leftp4) XOR Dextallp4(rightp4)
  509. #define Dblext_setone_lowmantissap4(dbl_value) Deposit_dextlowp4(dbl_value,1)
  510. /* The high bit is always zero so arithmetic or logical shifts will work. */
  511. #define Dblext_right_align(srcdstA,srcdstB,srcdstC,srcdstD,shift) \
  512. {int shiftamt, sticky; \
  513. shiftamt = shift % 32; \
  514. sticky = 0; \
  515. switch (shift/32) { \
  516. case 0: if (shiftamt > 0) { \
  517. sticky = Dextallp4(srcdstD) << 32 - (shiftamt); \
  518. Variable_shift_double(Dextallp3(srcdstC), \
  519. Dextallp4(srcdstD),shiftamt,Dextallp4(srcdstD)); \
  520. Variable_shift_double(Dextallp2(srcdstB), \
  521. Dextallp3(srcdstC),shiftamt,Dextallp3(srcdstC)); \
  522. Variable_shift_double(Dextallp1(srcdstA), \
  523. Dextallp2(srcdstB),shiftamt,Dextallp2(srcdstB)); \
  524. Dextallp1(srcdstA) >>= shiftamt; \
  525. } \
  526. break; \
  527. case 1: if (shiftamt > 0) { \
  528. sticky = (Dextallp3(srcdstC) << 31 - shiftamt) | \
  529. Dextallp4(srcdstD); \
  530. Variable_shift_double(Dextallp2(srcdstB), \
  531. Dextallp3(srcdstC),shiftamt,Dextallp4(srcdstD)); \
  532. Variable_shift_double(Dextallp1(srcdstA), \
  533. Dextallp2(srcdstB),shiftamt,Dextallp3(srcdstC)); \
  534. } \
  535. else { \
  536. sticky = Dextallp4(srcdstD); \
  537. Dextallp4(srcdstD) = Dextallp3(srcdstC); \
  538. Dextallp3(srcdstC) = Dextallp2(srcdstB); \
  539. } \
  540. Dextallp2(srcdstB) = Dextallp1(srcdstA) >> shiftamt; \
  541. Dextallp1(srcdstA) = 0; \
  542. break; \
  543. case 2: if (shiftamt > 0) { \
  544. sticky = (Dextallp2(srcdstB) << 31 - shiftamt) | \
  545. Dextallp3(srcdstC) | Dextallp4(srcdstD); \
  546. Variable_shift_double(Dextallp1(srcdstA), \
  547. Dextallp2(srcdstB),shiftamt,Dextallp4(srcdstD)); \
  548. } \
  549. else { \
  550. sticky = Dextallp3(srcdstC) | Dextallp4(srcdstD); \
  551. Dextallp4(srcdstD) = Dextallp2(srcdstB); \
  552. } \
  553. Dextallp3(srcdstC) = Dextallp1(srcdstA) >> shiftamt; \
  554. Dextallp1(srcdstA) = Dextallp2(srcdstB) = 0; \
  555. break; \
  556. case 3: if (shiftamt > 0) { \
  557. sticky = (Dextallp1(srcdstA) << 31 - shiftamt) | \
  558. Dextallp2(srcdstB) | Dextallp3(srcdstC) | \
  559. Dextallp4(srcdstD); \
  560. } \
  561. else { \
  562. sticky = Dextallp2(srcdstB) | Dextallp3(srcdstC) | \
  563. Dextallp4(srcdstD); \
  564. } \
  565. Dextallp4(srcdstD) = Dextallp1(srcdstA) >> shiftamt; \
  566. Dextallp1(srcdstA) = Dextallp2(srcdstB) = 0; \
  567. Dextallp3(srcdstC) = 0; \
  568. break; \
  569. } \
  570. if (sticky) Dblext_setone_lowmantissap4(srcdstD); \
  571. }
  572. /* The left argument is never smaller than the right argument */
  573. #define Dblext_subtract(lefta,leftb,leftc,leftd,righta,rightb,rightc,rightd,resulta,resultb,resultc,resultd) \
  574. if( Dextallp4(rightd) > Dextallp4(leftd) ) \
  575. if( (Dextallp3(leftc)--) == 0) \
  576. if( (Dextallp2(leftb)--) == 0) Dextallp1(lefta)--; \
  577. Dextallp4(resultd) = Dextallp4(leftd) - Dextallp4(rightd); \
  578. if( Dextallp3(rightc) > Dextallp3(leftc) ) \
  579. if( (Dextallp2(leftb)--) == 0) Dextallp1(lefta)--; \
  580. Dextallp3(resultc) = Dextallp3(leftc) - Dextallp3(rightc); \
  581. if( Dextallp2(rightb) > Dextallp2(leftb) ) Dextallp1(lefta)--; \
  582. Dextallp2(resultb) = Dextallp2(leftb) - Dextallp2(rightb); \
  583. Dextallp1(resulta) = Dextallp1(lefta) - Dextallp1(righta)
  584. #define Dblext_addition(lefta,leftb,leftc,leftd,righta,rightb,rightc,rightd,resulta,resultb,resultc,resultd) \
  585. /* If the sum of the low words is less than either source, then \
  586. * an overflow into the next word occurred. */ \
  587. if ((Dextallp4(resultd) = Dextallp4(leftd)+Dextallp4(rightd)) < \
  588. Dextallp4(rightd)) \
  589. if((Dextallp3(resultc) = Dextallp3(leftc)+Dextallp3(rightc)+1) <= \
  590. Dextallp3(rightc)) \
  591. if((Dextallp2(resultb) = Dextallp2(leftb)+Dextallp2(rightb)+1) \
  592. <= Dextallp2(rightb)) \
  593. Dextallp1(resulta) = Dextallp1(lefta)+Dextallp1(righta)+1; \
  594. else Dextallp1(resulta) = Dextallp1(lefta)+Dextallp1(righta); \
  595. else \
  596. if ((Dextallp2(resultb) = Dextallp2(leftb)+Dextallp2(rightb)) < \
  597. Dextallp2(rightb)) \
  598. Dextallp1(resulta) = Dextallp1(lefta)+Dextallp1(righta)+1; \
  599. else Dextallp1(resulta) = Dextallp1(lefta)+Dextallp1(righta); \
  600. else \
  601. if ((Dextallp3(resultc) = Dextallp3(leftc)+Dextallp3(rightc)) < \
  602. Dextallp3(rightc)) \
  603. if ((Dextallp2(resultb) = Dextallp2(leftb)+Dextallp2(rightb)+1) \
  604. <= Dextallp2(rightb)) \
  605. Dextallp1(resulta) = Dextallp1(lefta)+Dextallp1(righta)+1; \
  606. else Dextallp1(resulta) = Dextallp1(lefta)+Dextallp1(righta); \
  607. else \
  608. if ((Dextallp2(resultb) = Dextallp2(leftb)+Dextallp2(rightb)) < \
  609. Dextallp2(rightb)) \
  610. Dextallp1(resulta) = Dextallp1(lefta)+Dextallp1(righta)+1; \
  611. else Dextallp1(resulta) = Dextallp1(lefta)+Dextallp1(righta)
  612. #define Dblext_arithrightshiftby1(srcdstA,srcdstB,srcdstC,srcdstD) \
  613. Shiftdouble(Dextallp3(srcdstC),Dextallp4(srcdstD),1,Dextallp4(srcdstD)); \
  614. Shiftdouble(Dextallp2(srcdstB),Dextallp3(srcdstC),1,Dextallp3(srcdstC)); \
  615. Shiftdouble(Dextallp1(srcdstA),Dextallp2(srcdstB),1,Dextallp2(srcdstB)); \
  616. Dextallp1(srcdstA) = (int)Dextallp1(srcdstA) >> 1
  617. #define Dblext_leftshiftby8(valA,valB,valC,valD) \
  618. Shiftdouble(Dextallp1(valA),Dextallp2(valB),24,Dextallp1(valA)); \
  619. Shiftdouble(Dextallp2(valB),Dextallp3(valC),24,Dextallp2(valB)); \
  620. Shiftdouble(Dextallp3(valC),Dextallp4(valD),24,Dextallp3(valC)); \
  621. Dextallp4(valD) <<= 8
  622. #define Dblext_leftshiftby4(valA,valB,valC,valD) \
  623. Shiftdouble(Dextallp1(valA),Dextallp2(valB),28,Dextallp1(valA)); \
  624. Shiftdouble(Dextallp2(valB),Dextallp3(valC),28,Dextallp2(valB)); \
  625. Shiftdouble(Dextallp3(valC),Dextallp4(valD),28,Dextallp3(valC)); \
  626. Dextallp4(valD) <<= 4
  627. #define Dblext_leftshiftby3(valA,valB,valC,valD) \
  628. Shiftdouble(Dextallp1(valA),Dextallp2(valB),29,Dextallp1(valA)); \
  629. Shiftdouble(Dextallp2(valB),Dextallp3(valC),29,Dextallp2(valB)); \
  630. Shiftdouble(Dextallp3(valC),Dextallp4(valD),29,Dextallp3(valC)); \
  631. Dextallp4(valD) <<= 3
  632. #define Dblext_leftshiftby2(valA,valB,valC,valD) \
  633. Shiftdouble(Dextallp1(valA),Dextallp2(valB),30,Dextallp1(valA)); \
  634. Shiftdouble(Dextallp2(valB),Dextallp3(valC),30,Dextallp2(valB)); \
  635. Shiftdouble(Dextallp3(valC),Dextallp4(valD),30,Dextallp3(valC)); \
  636. Dextallp4(valD) <<= 2
  637. #define Dblext_leftshiftby1(valA,valB,valC,valD) \
  638. Shiftdouble(Dextallp1(valA),Dextallp2(valB),31,Dextallp1(valA)); \
  639. Shiftdouble(Dextallp2(valB),Dextallp3(valC),31,Dextallp2(valB)); \
  640. Shiftdouble(Dextallp3(valC),Dextallp4(valD),31,Dextallp3(valC)); \
  641. Dextallp4(valD) <<= 1
  642. #define Dblext_rightshiftby4(valueA,valueB,valueC,valueD) \
  643. Shiftdouble(Dextallp3(valueC),Dextallp4(valueD),4,Dextallp4(valueD)); \
  644. Shiftdouble(Dextallp2(valueB),Dextallp3(valueC),4,Dextallp3(valueC)); \
  645. Shiftdouble(Dextallp1(valueA),Dextallp2(valueB),4,Dextallp2(valueB)); \
  646. Dextallp1(valueA) >>= 4
  647. #define Dblext_rightshiftby1(valueA,valueB,valueC,valueD) \
  648. Shiftdouble(Dextallp3(valueC),Dextallp4(valueD),1,Dextallp4(valueD)); \
  649. Shiftdouble(Dextallp2(valueB),Dextallp3(valueC),1,Dextallp3(valueC)); \
  650. Shiftdouble(Dextallp1(valueA),Dextallp2(valueB),1,Dextallp2(valueB)); \
  651. Dextallp1(valueA) >>= 1
  652. #define Dblext_xortointp1(left,right,result) Dbl_xortointp1(left,right,result)
  653. #define Dblext_xorfromintp1(left,right,result) \
  654. Dbl_xorfromintp1(left,right,result)
  655. #define Dblext_copytoint_exponentmantissap1(src,dest) \
  656. Dbl_copytoint_exponentmantissap1(src,dest)
  657. #define Dblext_ismagnitudeless(leftB,rightB,signlessleft,signlessright) \
  658. Dbl_ismagnitudeless(leftB,rightB,signlessleft,signlessright)
  659. #define Dbl_copyto_dblext(src1,src2,dest1,dest2,dest3,dest4) \
  660. Dextallp1(dest1) = Dallp1(src1); Dextallp2(dest2) = Dallp2(src2); \
  661. Dextallp3(dest3) = 0; Dextallp4(dest4) = 0
  662. #define Dblext_set_sign(dbl_value,sign) Dbl_set_sign(dbl_value,sign)
  663. #define Dblext_clear_signexponent_set_hidden(srcdst) \
  664. Dbl_clear_signexponent_set_hidden(srcdst)
  665. #define Dblext_clear_signexponent(srcdst) Dbl_clear_signexponent(srcdst)
  666. #define Dblext_clear_sign(srcdst) Dbl_clear_sign(srcdst)
  667. #define Dblext_isone_hidden(dbl_value) Dbl_isone_hidden(dbl_value)
  668. /*
  669. * The Fourword_add() macro assumes that integers are 4 bytes in size.
  670. * It will break if this is not the case.
  671. */
  672. #define Fourword_add(src1dstA,src1dstB,src1dstC,src1dstD,src2A,src2B,src2C,src2D) \
  673. /* \
  674. * want this macro to generate: \
  675. * ADD src1dstD,src2D,src1dstD; \
  676. * ADDC src1dstC,src2C,src1dstC; \
  677. * ADDC src1dstB,src2B,src1dstB; \
  678. * ADDC src1dstA,src2A,src1dstA; \
  679. */ \
  680. if ((unsigned int)(src1dstD += (src2D)) < (unsigned int)(src2D)) { \
  681. if ((unsigned int)(src1dstC += (src2C) + 1) <= \
  682. (unsigned int)(src2C)) { \
  683. if ((unsigned int)(src1dstB += (src2B) + 1) <= \
  684. (unsigned int)(src2B)) src1dstA++; \
  685. } \
  686. else if ((unsigned int)(src1dstB += (src2B)) < \
  687. (unsigned int)(src2B)) src1dstA++; \
  688. } \
  689. else { \
  690. if ((unsigned int)(src1dstC += (src2C)) < \
  691. (unsigned int)(src2C)) { \
  692. if ((unsigned int)(src1dstB += (src2B) + 1) <= \
  693. (unsigned int)(src2B)) src1dstA++; \
  694. } \
  695. else if ((unsigned int)(src1dstB += (src2B)) < \
  696. (unsigned int)(src2B)) src1dstA++; \
  697. } \
  698. src1dstA += (src2A)
  699. #define Dblext_denormalize(opndp1,opndp2,opndp3,opndp4,exponent,is_tiny) \
  700. {int shiftamt, sticky; \
  701. is_tiny = TRUE; \
  702. if (exponent == 0 && (Dextallp3(opndp3) || Dextallp4(opndp4))) { \
  703. switch (Rounding_mode()) { \
  704. case ROUNDPLUS: \
  705. if (Dbl_iszero_sign(opndp1)) { \
  706. Dbl_increment(opndp1,opndp2); \
  707. if (Dbl_isone_hiddenoverflow(opndp1)) \
  708. is_tiny = FALSE; \
  709. Dbl_decrement(opndp1,opndp2); \
  710. } \
  711. break; \
  712. case ROUNDMINUS: \
  713. if (Dbl_isone_sign(opndp1)) { \
  714. Dbl_increment(opndp1,opndp2); \
  715. if (Dbl_isone_hiddenoverflow(opndp1)) \
  716. is_tiny = FALSE; \
  717. Dbl_decrement(opndp1,opndp2); \
  718. } \
  719. break; \
  720. case ROUNDNEAREST: \
  721. if (Dblext_isone_highp3(opndp3) && \
  722. (Dblext_isone_lowp2(opndp2) || \
  723. Dblext_isnotzero_low31p3(opndp3))) { \
  724. Dbl_increment(opndp1,opndp2); \
  725. if (Dbl_isone_hiddenoverflow(opndp1)) \
  726. is_tiny = FALSE; \
  727. Dbl_decrement(opndp1,opndp2); \
  728. } \
  729. break; \
  730. } \
  731. } \
  732. Dblext_clear_signexponent_set_hidden(opndp1); \
  733. if (exponent >= (1-QUAD_P)) { \
  734. shiftamt = (1-exponent) % 32; \
  735. switch((1-exponent)/32) { \
  736. case 0: sticky = Dextallp4(opndp4) << 32-(shiftamt); \
  737. Variableshiftdouble(opndp3,opndp4,shiftamt,opndp4); \
  738. Variableshiftdouble(opndp2,opndp3,shiftamt,opndp3); \
  739. Variableshiftdouble(opndp1,opndp2,shiftamt,opndp2); \
  740. Dextallp1(opndp1) >>= shiftamt; \
  741. break; \
  742. case 1: sticky = (Dextallp3(opndp3) << 32-(shiftamt)) | \
  743. Dextallp4(opndp4); \
  744. Variableshiftdouble(opndp2,opndp3,shiftamt,opndp4); \
  745. Variableshiftdouble(opndp1,opndp2,shiftamt,opndp3); \
  746. Dextallp2(opndp2) = Dextallp1(opndp1) >> shiftamt; \
  747. Dextallp1(opndp1) = 0; \
  748. break; \
  749. case 2: sticky = (Dextallp2(opndp2) << 32-(shiftamt)) | \
  750. Dextallp3(opndp3) | Dextallp4(opndp4); \
  751. Variableshiftdouble(opndp1,opndp2,shiftamt,opndp4); \
  752. Dextallp3(opndp3) = Dextallp1(opndp1) >> shiftamt; \
  753. Dextallp1(opndp1) = Dextallp2(opndp2) = 0; \
  754. break; \
  755. case 3: sticky = (Dextallp1(opndp1) << 32-(shiftamt)) | \
  756. Dextallp2(opndp2) | Dextallp3(opndp3) | \
  757. Dextallp4(opndp4); \
  758. Dextallp4(opndp4) = Dextallp1(opndp1) >> shiftamt; \
  759. Dextallp1(opndp1) = Dextallp2(opndp2) = 0; \
  760. Dextallp3(opndp3) = 0; \
  761. break; \
  762. } \
  763. } \
  764. else { \
  765. sticky = Dextallp1(opndp1) | Dextallp2(opndp2) | \
  766. Dextallp3(opndp3) | Dextallp4(opndp4); \
  767. Dblext_setzero(opndp1,opndp2,opndp3,opndp4); \
  768. } \
  769. if (sticky) Dblext_setone_lowmantissap4(opndp4); \
  770. exponent = 0; \
  771. }