1 /* 2 * Helpers for floating point instructions. 3 * 4 * Copyright (c) 2007 Jocelyn Mayer 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/exec-all.h" 23 #include "exec/helper-proto.h" 24 #include "fpu/softfloat.h" 25 26 #define FP_STATUS (env->fp_status) 27 28 29 void helper_setroundmode(CPUAlphaState *env, uint32_t val) 30 { 31 set_float_rounding_mode(val, &FP_STATUS); 32 } 33 34 void helper_setflushzero(CPUAlphaState *env, uint32_t val) 35 { 36 set_flush_to_zero(val, &FP_STATUS); 37 } 38 39 #define CONVERT_BIT(X, SRC, DST) \ 40 (SRC > DST ? (X) / (SRC / DST) & (DST) : ((X) & SRC) * (DST / SRC)) 41 42 static uint32_t soft_to_fpcr_exc(CPUAlphaState *env) 43 { 44 uint8_t exc = get_float_exception_flags(&FP_STATUS); 45 uint32_t ret = 0; 46 47 if (unlikely(exc)) { 48 set_float_exception_flags(0, &FP_STATUS); 49 ret |= CONVERT_BIT(exc, float_flag_invalid, FPCR_INV); 50 ret |= CONVERT_BIT(exc, float_flag_divbyzero, FPCR_DZE); 51 ret |= CONVERT_BIT(exc, float_flag_overflow, FPCR_OVF); 52 ret |= CONVERT_BIT(exc, float_flag_underflow, FPCR_UNF); 53 ret |= CONVERT_BIT(exc, float_flag_inexact, FPCR_INE); 54 } 55 56 return ret; 57 } 58 59 static void fp_exc_raise1(CPUAlphaState *env, uintptr_t retaddr, 60 uint32_t exc, uint32_t regno, uint32_t hw_exc) 61 { 62 hw_exc |= CONVERT_BIT(exc, FPCR_INV, EXC_M_INV); 63 hw_exc |= CONVERT_BIT(exc, FPCR_DZE, EXC_M_DZE); 64 hw_exc |= CONVERT_BIT(exc, FPCR_OVF, EXC_M_FOV); 65 hw_exc |= CONVERT_BIT(exc, FPCR_UNF, EXC_M_UNF); 66 hw_exc |= CONVERT_BIT(exc, FPCR_INE, EXC_M_INE); 67 hw_exc |= CONVERT_BIT(exc, FPCR_IOV, EXC_M_IOV); 68 69 arith_excp(env, retaddr, hw_exc, 1ull << regno); 70 } 71 72 /* Raise exceptions for ieee fp insns without software completion. 73 In that case there are no exceptions that don't trap; the mask 74 doesn't apply. */ 75 void helper_fp_exc_raise(CPUAlphaState *env, uint32_t ignore, uint32_t regno) 76 { 77 uint32_t exc = env->error_code; 78 if (exc) { 79 env->fpcr |= exc; 80 exc &= ~ignore; 81 if (exc) { 82 fp_exc_raise1(env, GETPC(), exc, regno, 0); 83 } 84 } 85 } 86 87 /* Raise exceptions for ieee fp insns with software completion. */ 88 void helper_fp_exc_raise_s(CPUAlphaState *env, uint32_t ignore, uint32_t regno) 89 { 90 uint32_t exc = env->error_code & ~ignore; 91 if (exc) { 92 env->fpcr |= exc; 93 exc &= env->fpcr_exc_enable; 94 /* 95 * In system mode, the software handler gets invoked 96 * for any non-ignored exception. 97 * In user mode, the kernel's software handler only 98 * delivers a signal if the exception is enabled. 99 */ 100 #ifdef CONFIG_USER_ONLY 101 if (!exc) { 102 return; 103 } 104 #endif 105 fp_exc_raise1(env, GETPC(), exc, regno, EXC_M_SWC); 106 } 107 } 108 109 /* Input handing without software completion. Trap for all 110 non-finite numbers. */ 111 void helper_ieee_input(CPUAlphaState *env, uint64_t val) 112 { 113 uint32_t exp = (uint32_t)(val >> 52) & 0x7ff; 114 uint64_t frac = val & 0xfffffffffffffull; 115 116 if (exp == 0) { 117 /* Denormals without /S raise an exception. */ 118 if (frac != 0) { 119 arith_excp(env, GETPC(), EXC_M_INV, 0); 120 } 121 } else if (exp == 0x7ff) { 122 /* Infinity or NaN. */ 123 env->fpcr |= FPCR_INV; 124 arith_excp(env, GETPC(), EXC_M_INV, 0); 125 } 126 } 127 128 /* Similar, but does not trap for infinities. Used for comparisons. */ 129 void helper_ieee_input_cmp(CPUAlphaState *env, uint64_t val) 130 { 131 uint32_t exp = (uint32_t)(val >> 52) & 0x7ff; 132 uint64_t frac = val & 0xfffffffffffffull; 133 134 if (exp == 0) { 135 /* Denormals without /S raise an exception. */ 136 if (frac != 0) { 137 arith_excp(env, GETPC(), EXC_M_INV, 0); 138 } 139 } else if (exp == 0x7ff && frac) { 140 /* NaN. */ 141 env->fpcr |= FPCR_INV; 142 arith_excp(env, GETPC(), EXC_M_INV, 0); 143 } 144 } 145 146 /* Input handing with software completion. Trap for denorms, unless DNZ 147 is set. If we try to support DNOD (which none of the produced hardware 148 did, AFAICS), we'll need to suppress the trap when FPCR.DNOD is set; 149 then the code downstream of that will need to cope with denorms sans 150 flush_input_to_zero. Most of it should work sanely, but there's 151 nothing to compare with. */ 152 void helper_ieee_input_s(CPUAlphaState *env, uint64_t val) 153 { 154 if (unlikely(2 * val - 1 < 0x1fffffffffffffull) 155 && !env->fp_status.flush_inputs_to_zero) { 156 arith_excp(env, GETPC(), EXC_M_INV | EXC_M_SWC, 0); 157 } 158 } 159 160 /* S floating (single) */ 161 162 /* Taken from linux/arch/alpha/kernel/traps.c, s_mem_to_reg. */ 163 static inline uint64_t float32_to_s_int(uint32_t fi) 164 { 165 uint32_t frac = fi & 0x7fffff; 166 uint32_t sign = fi >> 31; 167 uint32_t exp_msb = (fi >> 30) & 1; 168 uint32_t exp_low = (fi >> 23) & 0x7f; 169 uint32_t exp; 170 171 exp = (exp_msb << 10) | exp_low; 172 if (exp_msb) { 173 if (exp_low == 0x7f) { 174 exp = 0x7ff; 175 } 176 } else { 177 if (exp_low != 0x00) { 178 exp |= 0x380; 179 } 180 } 181 182 return (((uint64_t)sign << 63) 183 | ((uint64_t)exp << 52) 184 | ((uint64_t)frac << 29)); 185 } 186 187 static inline uint64_t float32_to_s(float32 fa) 188 { 189 CPU_FloatU a; 190 a.f = fa; 191 return float32_to_s_int(a.l); 192 } 193 194 static inline uint32_t s_to_float32_int(uint64_t a) 195 { 196 return ((a >> 32) & 0xc0000000) | ((a >> 29) & 0x3fffffff); 197 } 198 199 static inline float32 s_to_float32(uint64_t a) 200 { 201 CPU_FloatU r; 202 r.l = s_to_float32_int(a); 203 return r.f; 204 } 205 206 uint32_t helper_s_to_memory(uint64_t a) 207 { 208 return s_to_float32_int(a); 209 } 210 211 uint64_t helper_memory_to_s(uint32_t a) 212 { 213 return float32_to_s_int(a); 214 } 215 216 uint64_t helper_adds(CPUAlphaState *env, uint64_t a, uint64_t b) 217 { 218 float32 fa, fb, fr; 219 220 fa = s_to_float32(a); 221 fb = s_to_float32(b); 222 fr = float32_add(fa, fb, &FP_STATUS); 223 env->error_code = soft_to_fpcr_exc(env); 224 225 return float32_to_s(fr); 226 } 227 228 uint64_t helper_subs(CPUAlphaState *env, uint64_t a, uint64_t b) 229 { 230 float32 fa, fb, fr; 231 232 fa = s_to_float32(a); 233 fb = s_to_float32(b); 234 fr = float32_sub(fa, fb, &FP_STATUS); 235 env->error_code = soft_to_fpcr_exc(env); 236 237 return float32_to_s(fr); 238 } 239 240 uint64_t helper_muls(CPUAlphaState *env, uint64_t a, uint64_t b) 241 { 242 float32 fa, fb, fr; 243 244 fa = s_to_float32(a); 245 fb = s_to_float32(b); 246 fr = float32_mul(fa, fb, &FP_STATUS); 247 env->error_code = soft_to_fpcr_exc(env); 248 249 return float32_to_s(fr); 250 } 251 252 uint64_t helper_divs(CPUAlphaState *env, uint64_t a, uint64_t b) 253 { 254 float32 fa, fb, fr; 255 256 fa = s_to_float32(a); 257 fb = s_to_float32(b); 258 fr = float32_div(fa, fb, &FP_STATUS); 259 env->error_code = soft_to_fpcr_exc(env); 260 261 return float32_to_s(fr); 262 } 263 264 uint64_t helper_sqrts(CPUAlphaState *env, uint64_t a) 265 { 266 float32 fa, fr; 267 268 fa = s_to_float32(a); 269 fr = float32_sqrt(fa, &FP_STATUS); 270 env->error_code = soft_to_fpcr_exc(env); 271 272 return float32_to_s(fr); 273 } 274 275 276 /* T floating (double) */ 277 static inline float64 t_to_float64(uint64_t a) 278 { 279 /* Memory format is the same as float64 */ 280 CPU_DoubleU r; 281 r.ll = a; 282 return r.d; 283 } 284 285 static inline uint64_t float64_to_t(float64 fa) 286 { 287 /* Memory format is the same as float64 */ 288 CPU_DoubleU r; 289 r.d = fa; 290 return r.ll; 291 } 292 293 uint64_t helper_addt(CPUAlphaState *env, uint64_t a, uint64_t b) 294 { 295 float64 fa, fb, fr; 296 297 fa = t_to_float64(a); 298 fb = t_to_float64(b); 299 fr = float64_add(fa, fb, &FP_STATUS); 300 env->error_code = soft_to_fpcr_exc(env); 301 302 return float64_to_t(fr); 303 } 304 305 uint64_t helper_subt(CPUAlphaState *env, uint64_t a, uint64_t b) 306 { 307 float64 fa, fb, fr; 308 309 fa = t_to_float64(a); 310 fb = t_to_float64(b); 311 fr = float64_sub(fa, fb, &FP_STATUS); 312 env->error_code = soft_to_fpcr_exc(env); 313 314 return float64_to_t(fr); 315 } 316 317 uint64_t helper_mult(CPUAlphaState *env, uint64_t a, uint64_t b) 318 { 319 float64 fa, fb, fr; 320 321 fa = t_to_float64(a); 322 fb = t_to_float64(b); 323 fr = float64_mul(fa, fb, &FP_STATUS); 324 env->error_code = soft_to_fpcr_exc(env); 325 326 return float64_to_t(fr); 327 } 328 329 uint64_t helper_divt(CPUAlphaState *env, uint64_t a, uint64_t b) 330 { 331 float64 fa, fb, fr; 332 333 fa = t_to_float64(a); 334 fb = t_to_float64(b); 335 fr = float64_div(fa, fb, &FP_STATUS); 336 env->error_code = soft_to_fpcr_exc(env); 337 338 return float64_to_t(fr); 339 } 340 341 uint64_t helper_sqrtt(CPUAlphaState *env, uint64_t a) 342 { 343 float64 fa, fr; 344 345 fa = t_to_float64(a); 346 fr = float64_sqrt(fa, &FP_STATUS); 347 env->error_code = soft_to_fpcr_exc(env); 348 349 return float64_to_t(fr); 350 } 351 352 /* Comparisons */ 353 uint64_t helper_cmptun(CPUAlphaState *env, uint64_t a, uint64_t b) 354 { 355 float64 fa, fb; 356 uint64_t ret = 0; 357 358 fa = t_to_float64(a); 359 fb = t_to_float64(b); 360 361 if (float64_unordered_quiet(fa, fb, &FP_STATUS)) { 362 ret = 0x4000000000000000ULL; 363 } 364 env->error_code = soft_to_fpcr_exc(env); 365 366 return ret; 367 } 368 369 uint64_t helper_cmpteq(CPUAlphaState *env, uint64_t a, uint64_t b) 370 { 371 float64 fa, fb; 372 uint64_t ret = 0; 373 374 fa = t_to_float64(a); 375 fb = t_to_float64(b); 376 377 if (float64_eq_quiet(fa, fb, &FP_STATUS)) { 378 ret = 0x4000000000000000ULL; 379 } 380 env->error_code = soft_to_fpcr_exc(env); 381 382 return ret; 383 } 384 385 uint64_t helper_cmptle(CPUAlphaState *env, uint64_t a, uint64_t b) 386 { 387 float64 fa, fb; 388 uint64_t ret = 0; 389 390 fa = t_to_float64(a); 391 fb = t_to_float64(b); 392 393 if (float64_le(fa, fb, &FP_STATUS)) { 394 ret = 0x4000000000000000ULL; 395 } 396 env->error_code = soft_to_fpcr_exc(env); 397 398 return ret; 399 } 400 401 uint64_t helper_cmptlt(CPUAlphaState *env, uint64_t a, uint64_t b) 402 { 403 float64 fa, fb; 404 uint64_t ret = 0; 405 406 fa = t_to_float64(a); 407 fb = t_to_float64(b); 408 409 if (float64_lt(fa, fb, &FP_STATUS)) { 410 ret = 0x4000000000000000ULL; 411 } 412 env->error_code = soft_to_fpcr_exc(env); 413 414 return ret; 415 } 416 417 /* Floating point format conversion */ 418 uint64_t helper_cvtts(CPUAlphaState *env, uint64_t a) 419 { 420 float64 fa; 421 float32 fr; 422 423 fa = t_to_float64(a); 424 fr = float64_to_float32(fa, &FP_STATUS); 425 env->error_code = soft_to_fpcr_exc(env); 426 427 return float32_to_s(fr); 428 } 429 430 uint64_t helper_cvtst(CPUAlphaState *env, uint64_t a) 431 { 432 float32 fa; 433 float64 fr; 434 435 fa = s_to_float32(a); 436 fr = float32_to_float64(fa, &FP_STATUS); 437 env->error_code = soft_to_fpcr_exc(env); 438 439 return float64_to_t(fr); 440 } 441 442 uint64_t helper_cvtqs(CPUAlphaState *env, uint64_t a) 443 { 444 float32 fr = int64_to_float32(a, &FP_STATUS); 445 env->error_code = soft_to_fpcr_exc(env); 446 447 return float32_to_s(fr); 448 } 449 450 /* Implement float64 to uint64_t conversion without saturation -- we must 451 supply the truncated result. This behaviour is used by the compiler 452 to get unsigned conversion for free with the same instruction. */ 453 454 static uint64_t do_cvttq(CPUAlphaState *env, uint64_t a, int roundmode) 455 { 456 uint64_t frac, ret = 0; 457 uint32_t exp, sign, exc = 0; 458 int shift; 459 460 sign = (a >> 63); 461 exp = (uint32_t)(a >> 52) & 0x7ff; 462 frac = a & 0xfffffffffffffull; 463 464 if (exp == 0) { 465 if (unlikely(frac != 0) && !env->fp_status.flush_inputs_to_zero) { 466 goto do_underflow; 467 } 468 } else if (exp == 0x7ff) { 469 exc = FPCR_INV; 470 } else { 471 /* Restore implicit bit. */ 472 frac |= 0x10000000000000ull; 473 474 shift = exp - 1023 - 52; 475 if (shift >= 0) { 476 /* In this case the number is so large that we must shift 477 the fraction left. There is no rounding to do. */ 478 if (shift < 64) { 479 ret = frac << shift; 480 } 481 /* Check for overflow. Note the special case of -0x1p63. */ 482 if (shift >= 11 && a != 0xC3E0000000000000ull) { 483 exc = FPCR_IOV | FPCR_INE; 484 } 485 } else { 486 uint64_t round; 487 488 /* In this case the number is smaller than the fraction as 489 represented by the 52 bit number. Here we must think 490 about rounding the result. Handle this by shifting the 491 fractional part of the number into the high bits of ROUND. 492 This will let us efficiently handle round-to-nearest. */ 493 shift = -shift; 494 if (shift < 63) { 495 ret = frac >> shift; 496 round = frac << (64 - shift); 497 } else { 498 /* The exponent is so small we shift out everything. 499 Leave a sticky bit for proper rounding below. */ 500 do_underflow: 501 round = 1; 502 } 503 504 if (round) { 505 exc = FPCR_INE; 506 switch (roundmode) { 507 case float_round_nearest_even: 508 if (round == (1ull << 63)) { 509 /* Fraction is exactly 0.5; round to even. */ 510 ret += (ret & 1); 511 } else if (round > (1ull << 63)) { 512 ret += 1; 513 } 514 break; 515 case float_round_to_zero: 516 break; 517 case float_round_up: 518 ret += 1 - sign; 519 break; 520 case float_round_down: 521 ret += sign; 522 break; 523 } 524 } 525 } 526 if (sign) { 527 ret = -ret; 528 } 529 } 530 env->error_code = exc; 531 532 return ret; 533 } 534 535 uint64_t helper_cvttq(CPUAlphaState *env, uint64_t a) 536 { 537 return do_cvttq(env, a, FP_STATUS.float_rounding_mode); 538 } 539 540 uint64_t helper_cvttq_c(CPUAlphaState *env, uint64_t a) 541 { 542 return do_cvttq(env, a, float_round_to_zero); 543 } 544 545 uint64_t helper_cvtqt(CPUAlphaState *env, uint64_t a) 546 { 547 float64 fr = int64_to_float64(a, &FP_STATUS); 548 env->error_code = soft_to_fpcr_exc(env); 549 return float64_to_t(fr); 550 } 551 552 uint64_t helper_cvtql(CPUAlphaState *env, uint64_t val) 553 { 554 uint32_t exc = 0; 555 if (val != (int32_t)val) { 556 exc = FPCR_IOV | FPCR_INE; 557 } 558 env->error_code = exc; 559 560 return ((val & 0xc0000000) << 32) | ((val & 0x3fffffff) << 29); 561 } 562