1 /* 2 * m68k FPU helpers 3 * 4 * Copyright (c) 2006-2007 CodeSourcery 5 * Written by Paul Brook 6 * 7 * This library is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU Lesser General Public 9 * License as published by the Free Software Foundation; either 10 * version 2.1 of the License, or (at your option) any later version. 11 * 12 * This library is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 * Lesser General Public License for more details. 16 * 17 * You should have received a copy of the GNU Lesser General Public 18 * License along with this library; if not, see <http://www.gnu.org/licenses/>. 19 */ 20 21 #include "qemu/osdep.h" 22 #include "cpu.h" 23 #include "exec/helper-proto.h" 24 #include "accel/tcg/cpu-ldst.h" 25 #include "softfloat.h" 26 27 /* 28 * Undefined offsets may be different on various FPU. 29 * On 68040 they return 0.0 (floatx80_zero) 30 */ 31 32 static const floatx80 fpu_rom[128] = { 33 [0x00] = make_floatx80_init(0x4000, 0xc90fdaa22168c235ULL), /* Pi */ 34 [0x0b] = make_floatx80_init(0x3ffd, 0x9a209a84fbcff798ULL), /* Log10(2) */ 35 [0x0c] = make_floatx80_init(0x4000, 0xadf85458a2bb4a9aULL), /* e */ 36 [0x0d] = make_floatx80_init(0x3fff, 0xb8aa3b295c17f0bcULL), /* Log2(e) */ 37 [0x0e] = make_floatx80_init(0x3ffd, 0xde5bd8a937287195ULL), /* Log10(e) */ 38 [0x0f] = make_floatx80_init(0x0000, 0x0000000000000000ULL), /* Zero */ 39 [0x30] = make_floatx80_init(0x3ffe, 0xb17217f7d1cf79acULL), /* ln(2) */ 40 [0x31] = make_floatx80_init(0x4000, 0x935d8dddaaa8ac17ULL), /* ln(10) */ 41 [0x32] = make_floatx80_init(0x3fff, 0x8000000000000000ULL), /* 10^0 */ 42 [0x33] = make_floatx80_init(0x4002, 0xa000000000000000ULL), /* 10^1 */ 43 [0x34] = make_floatx80_init(0x4005, 0xc800000000000000ULL), /* 10^2 */ 44 [0x35] = make_floatx80_init(0x400c, 0x9c40000000000000ULL), /* 10^4 */ 45 [0x36] = make_floatx80_init(0x4019, 0xbebc200000000000ULL), /* 10^8 */ 46 [0x37] = make_floatx80_init(0x4034, 0x8e1bc9bf04000000ULL), /* 10^16 */ 47 [0x38] = make_floatx80_init(0x4069, 0x9dc5ada82b70b59eULL), /* 10^32 */ 48 [0x39] = make_floatx80_init(0x40d3, 0xc2781f49ffcfa6d5ULL), /* 10^64 */ 49 [0x3a] = make_floatx80_init(0x41a8, 0x93ba47c980e98ce0ULL), /* 10^128 */ 50 [0x3b] = make_floatx80_init(0x4351, 0xaa7eebfb9df9de8eULL), /* 10^256 */ 51 [0x3c] = make_floatx80_init(0x46a3, 0xe319a0aea60e91c7ULL), /* 10^512 */ 52 [0x3d] = make_floatx80_init(0x4d48, 0xc976758681750c17ULL), /* 10^1024 */ 53 [0x3e] = make_floatx80_init(0x5a92, 0x9e8b3b5dc53d5de5ULL), /* 10^2048 */ 54 [0x3f] = make_floatx80_init(0x7525, 0xc46052028a20979bULL), /* 10^4096 */ 55 }; 56 57 int32_t HELPER(reds32)(CPUM68KState *env, FPReg *val) 58 { 59 return floatx80_to_int32(val->d, &env->fp_status); 60 } 61 62 float32 HELPER(redf32)(CPUM68KState *env, FPReg *val) 63 { 64 return floatx80_to_float32(val->d, &env->fp_status); 65 } 66 67 void HELPER(exts32)(CPUM68KState *env, FPReg *res, int32_t val) 68 { 69 res->d = int32_to_floatx80(val, &env->fp_status); 70 } 71 72 void HELPER(extf32)(CPUM68KState *env, FPReg *res, float32 val) 73 { 74 res->d = float32_to_floatx80(val, &env->fp_status); 75 } 76 77 void HELPER(extf64)(CPUM68KState *env, FPReg *res, float64 val) 78 { 79 res->d = float64_to_floatx80(val, &env->fp_status); 80 } 81 82 float64 HELPER(redf64)(CPUM68KState *env, FPReg *val) 83 { 84 return floatx80_to_float64(val->d, &env->fp_status); 85 } 86 87 void HELPER(firound)(CPUM68KState *env, FPReg *res, FPReg *val) 88 { 89 res->d = floatx80_round_to_int(val->d, &env->fp_status); 90 } 91 92 static void m68k_restore_precision_mode(CPUM68KState *env) 93 { 94 switch (env->fpcr & FPCR_PREC_MASK) { 95 case FPCR_PREC_X: /* extended */ 96 set_floatx80_rounding_precision(floatx80_precision_x, &env->fp_status); 97 break; 98 case FPCR_PREC_S: /* single */ 99 set_floatx80_rounding_precision(floatx80_precision_s, &env->fp_status); 100 break; 101 case FPCR_PREC_D: /* double */ 102 set_floatx80_rounding_precision(floatx80_precision_d, &env->fp_status); 103 break; 104 case FPCR_PREC_U: /* undefined */ 105 default: 106 break; 107 } 108 } 109 110 static void cf_restore_precision_mode(CPUM68KState *env) 111 { 112 if (env->fpcr & FPCR_PREC_S) { /* single */ 113 set_floatx80_rounding_precision(floatx80_precision_s, &env->fp_status); 114 } else { /* double */ 115 set_floatx80_rounding_precision(floatx80_precision_d, &env->fp_status); 116 } 117 } 118 119 static void restore_rounding_mode(CPUM68KState *env) 120 { 121 switch (env->fpcr & FPCR_RND_MASK) { 122 case FPCR_RND_N: /* round to nearest */ 123 set_float_rounding_mode(float_round_nearest_even, &env->fp_status); 124 break; 125 case FPCR_RND_Z: /* round to zero */ 126 set_float_rounding_mode(float_round_to_zero, &env->fp_status); 127 break; 128 case FPCR_RND_M: /* round toward minus infinity */ 129 set_float_rounding_mode(float_round_down, &env->fp_status); 130 break; 131 case FPCR_RND_P: /* round toward positive infinity */ 132 set_float_rounding_mode(float_round_up, &env->fp_status); 133 break; 134 } 135 } 136 137 void cpu_m68k_restore_fp_status(CPUM68KState *env) 138 { 139 if (m68k_feature(env, M68K_FEATURE_CF_FPU)) { 140 cf_restore_precision_mode(env); 141 } else { 142 m68k_restore_precision_mode(env); 143 } 144 restore_rounding_mode(env); 145 } 146 147 void cpu_m68k_set_fpcr(CPUM68KState *env, uint32_t val) 148 { 149 env->fpcr = val & 0xffff; 150 cpu_m68k_restore_fp_status(env); 151 } 152 153 void HELPER(fitrunc)(CPUM68KState *env, FPReg *res, FPReg *val) 154 { 155 FloatRoundMode rounding_mode = get_float_rounding_mode(&env->fp_status); 156 set_float_rounding_mode(float_round_to_zero, &env->fp_status); 157 res->d = floatx80_round_to_int(val->d, &env->fp_status); 158 set_float_rounding_mode(rounding_mode, &env->fp_status); 159 } 160 161 void HELPER(set_fpcr)(CPUM68KState *env, uint32_t val) 162 { 163 cpu_m68k_set_fpcr(env, val); 164 } 165 166 /* Convert host exception flags to cpu_m68k form. */ 167 static int cpu_m68k_exceptbits_from_host(int host_bits) 168 { 169 int target_bits = 0; 170 171 if (host_bits & float_flag_invalid) { 172 target_bits |= 0x80; 173 } 174 if (host_bits & float_flag_overflow) { 175 target_bits |= 0x40; 176 } 177 if (host_bits & (float_flag_underflow | float_flag_output_denormal_flushed)) { 178 target_bits |= 0x20; 179 } 180 if (host_bits & float_flag_divbyzero) { 181 target_bits |= 0x10; 182 } 183 if (host_bits & float_flag_inexact) { 184 target_bits |= 0x08; 185 } 186 return target_bits; 187 } 188 189 /* Convert cpu_m68k exception flags to target form. */ 190 static int cpu_m68k_exceptbits_to_host(int target_bits) 191 { 192 int host_bits = 0; 193 194 if (target_bits & 0x80) { 195 host_bits |= float_flag_invalid; 196 } 197 if (target_bits & 0x40) { 198 host_bits |= float_flag_overflow; 199 } 200 if (target_bits & 0x20) { 201 host_bits |= float_flag_underflow; 202 } 203 if (target_bits & 0x10) { 204 host_bits |= float_flag_divbyzero; 205 } 206 if (target_bits & 0x08) { 207 host_bits |= float_flag_inexact; 208 } 209 return host_bits; 210 } 211 212 uint32_t cpu_m68k_get_fpsr(CPUM68KState *env) 213 { 214 int host_flags = get_float_exception_flags(&env->fp_status); 215 int target_flags = cpu_m68k_exceptbits_from_host(host_flags); 216 int except = (env->fpsr & ~(0xf8)) | target_flags; 217 return except; 218 } 219 220 uint32_t HELPER(get_fpsr)(CPUM68KState *env) 221 { 222 return cpu_m68k_get_fpsr(env); 223 } 224 225 void cpu_m68k_set_fpsr(CPUM68KState *env, uint32_t val) 226 { 227 env->fpsr = val; 228 229 int host_flags = cpu_m68k_exceptbits_to_host((int) env->fpsr); 230 set_float_exception_flags(host_flags, &env->fp_status); 231 } 232 233 void HELPER(set_fpsr)(CPUM68KState *env, uint32_t val) 234 { 235 cpu_m68k_set_fpsr(env, val); 236 } 237 238 #define PREC_BEGIN(prec) \ 239 do { \ 240 FloatX80RoundPrec old = \ 241 get_floatx80_rounding_precision(&env->fp_status); \ 242 set_floatx80_rounding_precision(prec, &env->fp_status) \ 243 244 #define PREC_END() \ 245 set_floatx80_rounding_precision(old, &env->fp_status); \ 246 } while (0) 247 248 void HELPER(fsround)(CPUM68KState *env, FPReg *res, FPReg *val) 249 { 250 PREC_BEGIN(floatx80_precision_s); 251 res->d = floatx80_round(val->d, &env->fp_status); 252 PREC_END(); 253 } 254 255 void HELPER(fdround)(CPUM68KState *env, FPReg *res, FPReg *val) 256 { 257 PREC_BEGIN(floatx80_precision_d); 258 res->d = floatx80_round(val->d, &env->fp_status); 259 PREC_END(); 260 } 261 262 void HELPER(fsqrt)(CPUM68KState *env, FPReg *res, FPReg *val) 263 { 264 res->d = floatx80_sqrt(val->d, &env->fp_status); 265 } 266 267 void HELPER(fssqrt)(CPUM68KState *env, FPReg *res, FPReg *val) 268 { 269 PREC_BEGIN(floatx80_precision_s); 270 res->d = floatx80_sqrt(val->d, &env->fp_status); 271 PREC_END(); 272 } 273 274 void HELPER(fdsqrt)(CPUM68KState *env, FPReg *res, FPReg *val) 275 { 276 PREC_BEGIN(floatx80_precision_d); 277 res->d = floatx80_sqrt(val->d, &env->fp_status); 278 PREC_END(); 279 } 280 281 void HELPER(fabs)(CPUM68KState *env, FPReg *res, FPReg *val) 282 { 283 res->d = floatx80_round(floatx80_abs(val->d), &env->fp_status); 284 } 285 286 void HELPER(fsabs)(CPUM68KState *env, FPReg *res, FPReg *val) 287 { 288 PREC_BEGIN(floatx80_precision_s); 289 res->d = floatx80_round(floatx80_abs(val->d), &env->fp_status); 290 PREC_END(); 291 } 292 293 void HELPER(fdabs)(CPUM68KState *env, FPReg *res, FPReg *val) 294 { 295 PREC_BEGIN(floatx80_precision_d); 296 res->d = floatx80_round(floatx80_abs(val->d), &env->fp_status); 297 PREC_END(); 298 } 299 300 void HELPER(fneg)(CPUM68KState *env, FPReg *res, FPReg *val) 301 { 302 res->d = floatx80_round(floatx80_chs(val->d), &env->fp_status); 303 } 304 305 void HELPER(fsneg)(CPUM68KState *env, FPReg *res, FPReg *val) 306 { 307 PREC_BEGIN(floatx80_precision_s); 308 res->d = floatx80_round(floatx80_chs(val->d), &env->fp_status); 309 PREC_END(); 310 } 311 312 void HELPER(fdneg)(CPUM68KState *env, FPReg *res, FPReg *val) 313 { 314 PREC_BEGIN(floatx80_precision_d); 315 res->d = floatx80_round(floatx80_chs(val->d), &env->fp_status); 316 PREC_END(); 317 } 318 319 void HELPER(fadd)(CPUM68KState *env, FPReg *res, FPReg *val0, FPReg *val1) 320 { 321 res->d = floatx80_add(val0->d, val1->d, &env->fp_status); 322 } 323 324 void HELPER(fsadd)(CPUM68KState *env, FPReg *res, FPReg *val0, FPReg *val1) 325 { 326 PREC_BEGIN(floatx80_precision_s); 327 res->d = floatx80_add(val0->d, val1->d, &env->fp_status); 328 PREC_END(); 329 } 330 331 void HELPER(fdadd)(CPUM68KState *env, FPReg *res, FPReg *val0, FPReg *val1) 332 { 333 PREC_BEGIN(floatx80_precision_d); 334 res->d = floatx80_add(val0->d, val1->d, &env->fp_status); 335 PREC_END(); 336 } 337 338 void HELPER(fsub)(CPUM68KState *env, FPReg *res, FPReg *val0, FPReg *val1) 339 { 340 res->d = floatx80_sub(val1->d, val0->d, &env->fp_status); 341 } 342 343 void HELPER(fssub)(CPUM68KState *env, FPReg *res, FPReg *val0, FPReg *val1) 344 { 345 PREC_BEGIN(floatx80_precision_s); 346 res->d = floatx80_sub(val1->d, val0->d, &env->fp_status); 347 PREC_END(); 348 } 349 350 void HELPER(fdsub)(CPUM68KState *env, FPReg *res, FPReg *val0, FPReg *val1) 351 { 352 PREC_BEGIN(floatx80_precision_d); 353 res->d = floatx80_sub(val1->d, val0->d, &env->fp_status); 354 PREC_END(); 355 } 356 357 void HELPER(fmul)(CPUM68KState *env, FPReg *res, FPReg *val0, FPReg *val1) 358 { 359 res->d = floatx80_mul(val0->d, val1->d, &env->fp_status); 360 } 361 362 void HELPER(fsmul)(CPUM68KState *env, FPReg *res, FPReg *val0, FPReg *val1) 363 { 364 PREC_BEGIN(floatx80_precision_s); 365 res->d = floatx80_mul(val0->d, val1->d, &env->fp_status); 366 PREC_END(); 367 } 368 369 void HELPER(fdmul)(CPUM68KState *env, FPReg *res, FPReg *val0, FPReg *val1) 370 { 371 PREC_BEGIN(floatx80_precision_d); 372 res->d = floatx80_mul(val0->d, val1->d, &env->fp_status); 373 PREC_END(); 374 } 375 376 void HELPER(fsglmul)(CPUM68KState *env, FPReg *res, FPReg *val0, FPReg *val1) 377 { 378 FloatRoundMode rounding_mode = get_float_rounding_mode(&env->fp_status); 379 floatx80 a, b; 380 381 PREC_BEGIN(floatx80_precision_s); 382 set_float_rounding_mode(float_round_to_zero, &env->fp_status); 383 a = floatx80_round(val0->d, &env->fp_status); 384 b = floatx80_round(val1->d, &env->fp_status); 385 set_float_rounding_mode(rounding_mode, &env->fp_status); 386 res->d = floatx80_mul(a, b, &env->fp_status); 387 PREC_END(); 388 } 389 390 void HELPER(fdiv)(CPUM68KState *env, FPReg *res, FPReg *val0, FPReg *val1) 391 { 392 res->d = floatx80_div(val1->d, val0->d, &env->fp_status); 393 } 394 395 void HELPER(fsdiv)(CPUM68KState *env, FPReg *res, FPReg *val0, FPReg *val1) 396 { 397 PREC_BEGIN(floatx80_precision_s); 398 res->d = floatx80_div(val1->d, val0->d, &env->fp_status); 399 PREC_END(); 400 } 401 402 void HELPER(fddiv)(CPUM68KState *env, FPReg *res, FPReg *val0, FPReg *val1) 403 { 404 PREC_BEGIN(floatx80_precision_d); 405 res->d = floatx80_div(val1->d, val0->d, &env->fp_status); 406 PREC_END(); 407 } 408 409 void HELPER(fsgldiv)(CPUM68KState *env, FPReg *res, FPReg *val0, FPReg *val1) 410 { 411 FloatRoundMode rounding_mode = get_float_rounding_mode(&env->fp_status); 412 floatx80 a, b; 413 414 PREC_BEGIN(floatx80_precision_s); 415 set_float_rounding_mode(float_round_to_zero, &env->fp_status); 416 a = floatx80_round(val1->d, &env->fp_status); 417 b = floatx80_round(val0->d, &env->fp_status); 418 set_float_rounding_mode(rounding_mode, &env->fp_status); 419 res->d = floatx80_div(a, b, &env->fp_status); 420 PREC_END(); 421 } 422 423 static int float_comp_to_cc(FloatRelation float_compare) 424 { 425 switch (float_compare) { 426 case float_relation_equal: 427 return FPSR_CC_Z; 428 case float_relation_less: 429 return FPSR_CC_N; 430 case float_relation_unordered: 431 return FPSR_CC_A; 432 case float_relation_greater: 433 return 0; 434 default: 435 g_assert_not_reached(); 436 } 437 } 438 439 void HELPER(fcmp)(CPUM68KState *env, FPReg *val0, FPReg *val1) 440 { 441 FloatRelation float_compare; 442 443 float_compare = floatx80_compare(val1->d, val0->d, &env->fp_status); 444 env->fpsr = (env->fpsr & ~FPSR_CC_MASK) | float_comp_to_cc(float_compare); 445 } 446 447 void HELPER(ftst)(CPUM68KState *env, FPReg *val) 448 { 449 uint32_t cc = 0; 450 451 if (floatx80_is_neg(val->d)) { 452 cc |= FPSR_CC_N; 453 } 454 455 if (floatx80_is_any_nan(val->d)) { 456 cc |= FPSR_CC_A; 457 } else if (floatx80_is_infinity(val->d, &env->fp_status)) { 458 cc |= FPSR_CC_I; 459 } else if (floatx80_is_zero(val->d)) { 460 cc |= FPSR_CC_Z; 461 } 462 env->fpsr = (env->fpsr & ~FPSR_CC_MASK) | cc; 463 } 464 465 void HELPER(fconst)(CPUM68KState *env, FPReg *val, uint32_t offset) 466 { 467 val->d = fpu_rom[offset]; 468 } 469 470 typedef int (*float_access)(CPUM68KState *env, uint32_t addr, FPReg *fp, 471 uintptr_t ra); 472 473 static uint32_t fmovem_predec(CPUM68KState *env, uint32_t addr, uint32_t mask, 474 float_access access_fn) 475 { 476 uintptr_t ra = GETPC(); 477 int i, size; 478 479 for (i = 7; i >= 0; i--, mask <<= 1) { 480 if (mask & 0x80) { 481 size = access_fn(env, addr, &env->fregs[i], ra); 482 if ((mask & 0xff) != 0x80) { 483 addr -= size; 484 } 485 } 486 } 487 488 return addr; 489 } 490 491 static uint32_t fmovem_postinc(CPUM68KState *env, uint32_t addr, uint32_t mask, 492 float_access access_fn) 493 { 494 uintptr_t ra = GETPC(); 495 int i, size; 496 497 for (i = 0; i < 8; i++, mask <<= 1) { 498 if (mask & 0x80) { 499 size = access_fn(env, addr, &env->fregs[i], ra); 500 addr += size; 501 } 502 } 503 504 return addr; 505 } 506 507 static int cpu_ld_floatx80_ra(CPUM68KState *env, uint32_t addr, FPReg *fp, 508 uintptr_t ra) 509 { 510 uint32_t high; 511 uint64_t low; 512 513 high = cpu_ldl_data_ra(env, addr, ra); 514 low = cpu_ldq_data_ra(env, addr + 4, ra); 515 516 fp->l.upper = high >> 16; 517 fp->l.lower = low; 518 519 return 12; 520 } 521 522 static int cpu_st_floatx80_ra(CPUM68KState *env, uint32_t addr, FPReg *fp, 523 uintptr_t ra) 524 { 525 cpu_stl_data_ra(env, addr, fp->l.upper << 16, ra); 526 cpu_stq_data_ra(env, addr + 4, fp->l.lower, ra); 527 528 return 12; 529 } 530 531 static int cpu_ld_float64_ra(CPUM68KState *env, uint32_t addr, FPReg *fp, 532 uintptr_t ra) 533 { 534 uint64_t val; 535 536 val = cpu_ldq_data_ra(env, addr, ra); 537 fp->d = float64_to_floatx80(*(float64 *)&val, &env->fp_status); 538 539 return 8; 540 } 541 542 static int cpu_st_float64_ra(CPUM68KState *env, uint32_t addr, FPReg *fp, 543 uintptr_t ra) 544 { 545 float64 val; 546 547 val = floatx80_to_float64(fp->d, &env->fp_status); 548 cpu_stq_data_ra(env, addr, *(uint64_t *)&val, ra); 549 550 return 8; 551 } 552 553 uint32_t HELPER(fmovemx_st_predec)(CPUM68KState *env, uint32_t addr, 554 uint32_t mask) 555 { 556 return fmovem_predec(env, addr, mask, cpu_st_floatx80_ra); 557 } 558 559 uint32_t HELPER(fmovemx_st_postinc)(CPUM68KState *env, uint32_t addr, 560 uint32_t mask) 561 { 562 return fmovem_postinc(env, addr, mask, cpu_st_floatx80_ra); 563 } 564 565 uint32_t HELPER(fmovemx_ld_postinc)(CPUM68KState *env, uint32_t addr, 566 uint32_t mask) 567 { 568 return fmovem_postinc(env, addr, mask, cpu_ld_floatx80_ra); 569 } 570 571 uint32_t HELPER(fmovemd_st_predec)(CPUM68KState *env, uint32_t addr, 572 uint32_t mask) 573 { 574 return fmovem_predec(env, addr, mask, cpu_st_float64_ra); 575 } 576 577 uint32_t HELPER(fmovemd_st_postinc)(CPUM68KState *env, uint32_t addr, 578 uint32_t mask) 579 { 580 return fmovem_postinc(env, addr, mask, cpu_st_float64_ra); 581 } 582 583 uint32_t HELPER(fmovemd_ld_postinc)(CPUM68KState *env, uint32_t addr, 584 uint32_t mask) 585 { 586 return fmovem_postinc(env, addr, mask, cpu_ld_float64_ra); 587 } 588 589 static void make_quotient(CPUM68KState *env, int sign, uint32_t quotient) 590 { 591 quotient = (sign << 7) | (quotient & 0x7f); 592 env->fpsr = (env->fpsr & ~FPSR_QT_MASK) | (quotient << FPSR_QT_SHIFT); 593 } 594 595 void HELPER(fmod)(CPUM68KState *env, FPReg *res, FPReg *val0, FPReg *val1) 596 { 597 uint64_t quotient; 598 int sign = extractFloatx80Sign(val1->d) ^ extractFloatx80Sign(val0->d); 599 600 res->d = floatx80_modrem(val1->d, val0->d, true, "ient, 601 &env->fp_status); 602 603 if (floatx80_is_any_nan(res->d)) { 604 return; 605 } 606 607 make_quotient(env, sign, quotient); 608 } 609 610 void HELPER(frem)(CPUM68KState *env, FPReg *res, FPReg *val0, FPReg *val1) 611 { 612 FPReg fp_quot; 613 floatx80 fp_rem; 614 615 fp_rem = floatx80_rem(val1->d, val0->d, &env->fp_status); 616 if (!floatx80_is_any_nan(fp_rem)) { 617 /* Use local temporary fp_status to set different rounding mode */ 618 float_status fp_status = env->fp_status; 619 uint32_t quotient; 620 int sign; 621 622 /* Calculate quotient directly using round to nearest mode */ 623 set_float_rounding_mode(float_round_nearest_even, &fp_status); 624 fp_quot.d = floatx80_div(val1->d, val0->d, &fp_status); 625 626 sign = extractFloatx80Sign(fp_quot.d); 627 quotient = floatx80_to_int32(floatx80_abs(fp_quot.d), &env->fp_status); 628 make_quotient(env, sign, quotient); 629 } 630 631 res->d = fp_rem; 632 } 633 634 void HELPER(fgetexp)(CPUM68KState *env, FPReg *res, FPReg *val) 635 { 636 res->d = floatx80_getexp(val->d, &env->fp_status); 637 } 638 639 void HELPER(fgetman)(CPUM68KState *env, FPReg *res, FPReg *val) 640 { 641 res->d = floatx80_getman(val->d, &env->fp_status); 642 } 643 644 void HELPER(fscale)(CPUM68KState *env, FPReg *res, FPReg *val0, FPReg *val1) 645 { 646 res->d = floatx80_scale(val1->d, val0->d, &env->fp_status); 647 } 648 649 void HELPER(flognp1)(CPUM68KState *env, FPReg *res, FPReg *val) 650 { 651 res->d = floatx80_lognp1(val->d, &env->fp_status); 652 } 653 654 void HELPER(flogn)(CPUM68KState *env, FPReg *res, FPReg *val) 655 { 656 res->d = floatx80_logn(val->d, &env->fp_status); 657 } 658 659 void HELPER(flog10)(CPUM68KState *env, FPReg *res, FPReg *val) 660 { 661 res->d = floatx80_log10(val->d, &env->fp_status); 662 } 663 664 void HELPER(flog2)(CPUM68KState *env, FPReg *res, FPReg *val) 665 { 666 res->d = floatx80_log2(val->d, &env->fp_status); 667 } 668 669 void HELPER(fetox)(CPUM68KState *env, FPReg *res, FPReg *val) 670 { 671 res->d = floatx80_etox(val->d, &env->fp_status); 672 } 673 674 void HELPER(ftwotox)(CPUM68KState *env, FPReg *res, FPReg *val) 675 { 676 res->d = floatx80_twotox(val->d, &env->fp_status); 677 } 678 679 void HELPER(ftentox)(CPUM68KState *env, FPReg *res, FPReg *val) 680 { 681 res->d = floatx80_tentox(val->d, &env->fp_status); 682 } 683 684 void HELPER(ftan)(CPUM68KState *env, FPReg *res, FPReg *val) 685 { 686 res->d = floatx80_tan(val->d, &env->fp_status); 687 } 688 689 void HELPER(fsin)(CPUM68KState *env, FPReg *res, FPReg *val) 690 { 691 res->d = floatx80_sin(val->d, &env->fp_status); 692 } 693 694 void HELPER(fcos)(CPUM68KState *env, FPReg *res, FPReg *val) 695 { 696 res->d = floatx80_cos(val->d, &env->fp_status); 697 } 698 699 void HELPER(fsincos)(CPUM68KState *env, FPReg *res0, FPReg *res1, FPReg *val) 700 { 701 floatx80 a = val->d; 702 /* 703 * If res0 and res1 specify the same floating-point data register, 704 * the sine result is stored in the register, and the cosine 705 * result is discarded. 706 */ 707 res1->d = floatx80_cos(a, &env->fp_status); 708 res0->d = floatx80_sin(a, &env->fp_status); 709 } 710 711 void HELPER(fatan)(CPUM68KState *env, FPReg *res, FPReg *val) 712 { 713 res->d = floatx80_atan(val->d, &env->fp_status); 714 } 715 716 void HELPER(fasin)(CPUM68KState *env, FPReg *res, FPReg *val) 717 { 718 res->d = floatx80_asin(val->d, &env->fp_status); 719 } 720 721 void HELPER(facos)(CPUM68KState *env, FPReg *res, FPReg *val) 722 { 723 res->d = floatx80_acos(val->d, &env->fp_status); 724 } 725 726 void HELPER(fatanh)(CPUM68KState *env, FPReg *res, FPReg *val) 727 { 728 res->d = floatx80_atanh(val->d, &env->fp_status); 729 } 730 731 void HELPER(fetoxm1)(CPUM68KState *env, FPReg *res, FPReg *val) 732 { 733 res->d = floatx80_etoxm1(val->d, &env->fp_status); 734 } 735 736 void HELPER(ftanh)(CPUM68KState *env, FPReg *res, FPReg *val) 737 { 738 res->d = floatx80_tanh(val->d, &env->fp_status); 739 } 740 741 void HELPER(fsinh)(CPUM68KState *env, FPReg *res, FPReg *val) 742 { 743 res->d = floatx80_sinh(val->d, &env->fp_status); 744 } 745 746 void HELPER(fcosh)(CPUM68KState *env, FPReg *res, FPReg *val) 747 { 748 res->d = floatx80_cosh(val->d, &env->fp_status); 749 } 750