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 /* 9 * BEGIN_DESC 10 * 11 * File: 12 * @(#) pa/spmath/sfrem.c $Revision: 1.1 $ 13 * 14 * Purpose: 15 * Single Precision Floating-point Remainder 16 * 17 * External Interfaces: 18 * sgl_frem(srcptr1,srcptr2,dstptr,status) 19 * 20 * Internal Interfaces: 21 * 22 * Theory: 23 * <<please update with a overview of the operation of this file>> 24 * 25 * END_DESC 26 */ 27 28 29 30 #include "float.h" 31 #include "sgl_float.h" 32 33 /* 34 * Single Precision Floating-point Remainder 35 */ 36 37 int 38 sgl_frem (sgl_floating_point * srcptr1, sgl_floating_point * srcptr2, 39 sgl_floating_point * dstptr, unsigned int *status) 40 { 41 register unsigned int opnd1, opnd2, result; 42 register int opnd1_exponent, opnd2_exponent, dest_exponent, stepcount; 43 register boolean roundup = FALSE; 44 45 opnd1 = *srcptr1; 46 opnd2 = *srcptr2; 47 /* 48 * check first operand for NaN's or infinity 49 */ 50 if ((opnd1_exponent = Sgl_exponent(opnd1)) == SGL_INFINITY_EXPONENT) { 51 if (Sgl_iszero_mantissa(opnd1)) { 52 if (Sgl_isnotnan(opnd2)) { 53 /* invalid since first operand is infinity */ 54 if (Is_invalidtrap_enabled()) 55 return(INVALIDEXCEPTION); 56 Set_invalidflag(); 57 Sgl_makequietnan(result); 58 *dstptr = result; 59 return(NOEXCEPTION); 60 } 61 } 62 else { 63 /* 64 * is NaN; signaling or quiet? 65 */ 66 if (Sgl_isone_signaling(opnd1)) { 67 /* trap if INVALIDTRAP enabled */ 68 if (Is_invalidtrap_enabled()) 69 return(INVALIDEXCEPTION); 70 /* make NaN quiet */ 71 Set_invalidflag(); 72 Sgl_set_quiet(opnd1); 73 } 74 /* 75 * is second operand a signaling NaN? 76 */ 77 else if (Sgl_is_signalingnan(opnd2)) { 78 /* trap if INVALIDTRAP enabled */ 79 if (Is_invalidtrap_enabled()) 80 return(INVALIDEXCEPTION); 81 /* make NaN quiet */ 82 Set_invalidflag(); 83 Sgl_set_quiet(opnd2); 84 *dstptr = opnd2; 85 return(NOEXCEPTION); 86 } 87 /* 88 * return quiet NaN 89 */ 90 *dstptr = opnd1; 91 return(NOEXCEPTION); 92 } 93 } 94 /* 95 * check second operand for NaN's or infinity 96 */ 97 if ((opnd2_exponent = Sgl_exponent(opnd2)) == SGL_INFINITY_EXPONENT) { 98 if (Sgl_iszero_mantissa(opnd2)) { 99 /* 100 * return first operand 101 */ 102 *dstptr = opnd1; 103 return(NOEXCEPTION); 104 } 105 /* 106 * is NaN; signaling or quiet? 107 */ 108 if (Sgl_isone_signaling(opnd2)) { 109 /* trap if INVALIDTRAP enabled */ 110 if (Is_invalidtrap_enabled()) return(INVALIDEXCEPTION); 111 /* make NaN quiet */ 112 Set_invalidflag(); 113 Sgl_set_quiet(opnd2); 114 } 115 /* 116 * return quiet NaN 117 */ 118 *dstptr = opnd2; 119 return(NOEXCEPTION); 120 } 121 /* 122 * check second operand for zero 123 */ 124 if (Sgl_iszero_exponentmantissa(opnd2)) { 125 /* invalid since second operand is zero */ 126 if (Is_invalidtrap_enabled()) return(INVALIDEXCEPTION); 127 Set_invalidflag(); 128 Sgl_makequietnan(result); 129 *dstptr = result; 130 return(NOEXCEPTION); 131 } 132 133 /* 134 * get sign of result 135 */ 136 result = opnd1; 137 138 /* 139 * check for denormalized operands 140 */ 141 if (opnd1_exponent == 0) { 142 /* check for zero */ 143 if (Sgl_iszero_mantissa(opnd1)) { 144 *dstptr = opnd1; 145 return(NOEXCEPTION); 146 } 147 /* normalize, then continue */ 148 opnd1_exponent = 1; 149 Sgl_normalize(opnd1,opnd1_exponent); 150 } 151 else { 152 Sgl_clear_signexponent_set_hidden(opnd1); 153 } 154 if (opnd2_exponent == 0) { 155 /* normalize, then continue */ 156 opnd2_exponent = 1; 157 Sgl_normalize(opnd2,opnd2_exponent); 158 } 159 else { 160 Sgl_clear_signexponent_set_hidden(opnd2); 161 } 162 163 /* find result exponent and divide step loop count */ 164 dest_exponent = opnd2_exponent - 1; 165 stepcount = opnd1_exponent - opnd2_exponent; 166 167 /* 168 * check for opnd1/opnd2 < 1 169 */ 170 if (stepcount < 0) { 171 /* 172 * check for opnd1/opnd2 > 1/2 173 * 174 * In this case n will round to 1, so 175 * r = opnd1 - opnd2 176 */ 177 if (stepcount == -1 && Sgl_isgreaterthan(opnd1,opnd2)) { 178 Sgl_all(result) = ~Sgl_all(result); /* set sign */ 179 /* align opnd2 with opnd1 */ 180 Sgl_leftshiftby1(opnd2); 181 Sgl_subtract(opnd2,opnd1,opnd2); 182 /* now normalize */ 183 while (Sgl_iszero_hidden(opnd2)) { 184 Sgl_leftshiftby1(opnd2); 185 dest_exponent--; 186 } 187 Sgl_set_exponentmantissa(result,opnd2); 188 goto testforunderflow; 189 } 190 /* 191 * opnd1/opnd2 <= 1/2 192 * 193 * In this case n will round to zero, so 194 * r = opnd1 195 */ 196 Sgl_set_exponentmantissa(result,opnd1); 197 dest_exponent = opnd1_exponent; 198 goto testforunderflow; 199 } 200 201 /* 202 * Generate result 203 * 204 * Do iterative subtract until remainder is less than operand 2. 205 */ 206 while (stepcount-- > 0 && Sgl_all(opnd1)) { 207 if (Sgl_isnotlessthan(opnd1,opnd2)) 208 Sgl_subtract(opnd1,opnd2,opnd1); 209 Sgl_leftshiftby1(opnd1); 210 } 211 /* 212 * Do last subtract, then determine which way to round if remainder 213 * is exactly 1/2 of opnd2 214 */ 215 if (Sgl_isnotlessthan(opnd1,opnd2)) { 216 Sgl_subtract(opnd1,opnd2,opnd1); 217 roundup = TRUE; 218 } 219 if (stepcount > 0 || Sgl_iszero(opnd1)) { 220 /* division is exact, remainder is zero */ 221 Sgl_setzero_exponentmantissa(result); 222 *dstptr = result; 223 return(NOEXCEPTION); 224 } 225 226 /* 227 * Check for cases where opnd1/opnd2 < n 228 * 229 * In this case the result's sign will be opposite that of 230 * opnd1. The mantissa also needs some correction. 231 */ 232 Sgl_leftshiftby1(opnd1); 233 if (Sgl_isgreaterthan(opnd1,opnd2)) { 234 Sgl_invert_sign(result); 235 Sgl_subtract((opnd2<<1),opnd1,opnd1); 236 } 237 /* check for remainder being exactly 1/2 of opnd2 */ 238 else if (Sgl_isequal(opnd1,opnd2) && roundup) { 239 Sgl_invert_sign(result); 240 } 241 242 /* normalize result's mantissa */ 243 while (Sgl_iszero_hidden(opnd1)) { 244 dest_exponent--; 245 Sgl_leftshiftby1(opnd1); 246 } 247 Sgl_set_exponentmantissa(result,opnd1); 248 249 /* 250 * Test for underflow 251 */ 252 testforunderflow: 253 if (dest_exponent <= 0) { 254 /* trap if UNDERFLOWTRAP enabled */ 255 if (Is_underflowtrap_enabled()) { 256 /* 257 * Adjust bias of result 258 */ 259 Sgl_setwrapped_exponent(result,dest_exponent,unfl); 260 *dstptr = result; 261 /* frem is always exact */ 262 return(UNDERFLOWEXCEPTION); 263 } 264 /* 265 * denormalize result or set to signed zero 266 */ 267 if (dest_exponent >= (1 - SGL_P)) { 268 Sgl_rightshift_exponentmantissa(result,1-dest_exponent); 269 } 270 else { 271 Sgl_setzero_exponentmantissa(result); 272 } 273 } 274 else Sgl_set_exponent(result,dest_exponent); 275 *dstptr = result; 276 return(NOEXCEPTION); 277 } 278