1 /* 2 * TriCore emulation for qemu: fpu helper. 3 * 4 * Copyright (c) 2016 Bastian Koppelmann University of Paderborn 5 * 6 * This library is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU Lesser General Public 8 * License as published by the Free Software Foundation; either 9 * version 2.1 of the License, or (at your option) any later version. 10 * 11 * This library is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 * Lesser General Public License for more details. 15 * 16 * You should have received a copy of the GNU Lesser General Public 17 * License along with this library; if not, see <http://www.gnu.org/licenses/>. 18 */ 19 20 #include "qemu/osdep.h" 21 #include "cpu.h" 22 #include "exec/helper-proto.h" 23 #include "fpu/softfloat.h" 24 25 #define QUIET_NAN 0x7fc00000 26 #define ADD_NAN 0x7fc00001 27 #define SQRT_NAN 0x7fc00004 28 #define DIV_NAN 0x7fc00008 29 #define MUL_NAN 0x7fc00002 30 #define FPU_FS PSW_USB_C 31 #define FPU_FI PSW_USB_V 32 #define FPU_FV PSW_USB_SV 33 #define FPU_FZ PSW_USB_AV 34 #define FPU_FU PSW_USB_SAV 35 36 #define float32_sqrt_nan make_float32(SQRT_NAN) 37 #define float32_quiet_nan make_float32(QUIET_NAN) 38 39 /* we don't care about input_denormal */ 40 static inline uint8_t f_get_excp_flags(CPUTriCoreState *env) 41 { 42 return get_float_exception_flags(&env->fp_status) 43 & (float_flag_invalid 44 | float_flag_overflow 45 | float_flag_underflow 46 | float_flag_output_denormal 47 | float_flag_divbyzero 48 | float_flag_inexact); 49 } 50 51 static inline float32 f_maddsub_nan_result(float32 arg1, float32 arg2, 52 float32 arg3, float32 result, 53 uint32_t muladd_negate_c) 54 { 55 uint32_t aSign, bSign, cSign; 56 uint32_t aExp, bExp, cExp; 57 58 if (float32_is_any_nan(arg1) || float32_is_any_nan(arg2) || 59 float32_is_any_nan(arg3)) { 60 return QUIET_NAN; 61 } else if (float32_is_infinity(arg1) && float32_is_zero(arg2)) { 62 return MUL_NAN; 63 } else if (float32_is_zero(arg1) && float32_is_infinity(arg2)) { 64 return MUL_NAN; 65 } else { 66 aSign = arg1 >> 31; 67 bSign = arg2 >> 31; 68 cSign = arg3 >> 31; 69 70 aExp = (arg1 >> 23) & 0xff; 71 bExp = (arg2 >> 23) & 0xff; 72 cExp = (arg3 >> 23) & 0xff; 73 74 if (muladd_negate_c) { 75 cSign ^= 1; 76 } 77 if (((aExp == 0xff) || (bExp == 0xff)) && (cExp == 0xff)) { 78 if (aSign ^ bSign ^ cSign) { 79 return ADD_NAN; 80 } 81 } 82 } 83 84 return result; 85 } 86 87 static void f_update_psw_flags(CPUTriCoreState *env, uint8_t flags) 88 { 89 uint8_t some_excp = 0; 90 set_float_exception_flags(0, &env->fp_status); 91 92 if (flags & float_flag_invalid) { 93 env->FPU_FI = 1 << 31; 94 some_excp = 1; 95 } 96 97 if (flags & float_flag_overflow) { 98 env->FPU_FV = 1 << 31; 99 some_excp = 1; 100 } 101 102 if (flags & float_flag_underflow || flags & float_flag_output_denormal) { 103 env->FPU_FU = 1 << 31; 104 some_excp = 1; 105 } 106 107 if (flags & float_flag_divbyzero) { 108 env->FPU_FZ = 1 << 31; 109 some_excp = 1; 110 } 111 112 if (flags & float_flag_inexact || flags & float_flag_output_denormal) { 113 env->PSW |= 1 << 26; 114 some_excp = 1; 115 } 116 117 env->FPU_FS = some_excp; 118 } 119 120 #define FADD_SUB(op) \ 121 uint32_t helper_f##op(CPUTriCoreState *env, uint32_t r1, uint32_t r2) \ 122 { \ 123 float32 arg1 = make_float32(r1); \ 124 float32 arg2 = make_float32(r2); \ 125 uint32_t flags; \ 126 float32 f_result; \ 127 \ 128 f_result = float32_##op(arg2, arg1, &env->fp_status); \ 129 flags = f_get_excp_flags(env); \ 130 if (flags) { \ 131 /* If the output is a NaN, but the inputs aren't, \ 132 we return a unique value. */ \ 133 if ((flags & float_flag_invalid) \ 134 && !float32_is_any_nan(arg1) \ 135 && !float32_is_any_nan(arg2)) { \ 136 f_result = ADD_NAN; \ 137 } \ 138 f_update_psw_flags(env, flags); \ 139 } else { \ 140 env->FPU_FS = 0; \ 141 } \ 142 return (uint32_t)f_result; \ 143 } 144 FADD_SUB(add) 145 FADD_SUB(sub) 146 147 uint32_t helper_fmul(CPUTriCoreState *env, uint32_t r1, uint32_t r2) 148 { 149 uint32_t flags; 150 float32 arg1 = make_float32(r1); 151 float32 arg2 = make_float32(r2); 152 float32 f_result; 153 154 f_result = float32_mul(arg1, arg2, &env->fp_status); 155 156 flags = f_get_excp_flags(env); 157 if (flags) { 158 /* If the output is a NaN, but the inputs aren't, 159 we return a unique value. */ 160 if ((flags & float_flag_invalid) 161 && !float32_is_any_nan(arg1) 162 && !float32_is_any_nan(arg2)) { 163 f_result = MUL_NAN; 164 } 165 f_update_psw_flags(env, flags); 166 } else { 167 env->FPU_FS = 0; 168 } 169 return (uint32_t)f_result; 170 171 } 172 173 /* 174 * Target TriCore QSEED.F significand Lookup Table 175 * 176 * The QSEED.F output significand depends on the least-significant 177 * exponent bit and the 6 most-significant significand bits. 178 * 179 * IEEE 754 float datatype 180 * partitioned into Sign (S), Exponent (E) and Significand (M): 181 * 182 * S E E E E E E E E M M M M M M ... 183 * | | | 184 * +------+------+-------+-------+ 185 * | | 186 * for lookup table 187 * calculating index for 188 * output E output M 189 * 190 * This lookup table was extracted by analyzing QSEED output 191 * from the real hardware 192 */ 193 static const uint8_t target_qseed_significand_table[128] = { 194 253, 252, 245, 244, 239, 238, 231, 230, 225, 224, 217, 216, 195 211, 210, 205, 204, 201, 200, 195, 194, 189, 188, 185, 184, 196 179, 178, 175, 174, 169, 168, 165, 164, 161, 160, 157, 156, 197 153, 152, 149, 148, 145, 144, 141, 140, 137, 136, 133, 132, 198 131, 130, 127, 126, 123, 122, 121, 120, 117, 116, 115, 114, 199 111, 110, 109, 108, 103, 102, 99, 98, 93, 92, 89, 88, 83, 200 82, 79, 78, 75, 74, 71, 70, 67, 66, 63, 62, 59, 58, 55, 201 54, 53, 52, 49, 48, 45, 44, 43, 42, 39, 38, 37, 36, 33, 202 32, 31, 30, 27, 26, 25, 24, 23, 22, 19, 18, 17, 16, 15, 203 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2 204 }; 205 206 uint32_t helper_qseed(CPUTriCoreState *env, uint32_t r1) 207 { 208 uint32_t arg1, S, E, M, E_minus_one, m_idx; 209 uint32_t new_E, new_M, new_S, result; 210 211 arg1 = make_float32(r1); 212 213 /* fetch IEEE-754 fields S, E and the uppermost 6-bit of M */ 214 S = extract32(arg1, 31, 1); 215 E = extract32(arg1, 23, 8); 216 M = extract32(arg1, 17, 6); 217 218 if (float32_is_any_nan(arg1)) { 219 result = float32_quiet_nan; 220 } else if (float32_is_zero_or_denormal(arg1)) { 221 if (float32_is_neg(arg1)) { 222 result = float32_infinity | (1 << 31); 223 } else { 224 result = float32_infinity; 225 } 226 } else if (float32_is_neg(arg1)) { 227 result = float32_sqrt_nan; 228 } else if (float32_is_infinity(arg1)) { 229 result = float32_zero; 230 } else { 231 E_minus_one = E - 1; 232 m_idx = ((E_minus_one & 1) << 6) | M; 233 new_S = S; 234 new_E = 0xBD - E_minus_one / 2; 235 new_M = target_qseed_significand_table[m_idx]; 236 237 result = 0; 238 result = deposit32(result, 31, 1, new_S); 239 result = deposit32(result, 23, 8, new_E); 240 result = deposit32(result, 15, 8, new_M); 241 } 242 243 if (float32_is_signaling_nan(arg1, &env->fp_status) 244 || result == float32_sqrt_nan) { 245 env->FPU_FI = 1 << 31; 246 env->FPU_FS = 1; 247 } else { 248 env->FPU_FS = 0; 249 } 250 251 return (uint32_t) result; 252 } 253 254 uint32_t helper_fdiv(CPUTriCoreState *env, uint32_t r1, uint32_t r2) 255 { 256 uint32_t flags; 257 float32 arg1 = make_float32(r1); 258 float32 arg2 = make_float32(r2); 259 float32 f_result; 260 261 f_result = float32_div(arg1, arg2 , &env->fp_status); 262 263 flags = f_get_excp_flags(env); 264 if (flags) { 265 /* If the output is a NaN, but the inputs aren't, 266 we return a unique value. */ 267 if ((flags & float_flag_invalid) 268 && !float32_is_any_nan(arg1) 269 && !float32_is_any_nan(arg2)) { 270 f_result = DIV_NAN; 271 } 272 f_update_psw_flags(env, flags); 273 } else { 274 env->FPU_FS = 0; 275 } 276 277 return (uint32_t)f_result; 278 } 279 280 uint32_t helper_fmadd(CPUTriCoreState *env, uint32_t r1, 281 uint32_t r2, uint32_t r3) 282 { 283 uint32_t flags; 284 float32 arg1 = make_float32(r1); 285 float32 arg2 = make_float32(r2); 286 float32 arg3 = make_float32(r3); 287 float32 f_result; 288 289 f_result = float32_muladd(arg1, arg2, arg3, 0, &env->fp_status); 290 291 flags = f_get_excp_flags(env); 292 if (flags) { 293 if (flags & float_flag_invalid) { 294 arg1 = float32_squash_input_denormal(arg1, &env->fp_status); 295 arg2 = float32_squash_input_denormal(arg2, &env->fp_status); 296 arg3 = float32_squash_input_denormal(arg3, &env->fp_status); 297 f_result = f_maddsub_nan_result(arg1, arg2, arg3, f_result, 0); 298 } 299 f_update_psw_flags(env, flags); 300 } else { 301 env->FPU_FS = 0; 302 } 303 return (uint32_t)f_result; 304 } 305 306 uint32_t helper_fmsub(CPUTriCoreState *env, uint32_t r1, 307 uint32_t r2, uint32_t r3) 308 { 309 uint32_t flags; 310 float32 arg1 = make_float32(r1); 311 float32 arg2 = make_float32(r2); 312 float32 arg3 = make_float32(r3); 313 float32 f_result; 314 315 f_result = float32_muladd(arg1, arg2, arg3, float_muladd_negate_product, 316 &env->fp_status); 317 318 flags = f_get_excp_flags(env); 319 if (flags) { 320 if (flags & float_flag_invalid) { 321 arg1 = float32_squash_input_denormal(arg1, &env->fp_status); 322 arg2 = float32_squash_input_denormal(arg2, &env->fp_status); 323 arg3 = float32_squash_input_denormal(arg3, &env->fp_status); 324 325 f_result = f_maddsub_nan_result(arg1, arg2, arg3, f_result, 1); 326 } 327 f_update_psw_flags(env, flags); 328 } else { 329 env->FPU_FS = 0; 330 } 331 return (uint32_t)f_result; 332 } 333 334 uint32_t helper_fcmp(CPUTriCoreState *env, uint32_t r1, uint32_t r2) 335 { 336 uint32_t result, flags; 337 float32 arg1 = make_float32(r1); 338 float32 arg2 = make_float32(r2); 339 340 set_flush_inputs_to_zero(0, &env->fp_status); 341 342 result = 1 << (float32_compare_quiet(arg1, arg2, &env->fp_status) + 1); 343 result |= float32_is_denormal(arg1) << 4; 344 result |= float32_is_denormal(arg2) << 5; 345 346 flags = f_get_excp_flags(env); 347 if (flags) { 348 f_update_psw_flags(env, flags); 349 } else { 350 env->FPU_FS = 0; 351 } 352 353 set_flush_inputs_to_zero(1, &env->fp_status); 354 return result; 355 } 356 357 uint32_t helper_ftoi(CPUTriCoreState *env, uint32_t arg) 358 { 359 float32 f_arg = make_float32(arg); 360 int32_t result, flags; 361 362 result = float32_to_int32(f_arg, &env->fp_status); 363 364 flags = f_get_excp_flags(env); 365 if (flags) { 366 if (float32_is_any_nan(f_arg)) { 367 result = 0; 368 } 369 f_update_psw_flags(env, flags); 370 } else { 371 env->FPU_FS = 0; 372 } 373 return (uint32_t)result; 374 } 375 376 uint32_t helper_hptof(CPUTriCoreState *env, uint32_t arg) 377 { 378 float16 f_arg = make_float16(arg); 379 uint32_t result = 0; 380 int32_t flags = 0; 381 382 /* 383 * if we have any NAN we need to move the top 2 and lower 8 input mantissa 384 * bits to the top 2 and lower 8 output mantissa bits respectively. 385 * Softfloat on the other hand uses the top 10 mantissa bits. 386 */ 387 if (float16_is_any_nan(f_arg)) { 388 if (float16_is_signaling_nan(f_arg, &env->fp_status)) { 389 flags |= float_flag_invalid; 390 } 391 result = 0; 392 result = float32_set_sign(result, f_arg >> 15); 393 result = deposit32(result, 23, 8, 0xff); 394 result = deposit32(result, 21, 2, extract32(f_arg, 8, 2)); 395 result = deposit32(result, 0, 8, extract32(f_arg, 0, 8)); 396 } else { 397 set_flush_inputs_to_zero(0, &env->fp_status); 398 result = float16_to_float32(f_arg, true, &env->fp_status); 399 set_flush_inputs_to_zero(1, &env->fp_status); 400 flags = f_get_excp_flags(env); 401 } 402 403 if (flags) { 404 f_update_psw_flags(env, flags); 405 } else { 406 env->FPU_FS = 0; 407 } 408 409 return result; 410 } 411 412 uint32_t helper_ftohp(CPUTriCoreState *env, uint32_t arg) 413 { 414 float32 f_arg = make_float32(arg); 415 uint32_t result = 0; 416 int32_t flags = 0; 417 418 /* 419 * if we have any NAN we need to move the top 2 and lower 8 input mantissa 420 * bits to the top 2 and lower 8 output mantissa bits respectively. 421 * Softfloat on the other hand uses the top 10 mantissa bits. 422 */ 423 if (float32_is_any_nan(f_arg)) { 424 if (float32_is_signaling_nan(f_arg, &env->fp_status)) { 425 flags |= float_flag_invalid; 426 } 427 result = float16_set_sign(result, arg >> 31); 428 result = deposit32(result, 10, 5, 0x1f); 429 result = deposit32(result, 8, 2, extract32(arg, 21, 2)); 430 result = deposit32(result, 0, 8, extract32(arg, 0, 8)); 431 if (extract32(result, 0, 10) == 0) { 432 result |= (1 << 8); 433 } 434 } else { 435 set_flush_to_zero(0, &env->fp_status); 436 result = float32_to_float16(f_arg, true, &env->fp_status); 437 set_flush_to_zero(1, &env->fp_status); 438 flags = f_get_excp_flags(env); 439 } 440 441 if (flags) { 442 f_update_psw_flags(env, flags); 443 } else { 444 env->FPU_FS = 0; 445 } 446 447 return result; 448 } 449 450 uint32_t helper_itof(CPUTriCoreState *env, uint32_t arg) 451 { 452 float32 f_result; 453 uint32_t flags; 454 f_result = int32_to_float32(arg, &env->fp_status); 455 456 flags = f_get_excp_flags(env); 457 if (flags) { 458 f_update_psw_flags(env, flags); 459 } else { 460 env->FPU_FS = 0; 461 } 462 return (uint32_t)f_result; 463 } 464 465 uint32_t helper_utof(CPUTriCoreState *env, uint32_t arg) 466 { 467 float32 f_result; 468 uint32_t flags; 469 470 f_result = uint32_to_float32(arg, &env->fp_status); 471 472 flags = f_get_excp_flags(env); 473 if (flags) { 474 f_update_psw_flags(env, flags); 475 } else { 476 env->FPU_FS = 0; 477 } 478 return (uint32_t)f_result; 479 } 480 481 uint32_t helper_ftoiz(CPUTriCoreState *env, uint32_t arg) 482 { 483 float32 f_arg = make_float32(arg); 484 uint32_t result; 485 int32_t flags; 486 487 result = float32_to_int32_round_to_zero(f_arg, &env->fp_status); 488 489 flags = f_get_excp_flags(env); 490 if (flags & float_flag_invalid) { 491 flags &= ~float_flag_inexact; 492 if (float32_is_any_nan(f_arg)) { 493 result = 0; 494 } 495 } 496 497 if (flags) { 498 f_update_psw_flags(env, flags); 499 } else { 500 env->FPU_FS = 0; 501 } 502 503 return result; 504 } 505 506 uint32_t helper_ftou(CPUTriCoreState *env, uint32_t arg) 507 { 508 float32 f_arg = make_float32(arg); 509 uint32_t result; 510 int32_t flags = 0; 511 512 result = float32_to_uint32(f_arg, &env->fp_status); 513 514 flags = f_get_excp_flags(env); 515 if (flags & float_flag_invalid) { 516 flags &= ~float_flag_inexact; 517 if (float32_is_any_nan(f_arg)) { 518 result = 0; 519 } 520 /* 521 * we need to check arg < 0.0 before rounding as TriCore needs to raise 522 * float_flag_invalid as well. For instance, when we have a negative 523 * exponent and sign, softfloat would only raise float_flat_inexact. 524 */ 525 } else if (float32_lt_quiet(f_arg, 0, &env->fp_status)) { 526 flags = float_flag_invalid; 527 result = 0; 528 } 529 530 if (flags) { 531 f_update_psw_flags(env, flags); 532 } else { 533 env->FPU_FS = 0; 534 } 535 return result; 536 } 537 538 uint32_t helper_ftouz(CPUTriCoreState *env, uint32_t arg) 539 { 540 float32 f_arg = make_float32(arg); 541 uint32_t result; 542 int32_t flags; 543 544 result = float32_to_uint32_round_to_zero(f_arg, &env->fp_status); 545 546 flags = f_get_excp_flags(env); 547 if (flags & float_flag_invalid) { 548 flags &= ~float_flag_inexact; 549 if (float32_is_any_nan(f_arg)) { 550 result = 0; 551 } 552 /* 553 * we need to check arg < 0.0 before rounding as TriCore needs to raise 554 * float_flag_invalid as well. For instance, when we have a negative 555 * exponent and sign, softfloat would only raise float_flat_inexact. 556 */ 557 } else if (float32_lt_quiet(f_arg, 0, &env->fp_status)) { 558 flags = float_flag_invalid; 559 result = 0; 560 } 561 562 if (flags) { 563 f_update_psw_flags(env, flags); 564 } else { 565 env->FPU_FS = 0; 566 } 567 return result; 568 } 569 570 void helper_updfl(CPUTriCoreState *env, uint32_t arg) 571 { 572 env->FPU_FS = extract32(arg, 7, 1) & extract32(arg, 15, 1); 573 env->FPU_FI = (extract32(arg, 6, 1) & extract32(arg, 14, 1)) << 31; 574 env->FPU_FV = (extract32(arg, 5, 1) & extract32(arg, 13, 1)) << 31; 575 env->FPU_FZ = (extract32(arg, 4, 1) & extract32(arg, 12, 1)) << 31; 576 env->FPU_FU = (extract32(arg, 3, 1) & extract32(arg, 11, 1)) << 31; 577 /* clear FX and RM */ 578 env->PSW &= ~(extract32(arg, 10, 1) << 26); 579 env->PSW |= (extract32(arg, 2, 1) & extract32(arg, 10, 1)) << 26; 580 581 fpu_set_state(env); 582 } 583