1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 NetWinder Floating Point Emulator 4 (c) Rebel.COM, 1998,1999 5 (c) Philip Blundell, 1999, 2001 6 7 Direct questions, comments to Scott Bambrough <scottb@netwinder.org> 8 9 */ 10 11 #include "fpa11.h" 12 #include "fpopcode.h" 13 #include "fpa11.inl" 14 #include "fpmodule.h" 15 #include "fpmodule.inl" 16 #include "softfloat.h" 17 18 unsigned int PerformFLT(const unsigned int opcode); 19 unsigned int PerformFIX(const unsigned int opcode); 20 21 static unsigned int PerformComparison(const unsigned int opcode); 22 23 unsigned int EmulateCPRT(const unsigned int opcode) 24 { 25 26 if (opcode & 0x800000) { 27 /* This is some variant of a comparison (PerformComparison 28 will sort out which one). Since most of the other CPRT 29 instructions are oddball cases of some sort or other it 30 makes sense to pull this out into a fast path. */ 31 return PerformComparison(opcode); 32 } 33 34 /* Hint to GCC that we'd like a jump table rather than a load of CMPs */ 35 switch ((opcode & 0x700000) >> 20) { 36 case FLT_CODE >> 20: 37 return PerformFLT(opcode); 38 break; 39 case FIX_CODE >> 20: 40 return PerformFIX(opcode); 41 break; 42 43 case WFS_CODE >> 20: 44 writeFPSR(readRegister(getRd(opcode))); 45 break; 46 case RFS_CODE >> 20: 47 writeRegister(getRd(opcode), readFPSR()); 48 break; 49 50 default: 51 return 0; 52 } 53 54 return 1; 55 } 56 57 unsigned int PerformFLT(const unsigned int opcode) 58 { 59 FPA11 *fpa11 = GET_FPA11(); 60 struct roundingData roundData; 61 62 roundData.mode = SetRoundingMode(opcode); 63 roundData.precision = SetRoundingPrecision(opcode); 64 roundData.exception = 0; 65 66 switch (opcode & MASK_ROUNDING_PRECISION) { 67 case ROUND_SINGLE: 68 { 69 fpa11->fType[getFn(opcode)] = typeSingle; 70 fpa11->fpreg[getFn(opcode)].fSingle = int32_to_float32(&roundData, readRegister(getRd(opcode))); 71 } 72 break; 73 74 case ROUND_DOUBLE: 75 { 76 fpa11->fType[getFn(opcode)] = typeDouble; 77 fpa11->fpreg[getFn(opcode)].fDouble = int32_to_float64(readRegister(getRd(opcode))); 78 } 79 break; 80 81 #ifdef CONFIG_FPE_NWFPE_XP 82 case ROUND_EXTENDED: 83 { 84 fpa11->fType[getFn(opcode)] = typeExtended; 85 fpa11->fpreg[getFn(opcode)].fExtended = int32_to_floatx80(readRegister(getRd(opcode))); 86 } 87 break; 88 #endif 89 90 default: 91 return 0; 92 } 93 94 if (roundData.exception) 95 float_raise(roundData.exception); 96 97 return 1; 98 } 99 100 unsigned int PerformFIX(const unsigned int opcode) 101 { 102 FPA11 *fpa11 = GET_FPA11(); 103 unsigned int Fn = getFm(opcode); 104 struct roundingData roundData; 105 106 roundData.mode = SetRoundingMode(opcode); 107 roundData.precision = SetRoundingPrecision(opcode); 108 roundData.exception = 0; 109 110 switch (fpa11->fType[Fn]) { 111 case typeSingle: 112 { 113 writeRegister(getRd(opcode), float32_to_int32(&roundData, fpa11->fpreg[Fn].fSingle)); 114 } 115 break; 116 117 case typeDouble: 118 { 119 writeRegister(getRd(opcode), float64_to_int32(&roundData, fpa11->fpreg[Fn].fDouble)); 120 } 121 break; 122 123 #ifdef CONFIG_FPE_NWFPE_XP 124 case typeExtended: 125 { 126 writeRegister(getRd(opcode), floatx80_to_int32(&roundData, fpa11->fpreg[Fn].fExtended)); 127 } 128 break; 129 #endif 130 131 default: 132 return 0; 133 } 134 135 if (roundData.exception) 136 float_raise(roundData.exception); 137 138 return 1; 139 } 140 141 /* This instruction sets the flags N, Z, C, V in the FPSR. */ 142 static unsigned int PerformComparison(const unsigned int opcode) 143 { 144 FPA11 *fpa11 = GET_FPA11(); 145 unsigned int Fn = getFn(opcode), Fm = getFm(opcode); 146 int e_flag = opcode & 0x400000; /* 1 if CxFE */ 147 int n_flag = opcode & 0x200000; /* 1 if CNxx */ 148 unsigned int flags = 0; 149 150 #ifdef CONFIG_FPE_NWFPE_XP 151 floatx80 rFn, rFm; 152 153 /* Check for unordered condition and convert all operands to 80-bit 154 format. 155 ?? Might be some mileage in avoiding this conversion if possible. 156 Eg, if both operands are 32-bit, detect this and do a 32-bit 157 comparison (cheaper than an 80-bit one). */ 158 switch (fpa11->fType[Fn]) { 159 case typeSingle: 160 //printk("single.\n"); 161 if (float32_is_nan(fpa11->fpreg[Fn].fSingle)) 162 goto unordered; 163 rFn = float32_to_floatx80(fpa11->fpreg[Fn].fSingle); 164 break; 165 166 case typeDouble: 167 //printk("double.\n"); 168 if (float64_is_nan(fpa11->fpreg[Fn].fDouble)) 169 goto unordered; 170 rFn = float64_to_floatx80(fpa11->fpreg[Fn].fDouble); 171 break; 172 173 case typeExtended: 174 //printk("extended.\n"); 175 if (floatx80_is_nan(fpa11->fpreg[Fn].fExtended)) 176 goto unordered; 177 rFn = fpa11->fpreg[Fn].fExtended; 178 break; 179 180 default: 181 return 0; 182 } 183 184 if (CONSTANT_FM(opcode)) { 185 //printk("Fm is a constant: #%d.\n",Fm); 186 rFm = getExtendedConstant(Fm); 187 if (floatx80_is_nan(rFm)) 188 goto unordered; 189 } else { 190 //printk("Fm = r%d which contains a ",Fm); 191 switch (fpa11->fType[Fm]) { 192 case typeSingle: 193 //printk("single.\n"); 194 if (float32_is_nan(fpa11->fpreg[Fm].fSingle)) 195 goto unordered; 196 rFm = float32_to_floatx80(fpa11->fpreg[Fm].fSingle); 197 break; 198 199 case typeDouble: 200 //printk("double.\n"); 201 if (float64_is_nan(fpa11->fpreg[Fm].fDouble)) 202 goto unordered; 203 rFm = float64_to_floatx80(fpa11->fpreg[Fm].fDouble); 204 break; 205 206 case typeExtended: 207 //printk("extended.\n"); 208 if (floatx80_is_nan(fpa11->fpreg[Fm].fExtended)) 209 goto unordered; 210 rFm = fpa11->fpreg[Fm].fExtended; 211 break; 212 213 default: 214 return 0; 215 } 216 } 217 218 if (n_flag) 219 rFm.high ^= 0x8000; 220 221 /* test for less than condition */ 222 if (floatx80_lt(rFn, rFm)) 223 flags |= CC_NEGATIVE; 224 225 /* test for equal condition */ 226 if (floatx80_eq(rFn, rFm)) 227 flags |= CC_ZERO; 228 229 /* test for greater than or equal condition */ 230 if (floatx80_lt(rFm, rFn)) 231 flags |= CC_CARRY; 232 233 #else 234 if (CONSTANT_FM(opcode)) { 235 /* Fm is a constant. Do the comparison in whatever precision 236 Fn happens to be stored in. */ 237 if (fpa11->fType[Fn] == typeSingle) { 238 float32 rFm = getSingleConstant(Fm); 239 float32 rFn = fpa11->fpreg[Fn].fSingle; 240 241 if (float32_is_nan(rFn)) 242 goto unordered; 243 244 if (n_flag) 245 rFm ^= 0x80000000; 246 247 /* test for less than condition */ 248 if (float32_lt_nocheck(rFn, rFm)) 249 flags |= CC_NEGATIVE; 250 251 /* test for equal condition */ 252 if (float32_eq_nocheck(rFn, rFm)) 253 flags |= CC_ZERO; 254 255 /* test for greater than or equal condition */ 256 if (float32_lt_nocheck(rFm, rFn)) 257 flags |= CC_CARRY; 258 } else { 259 float64 rFm = getDoubleConstant(Fm); 260 float64 rFn = fpa11->fpreg[Fn].fDouble; 261 262 if (float64_is_nan(rFn)) 263 goto unordered; 264 265 if (n_flag) 266 rFm ^= 0x8000000000000000ULL; 267 268 /* test for less than condition */ 269 if (float64_lt_nocheck(rFn, rFm)) 270 flags |= CC_NEGATIVE; 271 272 /* test for equal condition */ 273 if (float64_eq_nocheck(rFn, rFm)) 274 flags |= CC_ZERO; 275 276 /* test for greater than or equal condition */ 277 if (float64_lt_nocheck(rFm, rFn)) 278 flags |= CC_CARRY; 279 } 280 } else { 281 /* Both operands are in registers. */ 282 if (fpa11->fType[Fn] == typeSingle 283 && fpa11->fType[Fm] == typeSingle) { 284 float32 rFm = fpa11->fpreg[Fm].fSingle; 285 float32 rFn = fpa11->fpreg[Fn].fSingle; 286 287 if (float32_is_nan(rFn) 288 || float32_is_nan(rFm)) 289 goto unordered; 290 291 if (n_flag) 292 rFm ^= 0x80000000; 293 294 /* test for less than condition */ 295 if (float32_lt_nocheck(rFn, rFm)) 296 flags |= CC_NEGATIVE; 297 298 /* test for equal condition */ 299 if (float32_eq_nocheck(rFn, rFm)) 300 flags |= CC_ZERO; 301 302 /* test for greater than or equal condition */ 303 if (float32_lt_nocheck(rFm, rFn)) 304 flags |= CC_CARRY; 305 } else { 306 /* Promote 32-bit operand to 64 bits. */ 307 float64 rFm, rFn; 308 309 rFm = (fpa11->fType[Fm] == typeSingle) ? 310 float32_to_float64(fpa11->fpreg[Fm].fSingle) 311 : fpa11->fpreg[Fm].fDouble; 312 313 rFn = (fpa11->fType[Fn] == typeSingle) ? 314 float32_to_float64(fpa11->fpreg[Fn].fSingle) 315 : fpa11->fpreg[Fn].fDouble; 316 317 if (float64_is_nan(rFn) 318 || float64_is_nan(rFm)) 319 goto unordered; 320 321 if (n_flag) 322 rFm ^= 0x8000000000000000ULL; 323 324 /* test for less than condition */ 325 if (float64_lt_nocheck(rFn, rFm)) 326 flags |= CC_NEGATIVE; 327 328 /* test for equal condition */ 329 if (float64_eq_nocheck(rFn, rFm)) 330 flags |= CC_ZERO; 331 332 /* test for greater than or equal condition */ 333 if (float64_lt_nocheck(rFm, rFn)) 334 flags |= CC_CARRY; 335 } 336 } 337 338 #endif 339 340 writeConditionCodes(flags); 341 342 return 1; 343 344 unordered: 345 /* ?? The FPA data sheet is pretty vague about this, in particular 346 about whether the non-E comparisons can ever raise exceptions. 347 This implementation is based on a combination of what it says in 348 the data sheet, observation of how the Acorn emulator actually 349 behaves (and how programs expect it to) and guesswork. */ 350 flags |= CC_OVERFLOW; 351 flags &= ~(CC_ZERO | CC_NEGATIVE); 352 353 if (BIT_AC & readFPSR()) 354 flags |= CC_CARRY; 355 356 if (e_flag) 357 float_raise(float_flag_invalid); 358 359 writeConditionCodes(flags); 360 return 1; 361 } 362