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