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