fpu_helper.c (23337B)
1 /* SPDX-License-Identifier: GPL-2.0-or-later */ 2 /* 3 * LoongArch float point emulation helpers for QEMU 4 * 5 * Copyright (c) 2021 Loongson Technology Corporation Limited 6 */ 7 8 #include "qemu/osdep.h" 9 #include "cpu.h" 10 #include "exec/helper-proto.h" 11 #include "exec/exec-all.h" 12 #include "exec/cpu_ldst.h" 13 #include "fpu/softfloat.h" 14 #include "internals.h" 15 16 static inline uint64_t nanbox_s(float32 fp) 17 { 18 return fp | MAKE_64BIT_MASK(32, 32); 19 } 20 21 /* Convert loongarch rounding mode in fcsr0 to IEEE library */ 22 static const FloatRoundMode ieee_rm[4] = { 23 float_round_nearest_even, 24 float_round_to_zero, 25 float_round_up, 26 float_round_down 27 }; 28 29 void restore_fp_status(CPULoongArchState *env) 30 { 31 set_float_rounding_mode(ieee_rm[(env->fcsr0 >> FCSR0_RM) & 0x3], 32 &env->fp_status); 33 set_flush_to_zero(0, &env->fp_status); 34 } 35 36 static int ieee_ex_to_loongarch(int xcpt) 37 { 38 int ret = 0; 39 if (xcpt & float_flag_invalid) { 40 ret |= FP_INVALID; 41 } 42 if (xcpt & float_flag_overflow) { 43 ret |= FP_OVERFLOW; 44 } 45 if (xcpt & float_flag_underflow) { 46 ret |= FP_UNDERFLOW; 47 } 48 if (xcpt & float_flag_divbyzero) { 49 ret |= FP_DIV0; 50 } 51 if (xcpt & float_flag_inexact) { 52 ret |= FP_INEXACT; 53 } 54 return ret; 55 } 56 57 static void update_fcsr0_mask(CPULoongArchState *env, uintptr_t pc, int mask) 58 { 59 int flags = get_float_exception_flags(&env->fp_status); 60 61 set_float_exception_flags(0, &env->fp_status); 62 63 flags &= ~mask; 64 65 if (!flags) { 66 SET_FP_CAUSE(env->fcsr0, flags); 67 return; 68 } else { 69 flags = ieee_ex_to_loongarch(flags); 70 SET_FP_CAUSE(env->fcsr0, flags); 71 } 72 73 if (GET_FP_ENABLES(env->fcsr0) & flags) { 74 do_raise_exception(env, EXCCODE_FPE, pc); 75 } else { 76 UPDATE_FP_FLAGS(env->fcsr0, flags); 77 } 78 } 79 80 static void update_fcsr0(CPULoongArchState *env, uintptr_t pc) 81 { 82 update_fcsr0_mask(env, pc, 0); 83 } 84 85 uint64_t helper_fadd_s(CPULoongArchState *env, uint64_t fj, uint64_t fk) 86 { 87 uint64_t fd; 88 89 fd = nanbox_s(float32_add((uint32_t)fj, (uint32_t)fk, &env->fp_status)); 90 update_fcsr0(env, GETPC()); 91 return fd; 92 } 93 94 uint64_t helper_fadd_d(CPULoongArchState *env, uint64_t fj, uint64_t fk) 95 { 96 uint64_t fd; 97 98 fd = float64_add(fj, fk, &env->fp_status); 99 update_fcsr0(env, GETPC()); 100 return fd; 101 } 102 103 uint64_t helper_fsub_s(CPULoongArchState *env, uint64_t fj, uint64_t fk) 104 { 105 uint64_t fd; 106 107 fd = nanbox_s(float32_sub((uint32_t)fj, (uint32_t)fk, &env->fp_status)); 108 update_fcsr0(env, GETPC()); 109 return fd; 110 } 111 112 uint64_t helper_fsub_d(CPULoongArchState *env, uint64_t fj, uint64_t fk) 113 { 114 uint64_t fd; 115 116 fd = float64_sub(fj, fk, &env->fp_status); 117 update_fcsr0(env, GETPC()); 118 return fd; 119 } 120 121 uint64_t helper_fmul_s(CPULoongArchState *env, uint64_t fj, uint64_t fk) 122 { 123 uint64_t fd; 124 125 fd = nanbox_s(float32_mul((uint32_t)fj, (uint32_t)fk, &env->fp_status)); 126 update_fcsr0(env, GETPC()); 127 return fd; 128 } 129 130 uint64_t helper_fmul_d(CPULoongArchState *env, uint64_t fj, uint64_t fk) 131 { 132 uint64_t fd; 133 134 fd = float64_mul(fj, fk, &env->fp_status); 135 update_fcsr0(env, GETPC()); 136 return fd; 137 } 138 139 uint64_t helper_fdiv_s(CPULoongArchState *env, uint64_t fj, uint64_t fk) 140 { 141 uint64_t fd; 142 143 fd = nanbox_s(float32_div((uint32_t)fj, (uint32_t)fk, &env->fp_status)); 144 update_fcsr0(env, GETPC()); 145 return fd; 146 } 147 148 uint64_t helper_fdiv_d(CPULoongArchState *env, uint64_t fj, uint64_t fk) 149 { 150 uint64_t fd; 151 152 fd = float64_div(fj, fk, &env->fp_status); 153 update_fcsr0(env, GETPC()); 154 return fd; 155 } 156 157 uint64_t helper_fmax_s(CPULoongArchState *env, uint64_t fj, uint64_t fk) 158 { 159 uint64_t fd; 160 161 fd = nanbox_s(float32_maxnum((uint32_t)fj, (uint32_t)fk, &env->fp_status)); 162 update_fcsr0(env, GETPC()); 163 return fd; 164 } 165 166 uint64_t helper_fmax_d(CPULoongArchState *env, uint64_t fj, uint64_t fk) 167 { 168 uint64_t fd; 169 170 fd = float64_maxnum(fj, fk, &env->fp_status); 171 update_fcsr0(env, GETPC()); 172 return fd; 173 } 174 175 uint64_t helper_fmin_s(CPULoongArchState *env, uint64_t fj, uint64_t fk) 176 { 177 uint64_t fd; 178 179 fd = nanbox_s(float32_minnum((uint32_t)fj, (uint32_t)fk, &env->fp_status)); 180 update_fcsr0(env, GETPC()); 181 return fd; 182 } 183 184 uint64_t helper_fmin_d(CPULoongArchState *env, uint64_t fj, uint64_t fk) 185 { 186 uint64_t fd; 187 188 fd = float64_minnum(fj, fk, &env->fp_status); 189 update_fcsr0(env, GETPC()); 190 return fd; 191 } 192 193 uint64_t helper_fmaxa_s(CPULoongArchState *env, uint64_t fj, uint64_t fk) 194 { 195 uint64_t fd; 196 197 fd = nanbox_s(float32_maxnummag((uint32_t)fj, 198 (uint32_t)fk, &env->fp_status)); 199 update_fcsr0(env, GETPC()); 200 return fd; 201 } 202 203 uint64_t helper_fmaxa_d(CPULoongArchState *env, uint64_t fj, uint64_t fk) 204 { 205 uint64_t fd; 206 207 fd = float64_maxnummag(fj, fk, &env->fp_status); 208 update_fcsr0(env, GETPC()); 209 return fd; 210 } 211 212 uint64_t helper_fmina_s(CPULoongArchState *env, uint64_t fj, uint64_t fk) 213 { 214 uint64_t fd; 215 216 fd = nanbox_s(float32_minnummag((uint32_t)fj, 217 (uint32_t)fk, &env->fp_status)); 218 update_fcsr0(env, GETPC()); 219 return fd; 220 } 221 222 uint64_t helper_fmina_d(CPULoongArchState *env, uint64_t fj, uint64_t fk) 223 { 224 uint64_t fd; 225 226 fd = float64_minnummag(fj, fk, &env->fp_status); 227 update_fcsr0(env, GETPC()); 228 return fd; 229 } 230 231 uint64_t helper_fscaleb_s(CPULoongArchState *env, uint64_t fj, uint64_t fk) 232 { 233 uint64_t fd; 234 int32_t n = (int32_t)fk; 235 236 fd = nanbox_s(float32_scalbn((uint32_t)fj, 237 n > 0x200 ? 0x200 : 238 n < -0x200 ? -0x200 : n, 239 &env->fp_status)); 240 update_fcsr0(env, GETPC()); 241 return fd; 242 } 243 244 uint64_t helper_fscaleb_d(CPULoongArchState *env, uint64_t fj, uint64_t fk) 245 { 246 uint64_t fd; 247 int64_t n = (int64_t)fk; 248 249 fd = float64_scalbn(fj, 250 n > 0x1000 ? 0x1000 : 251 n < -0x1000 ? -0x1000 : n, 252 &env->fp_status); 253 update_fcsr0(env, GETPC()); 254 return fd; 255 } 256 257 uint64_t helper_fsqrt_s(CPULoongArchState *env, uint64_t fj) 258 { 259 uint64_t fd; 260 261 fd = nanbox_s(float32_sqrt((uint32_t)fj, &env->fp_status)); 262 update_fcsr0(env, GETPC()); 263 return fd; 264 } 265 266 uint64_t helper_fsqrt_d(CPULoongArchState *env, uint64_t fj) 267 { 268 uint64_t fd; 269 270 fd = float64_sqrt(fj, &env->fp_status); 271 update_fcsr0(env, GETPC()); 272 return fd; 273 } 274 275 uint64_t helper_frecip_s(CPULoongArchState *env, uint64_t fj) 276 { 277 uint64_t fd; 278 279 fd = nanbox_s(float32_div(float32_one, (uint32_t)fj, &env->fp_status)); 280 update_fcsr0(env, GETPC()); 281 return fd; 282 } 283 284 uint64_t helper_frecip_d(CPULoongArchState *env, uint64_t fj) 285 { 286 uint64_t fd; 287 288 fd = float64_div(float64_one, fj, &env->fp_status); 289 update_fcsr0(env, GETPC()); 290 return fd; 291 } 292 293 uint64_t helper_frsqrt_s(CPULoongArchState *env, uint64_t fj) 294 { 295 uint64_t fd; 296 uint32_t fp; 297 298 fp = float32_sqrt((uint32_t)fj, &env->fp_status); 299 fd = nanbox_s(float32_div(float32_one, fp, &env->fp_status)); 300 update_fcsr0(env, GETPC()); 301 return fd; 302 } 303 304 uint64_t helper_frsqrt_d(CPULoongArchState *env, uint64_t fj) 305 { 306 uint64_t fp, fd; 307 308 fp = float64_sqrt(fj, &env->fp_status); 309 fd = float64_div(float64_one, fp, &env->fp_status); 310 update_fcsr0(env, GETPC()); 311 return fd; 312 } 313 314 uint64_t helper_flogb_s(CPULoongArchState *env, uint64_t fj) 315 { 316 uint64_t fd; 317 uint32_t fp; 318 float_status *status = &env->fp_status; 319 FloatRoundMode old_mode = get_float_rounding_mode(status); 320 321 set_float_rounding_mode(float_round_down, status); 322 fp = float32_log2((uint32_t)fj, status); 323 fd = nanbox_s(float32_round_to_int(fp, status)); 324 set_float_rounding_mode(old_mode, status); 325 update_fcsr0_mask(env, GETPC(), float_flag_inexact); 326 return fd; 327 } 328 329 uint64_t helper_flogb_d(CPULoongArchState *env, uint64_t fj) 330 { 331 uint64_t fd; 332 float_status *status = &env->fp_status; 333 FloatRoundMode old_mode = get_float_rounding_mode(status); 334 335 set_float_rounding_mode(float_round_down, status); 336 fd = float64_log2(fj, status); 337 fd = float64_round_to_int(fd, status); 338 set_float_rounding_mode(old_mode, status); 339 update_fcsr0_mask(env, GETPC(), float_flag_inexact); 340 return fd; 341 } 342 343 uint64_t helper_fclass_s(CPULoongArchState *env, uint64_t fj) 344 { 345 float32 f = fj; 346 bool sign = float32_is_neg(f); 347 348 if (float32_is_infinity(f)) { 349 return sign ? 1 << 2 : 1 << 6; 350 } else if (float32_is_zero(f)) { 351 return sign ? 1 << 5 : 1 << 9; 352 } else if (float32_is_zero_or_denormal(f)) { 353 return sign ? 1 << 4 : 1 << 8; 354 } else if (float32_is_any_nan(f)) { 355 float_status s = { }; /* for snan_bit_is_one */ 356 return float32_is_quiet_nan(f, &s) ? 1 << 1 : 1 << 0; 357 } else { 358 return sign ? 1 << 3 : 1 << 7; 359 } 360 } 361 362 uint64_t helper_fclass_d(CPULoongArchState *env, uint64_t fj) 363 { 364 float64 f = fj; 365 bool sign = float64_is_neg(f); 366 367 if (float64_is_infinity(f)) { 368 return sign ? 1 << 2 : 1 << 6; 369 } else if (float64_is_zero(f)) { 370 return sign ? 1 << 5 : 1 << 9; 371 } else if (float64_is_zero_or_denormal(f)) { 372 return sign ? 1 << 4 : 1 << 8; 373 } else if (float64_is_any_nan(f)) { 374 float_status s = { }; /* for snan_bit_is_one */ 375 return float64_is_quiet_nan(f, &s) ? 1 << 1 : 1 << 0; 376 } else { 377 return sign ? 1 << 3 : 1 << 7; 378 } 379 } 380 381 uint64_t helper_fmuladd_s(CPULoongArchState *env, uint64_t fj, 382 uint64_t fk, uint64_t fa, uint32_t flag) 383 { 384 uint64_t fd; 385 386 fd = nanbox_s(float32_muladd((uint32_t)fj, (uint32_t)fk, 387 (uint32_t)fa, flag, &env->fp_status)); 388 update_fcsr0(env, GETPC()); 389 return fd; 390 } 391 392 uint64_t helper_fmuladd_d(CPULoongArchState *env, uint64_t fj, 393 uint64_t fk, uint64_t fa, uint32_t flag) 394 { 395 uint64_t fd; 396 397 fd = float64_muladd(fj, fk, fa, flag, &env->fp_status); 398 update_fcsr0(env, GETPC()); 399 return fd; 400 } 401 402 static uint64_t fcmp_common(CPULoongArchState *env, FloatRelation cmp, 403 uint32_t flags) 404 { 405 bool ret; 406 407 switch (cmp) { 408 case float_relation_less: 409 ret = (flags & FCMP_LT); 410 break; 411 case float_relation_equal: 412 ret = (flags & FCMP_EQ); 413 break; 414 case float_relation_greater: 415 ret = (flags & FCMP_GT); 416 break; 417 case float_relation_unordered: 418 ret = (flags & FCMP_UN); 419 break; 420 default: 421 g_assert_not_reached(); 422 } 423 update_fcsr0(env, GETPC()); 424 425 return ret; 426 } 427 428 /* fcmp_cXXX_s */ 429 uint64_t helper_fcmp_c_s(CPULoongArchState *env, uint64_t fj, 430 uint64_t fk, uint32_t flags) 431 { 432 FloatRelation cmp = float32_compare_quiet((uint32_t)fj, 433 (uint32_t)fk, &env->fp_status); 434 return fcmp_common(env, cmp, flags); 435 } 436 437 /* fcmp_sXXX_s */ 438 uint64_t helper_fcmp_s_s(CPULoongArchState *env, uint64_t fj, 439 uint64_t fk, uint32_t flags) 440 { 441 FloatRelation cmp = float32_compare((uint32_t)fj, 442 (uint32_t)fk, &env->fp_status); 443 return fcmp_common(env, cmp, flags); 444 } 445 446 /* fcmp_cXXX_d */ 447 uint64_t helper_fcmp_c_d(CPULoongArchState *env, uint64_t fj, 448 uint64_t fk, uint32_t flags) 449 { 450 FloatRelation cmp = float64_compare_quiet(fj, fk, &env->fp_status); 451 return fcmp_common(env, cmp, flags); 452 } 453 454 /* fcmp_sXXX_d */ 455 uint64_t helper_fcmp_s_d(CPULoongArchState *env, uint64_t fj, 456 uint64_t fk, uint32_t flags) 457 { 458 FloatRelation cmp = float64_compare(fj, fk, &env->fp_status); 459 return fcmp_common(env, cmp, flags); 460 } 461 462 /* floating point conversion */ 463 uint64_t helper_fcvt_s_d(CPULoongArchState *env, uint64_t fj) 464 { 465 uint64_t fd; 466 467 fd = nanbox_s(float64_to_float32(fj, &env->fp_status)); 468 update_fcsr0(env, GETPC()); 469 return fd; 470 } 471 472 uint64_t helper_fcvt_d_s(CPULoongArchState *env, uint64_t fj) 473 { 474 uint64_t fd; 475 476 fd = float32_to_float64((uint32_t)fj, &env->fp_status); 477 update_fcsr0(env, GETPC()); 478 return fd; 479 } 480 481 uint64_t helper_ffint_s_w(CPULoongArchState *env, uint64_t fj) 482 { 483 uint64_t fd; 484 485 fd = nanbox_s(int32_to_float32((int32_t)fj, &env->fp_status)); 486 update_fcsr0(env, GETPC()); 487 return fd; 488 } 489 490 uint64_t helper_ffint_s_l(CPULoongArchState *env, uint64_t fj) 491 { 492 uint64_t fd; 493 494 fd = nanbox_s(int64_to_float32(fj, &env->fp_status)); 495 update_fcsr0(env, GETPC()); 496 return fd; 497 } 498 499 uint64_t helper_ffint_d_w(CPULoongArchState *env, uint64_t fj) 500 { 501 uint64_t fd; 502 503 fd = int32_to_float64((int32_t)fj, &env->fp_status); 504 update_fcsr0(env, GETPC()); 505 return fd; 506 } 507 508 uint64_t helper_ffint_d_l(CPULoongArchState *env, uint64_t fj) 509 { 510 uint64_t fd; 511 512 fd = int64_to_float64(fj, &env->fp_status); 513 update_fcsr0(env, GETPC()); 514 return fd; 515 } 516 517 uint64_t helper_frint_s(CPULoongArchState *env, uint64_t fj) 518 { 519 uint64_t fd; 520 521 fd = (uint64_t)(float32_round_to_int((uint32_t)fj, &env->fp_status)); 522 update_fcsr0(env, GETPC()); 523 return fd; 524 } 525 526 uint64_t helper_frint_d(CPULoongArchState *env, uint64_t fj) 527 { 528 uint64_t fd; 529 530 fd = float64_round_to_int(fj, &env->fp_status); 531 update_fcsr0(env, GETPC()); 532 return fd; 533 } 534 535 uint64_t helper_ftintrm_l_d(CPULoongArchState *env, uint64_t fj) 536 { 537 uint64_t fd; 538 FloatRoundMode old_mode = get_float_rounding_mode(&env->fp_status); 539 540 set_float_rounding_mode(float_round_down, &env->fp_status); 541 fd = float64_to_int64(fj, &env->fp_status); 542 set_float_rounding_mode(old_mode, &env->fp_status); 543 544 if (get_float_exception_flags(&env->fp_status) & (float_flag_invalid)) { 545 if (float64_is_any_nan(fj)) { 546 fd = 0; 547 } 548 } 549 update_fcsr0(env, GETPC()); 550 return fd; 551 } 552 553 uint64_t helper_ftintrm_l_s(CPULoongArchState *env, uint64_t fj) 554 { 555 uint64_t fd; 556 FloatRoundMode old_mode = get_float_rounding_mode(&env->fp_status); 557 558 set_float_rounding_mode(float_round_down, &env->fp_status); 559 fd = float32_to_int64((uint32_t)fj, &env->fp_status); 560 set_float_rounding_mode(old_mode, &env->fp_status); 561 562 if (get_float_exception_flags(&env->fp_status) & (float_flag_invalid)) { 563 if (float32_is_any_nan((uint32_t)fj)) { 564 fd = 0; 565 } 566 } 567 update_fcsr0(env, GETPC()); 568 return fd; 569 } 570 571 uint64_t helper_ftintrm_w_d(CPULoongArchState *env, uint64_t fj) 572 { 573 uint64_t fd; 574 FloatRoundMode old_mode = get_float_rounding_mode(&env->fp_status); 575 576 set_float_rounding_mode(float_round_down, &env->fp_status); 577 fd = (uint64_t)float64_to_int32(fj, &env->fp_status); 578 set_float_rounding_mode(old_mode, &env->fp_status); 579 580 if (get_float_exception_flags(&env->fp_status) & (float_flag_invalid)) { 581 if (float64_is_any_nan(fj)) { 582 fd = 0; 583 } 584 } 585 update_fcsr0(env, GETPC()); 586 return fd; 587 } 588 589 uint64_t helper_ftintrm_w_s(CPULoongArchState *env, uint64_t fj) 590 { 591 uint64_t fd; 592 FloatRoundMode old_mode = get_float_rounding_mode(&env->fp_status); 593 594 set_float_rounding_mode(float_round_down, &env->fp_status); 595 fd = (uint64_t)float32_to_int32((uint32_t)fj, &env->fp_status); 596 set_float_rounding_mode(old_mode, &env->fp_status); 597 598 if (get_float_exception_flags(&env->fp_status) & (float_flag_invalid)) { 599 if (float32_is_any_nan((uint32_t)fj)) { 600 fd = 0; 601 } 602 } 603 update_fcsr0(env, GETPC()); 604 return fd; 605 } 606 607 uint64_t helper_ftintrp_l_d(CPULoongArchState *env, uint64_t fj) 608 { 609 uint64_t fd; 610 FloatRoundMode old_mode = get_float_rounding_mode(&env->fp_status); 611 612 set_float_rounding_mode(float_round_up, &env->fp_status); 613 fd = float64_to_int64(fj, &env->fp_status); 614 set_float_rounding_mode(old_mode, &env->fp_status); 615 616 if (get_float_exception_flags(&env->fp_status) & (float_flag_invalid)) { 617 if (float64_is_any_nan(fj)) { 618 fd = 0; 619 } 620 } 621 update_fcsr0(env, GETPC()); 622 return fd; 623 } 624 625 uint64_t helper_ftintrp_l_s(CPULoongArchState *env, uint64_t fj) 626 { 627 uint64_t fd; 628 FloatRoundMode old_mode = get_float_rounding_mode(&env->fp_status); 629 630 set_float_rounding_mode(float_round_up, &env->fp_status); 631 fd = float32_to_int64((uint32_t)fj, &env->fp_status); 632 set_float_rounding_mode(old_mode, &env->fp_status); 633 634 if (get_float_exception_flags(&env->fp_status) & (float_flag_invalid)) { 635 if (float32_is_any_nan((uint32_t)fj)) { 636 fd = 0; 637 } 638 } 639 update_fcsr0(env, GETPC()); 640 return fd; 641 } 642 643 uint64_t helper_ftintrp_w_d(CPULoongArchState *env, uint64_t fj) 644 { 645 uint64_t fd; 646 FloatRoundMode old_mode = get_float_rounding_mode(&env->fp_status); 647 648 set_float_rounding_mode(float_round_up, &env->fp_status); 649 fd = (uint64_t)float64_to_int32(fj, &env->fp_status); 650 set_float_rounding_mode(old_mode, &env->fp_status); 651 652 if (get_float_exception_flags(&env->fp_status) & (float_flag_invalid)) { 653 if (float64_is_any_nan(fj)) { 654 fd = 0; 655 } 656 } 657 update_fcsr0(env, GETPC()); 658 return fd; 659 } 660 661 uint64_t helper_ftintrp_w_s(CPULoongArchState *env, uint64_t fj) 662 { 663 uint64_t fd; 664 FloatRoundMode old_mode = get_float_rounding_mode(&env->fp_status); 665 666 set_float_rounding_mode(float_round_up, &env->fp_status); 667 fd = (uint64_t)float32_to_int32((uint32_t)fj, &env->fp_status); 668 set_float_rounding_mode(old_mode, &env->fp_status); 669 670 if (get_float_exception_flags(&env->fp_status) & (float_flag_invalid)) { 671 if (float32_is_any_nan((uint32_t)fj)) { 672 fd = 0; 673 } 674 } 675 update_fcsr0(env, GETPC()); 676 return fd; 677 } 678 679 uint64_t helper_ftintrz_l_d(CPULoongArchState *env, uint64_t fj) 680 { 681 uint64_t fd; 682 FloatRoundMode old_mode = get_float_rounding_mode(&env->fp_status); 683 684 fd = float64_to_int64_round_to_zero(fj, &env->fp_status); 685 set_float_rounding_mode(old_mode, &env->fp_status); 686 687 if (get_float_exception_flags(&env->fp_status) & (float_flag_invalid)) { 688 if (float64_is_any_nan(fj)) { 689 fd = 0; 690 } 691 } 692 update_fcsr0(env, GETPC()); 693 return fd; 694 } 695 696 uint64_t helper_ftintrz_l_s(CPULoongArchState *env, uint64_t fj) 697 { 698 uint64_t fd; 699 FloatRoundMode old_mode = get_float_rounding_mode(&env->fp_status); 700 701 fd = float32_to_int64_round_to_zero((uint32_t)fj, &env->fp_status); 702 set_float_rounding_mode(old_mode, &env->fp_status); 703 704 if (get_float_exception_flags(&env->fp_status) & (float_flag_invalid)) { 705 if (float32_is_any_nan((uint32_t)fj)) { 706 fd = 0; 707 } 708 } 709 update_fcsr0(env, GETPC()); 710 return fd; 711 } 712 713 uint64_t helper_ftintrz_w_d(CPULoongArchState *env, uint64_t fj) 714 { 715 uint64_t fd; 716 FloatRoundMode old_mode = get_float_rounding_mode(&env->fp_status); 717 718 fd = (uint64_t)float64_to_int32_round_to_zero(fj, &env->fp_status); 719 set_float_rounding_mode(old_mode, &env->fp_status); 720 721 if (get_float_exception_flags(&env->fp_status) & (float_flag_invalid)) { 722 if (float64_is_any_nan(fj)) { 723 fd = 0; 724 } 725 } 726 update_fcsr0(env, GETPC()); 727 return fd; 728 } 729 730 uint64_t helper_ftintrz_w_s(CPULoongArchState *env, uint64_t fj) 731 { 732 uint32_t fd; 733 FloatRoundMode old_mode = get_float_rounding_mode(&env->fp_status); 734 735 fd = float32_to_int32_round_to_zero((uint32_t)fj, &env->fp_status); 736 set_float_rounding_mode(old_mode, &env->fp_status); 737 738 if (get_float_exception_flags(&env->fp_status) & (float_flag_invalid)) { 739 if (float32_is_any_nan((uint32_t)fj)) { 740 fd = 0; 741 } 742 } 743 update_fcsr0(env, GETPC()); 744 return (uint64_t)fd; 745 } 746 747 uint64_t helper_ftintrne_l_d(CPULoongArchState *env, uint64_t fj) 748 { 749 uint64_t fd; 750 FloatRoundMode old_mode = get_float_rounding_mode(&env->fp_status); 751 752 set_float_rounding_mode(float_round_nearest_even, &env->fp_status); 753 fd = float64_to_int64(fj, &env->fp_status); 754 set_float_rounding_mode(old_mode, &env->fp_status); 755 756 if (get_float_exception_flags(&env->fp_status) & (float_flag_invalid)) { 757 if (float64_is_any_nan(fj)) { 758 fd = 0; 759 } 760 } 761 update_fcsr0(env, GETPC()); 762 return fd; 763 } 764 765 uint64_t helper_ftintrne_l_s(CPULoongArchState *env, uint64_t fj) 766 { 767 uint64_t fd; 768 FloatRoundMode old_mode = get_float_rounding_mode(&env->fp_status); 769 770 set_float_rounding_mode(float_round_nearest_even, &env->fp_status); 771 fd = float32_to_int64((uint32_t)fj, &env->fp_status); 772 set_float_rounding_mode(old_mode, &env->fp_status); 773 774 if (get_float_exception_flags(&env->fp_status) & (float_flag_invalid)) { 775 if (float32_is_any_nan((uint32_t)fj)) { 776 fd = 0; 777 } 778 } 779 update_fcsr0(env, GETPC()); 780 return fd; 781 } 782 783 uint64_t helper_ftintrne_w_d(CPULoongArchState *env, uint64_t fj) 784 { 785 uint64_t fd; 786 FloatRoundMode old_mode = get_float_rounding_mode(&env->fp_status); 787 788 set_float_rounding_mode(float_round_nearest_even, &env->fp_status); 789 fd = (uint64_t)float64_to_int32(fj, &env->fp_status); 790 set_float_rounding_mode(old_mode, &env->fp_status); 791 792 if (get_float_exception_flags(&env->fp_status) & (float_flag_invalid)) { 793 if (float64_is_any_nan(fj)) { 794 fd = 0; 795 } 796 } 797 update_fcsr0(env, GETPC()); 798 return fd; 799 } 800 801 uint64_t helper_ftintrne_w_s(CPULoongArchState *env, uint64_t fj) 802 { 803 uint32_t fd; 804 FloatRoundMode old_mode = get_float_rounding_mode(&env->fp_status); 805 806 set_float_rounding_mode(float_round_nearest_even, &env->fp_status); 807 fd = float32_to_int32((uint32_t)fj, &env->fp_status); 808 set_float_rounding_mode(old_mode, &env->fp_status); 809 810 if (get_float_exception_flags(&env->fp_status) & (float_flag_invalid)) { 811 if (float32_is_any_nan((uint32_t)fj)) { 812 fd = 0; 813 } 814 } 815 update_fcsr0(env, GETPC()); 816 return (uint64_t)fd; 817 } 818 819 uint64_t helper_ftint_l_d(CPULoongArchState *env, uint64_t fj) 820 { 821 uint64_t fd; 822 823 fd = float64_to_int64(fj, &env->fp_status); 824 if (get_float_exception_flags(&env->fp_status) & (float_flag_invalid)) { 825 if (float64_is_any_nan(fj)) { 826 fd = 0; 827 } 828 } 829 update_fcsr0(env, GETPC()); 830 return fd; 831 } 832 833 uint64_t helper_ftint_l_s(CPULoongArchState *env, uint64_t fj) 834 { 835 uint64_t fd; 836 837 fd = float32_to_int64((uint32_t)fj, &env->fp_status); 838 if (get_float_exception_flags(&env->fp_status) & (float_flag_invalid)) { 839 if (float32_is_any_nan((uint32_t)fj)) { 840 fd = 0; 841 } 842 } 843 update_fcsr0(env, GETPC()); 844 return fd; 845 } 846 847 uint64_t helper_ftint_w_s(CPULoongArchState *env, uint64_t fj) 848 { 849 uint64_t fd; 850 851 fd = (uint64_t)float32_to_int32((uint32_t)fj, &env->fp_status); 852 if (get_float_exception_flags(&env->fp_status) & (float_flag_invalid)) { 853 if (float32_is_any_nan((uint32_t)fj)) { 854 fd = 0; 855 } 856 } 857 update_fcsr0(env, GETPC()); 858 return fd; 859 } 860 861 uint64_t helper_ftint_w_d(CPULoongArchState *env, uint64_t fj) 862 { 863 uint64_t fd; 864 865 fd = (uint64_t)float64_to_int32(fj, &env->fp_status); 866 if (get_float_exception_flags(&env->fp_status) & (float_flag_invalid)) { 867 if (float64_is_any_nan(fj)) { 868 fd = 0; 869 } 870 } 871 update_fcsr0(env, GETPC()); 872 return fd; 873 } 874 875 void helper_set_rounding_mode(CPULoongArchState *env) 876 { 877 set_float_rounding_mode(ieee_rm[(env->fcsr0 >> FCSR0_RM) & 0x3], 878 &env->fp_status); 879 }