target-s390x/fpu_helper.c

   1 /*
   2  *  S/390 FPU helper routines
   3  *
   4  *  Copyright (c) 2009 Ulrich Hecht
   5  *  Copyright (c) 2009 Alexander Graf
   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 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 "cpu.h"
  22 #include "helper.h"
  23
  24 #if !defined(CONFIG_USER_ONLY)
  25 #include "exec/softmmu_exec.h"
  26 #endif
  27
  28 /* #define DEBUG_HELPER */
  29 #ifdef DEBUG_HELPER
  30 #define HELPER_LOG(x...) qemu_log(x)
  31 #else
  32 #define HELPER_LOG(x...)
  33 #endif
  34
  35 #define RET128(F) (env->retxl = F.low, F.high)
  36
  37 #define convert_bit(mask, from, to) \
  38     (to < from                      \
  39      ? (mask / (from / to)) & to    \
  40      : (mask & from) * (to / from))
  41
  42 static void ieee_exception(CPUS390XState *env, uint32_t dxc, uintptr_t retaddr)
  43 {
  44     /* Install the DXC code.  */
  45     env->fpc = (env->fpc & ~0xff00) | (dxc << 8);
  46     /* Trap.  */
  47     runtime_exception(env, PGM_DATA, retaddr);
  48 }
  49
  50 /* Should be called after any operation that may raise IEEE exceptions.  */
  51 static void handle_exceptions(CPUS390XState *env, uintptr_t retaddr)
  52 {
  53     unsigned s390_exc, qemu_exc;
  54
  55     /* Get the exceptions raised by the current operation.  Reset the
  56        fpu_status contents so that the next operation has a clean slate.  */
  57     qemu_exc = env->fpu_status.float_exception_flags;
  58     if (qemu_exc == 0) {
  59         return;
  60     }
  61     env->fpu_status.float_exception_flags = 0;
  62
  63     /* Convert softfloat exception bits to s390 exception bits.  */
  64     s390_exc = 0;
  65     s390_exc |= convert_bit(qemu_exc, float_flag_invalid, 0x80);
  66     s390_exc |= convert_bit(qemu_exc, float_flag_divbyzero, 0x40);
  67     s390_exc |= convert_bit(qemu_exc, float_flag_overflow, 0x20);
  68     s390_exc |= convert_bit(qemu_exc, float_flag_underflow, 0x10);
  69     s390_exc |= convert_bit(qemu_exc, float_flag_inexact, 0x08);
  70
  71     /* Install the exceptions that we raised.  */
  72     env->fpc |= s390_exc << 16;
  73
  74     /* Send signals for enabled exceptions.  */
  75     s390_exc &= env->fpc >> 24;
  76     if (s390_exc) {
  77         ieee_exception(env, s390_exc, retaddr);
  78     }
  79 }
  80
  81 static inline int float_comp_to_cc(CPUS390XState *env, int float_compare)
  82 {
  83     switch (float_compare) {
  84     case float_relation_equal:
  85         return 0;
  86     case float_relation_less:
  87         return 1;
  88     case float_relation_greater:
  89         return 2;
  90     case float_relation_unordered:
  91         return 3;
  92     default:
  93         cpu_abort(env, "unknown return value for float compare\n");
  94     }
  95 }
  96
  97 /* condition codes for unary FP ops */
  98 uint32_t set_cc_nz_f32(float32 v)
  99 {
 100     if (float32_is_any_nan(v)) {
 101         return 3;
 102     } else if (float32_is_zero(v)) {
 103         return 0;
 104     } else if (float32_is_neg(v)) {
 105         return 1;
 106     } else {
 107         return 2;
 108     }
 109 }
 110
 111 uint32_t set_cc_nz_f64(float64 v)
 112 {
 113     if (float64_is_any_nan(v)) {
 114         return 3;
 115     } else if (float64_is_zero(v)) {
 116         return 0;
 117     } else if (float64_is_neg(v)) {
 118         return 1;
 119     } else {
 120         return 2;
 121     }
 122 }
 123
 124 uint32_t set_cc_nz_f128(float128 v)
 125 {
 126     if (float128_is_any_nan(v)) {
 127         return 3;
 128     } else if (float128_is_zero(v)) {
 129         return 0;
 130     } else if (float128_is_neg(v)) {
 131         return 1;
 132     } else {
 133         return 2;
 134     }
 135 }
 136
 137 /* convert 32-bit int to 64-bit float */
 138 void HELPER(cdfbr)(CPUS390XState *env, uint32_t f1, int32_t v2)
 139 {
 140     HELPER_LOG("%s: converting %d to f%d\n", __func__, v2, f1);
 141     env->fregs[f1].d = int32_to_float64(v2, &env->fpu_status);
 142 }
 143
 144 /* convert 32-bit int to 128-bit float */
 145 void HELPER(cxfbr)(CPUS390XState *env, uint32_t f1, int32_t v2)
 146 {
 147     CPU_QuadU v1;
 148
 149     v1.q = int32_to_float128(v2, &env->fpu_status);
 150     env->fregs[f1].ll = v1.ll.upper;
 151     env->fregs[f1 + 2].ll = v1.ll.lower;
 152 }
 153
 154 /* convert 64-bit int to 32-bit float */
 155 void HELPER(cegbr)(CPUS390XState *env, uint32_t f1, int64_t v2)
 156 {
 157     HELPER_LOG("%s: converting %ld to f%d\n", __func__, v2, f1);
 158     env->fregs[f1].l.upper = int64_to_float32(v2, &env->fpu_status);
 159 }
 160
 161 /* convert 64-bit int to 64-bit float */
 162 void HELPER(cdgbr)(CPUS390XState *env, uint32_t f1, int64_t v2)
 163 {
 164     HELPER_LOG("%s: converting %ld to f%d\n", __func__, v2, f1);
 165     env->fregs[f1].d = int64_to_float64(v2, &env->fpu_status);
 166 }
 167
 168 /* convert 64-bit int to 128-bit float */
 169 void HELPER(cxgbr)(CPUS390XState *env, uint32_t f1, int64_t v2)
 170 {
 171     CPU_QuadU x1;
 172
 173     x1.q = int64_to_float128(v2, &env->fpu_status);
 174     HELPER_LOG("%s: converted %ld to 0x%lx and 0x%lx\n", __func__, v2,
 175                x1.ll.upper, x1.ll.lower);
 176     env->fregs[f1].ll = x1.ll.upper;
 177     env->fregs[f1 + 2].ll = x1.ll.lower;
 178 }
 179
 180 /* convert 32-bit int to 32-bit float */
 181 void HELPER(cefbr)(CPUS390XState *env, uint32_t f1, int32_t v2)
 182 {
 183     env->fregs[f1].l.upper = int32_to_float32(v2, &env->fpu_status);
 184     HELPER_LOG("%s: converting %d to 0x%d in f%d\n", __func__, v2,
 185                env->fregs[f1].l.upper, f1);
 186 }
 187
 188 /* 32-bit FP addition */
 189 uint64_t HELPER(aeb)(CPUS390XState *env, uint64_t f1, uint64_t f2)
 190 {
 191     float32 ret = float32_add(f1, f2, &env->fpu_status);
 192     handle_exceptions(env, GETPC());
 193     return ret;
 194 }
 195
 196 /* 64-bit FP addition */
 197 uint64_t HELPER(adb)(CPUS390XState *env, uint64_t f1, uint64_t f2)
 198 {
 199     float64 ret = float64_add(f1, f2, &env->fpu_status);
 200     handle_exceptions(env, GETPC());
 201     return ret;
 202 }
 203
 204 /* 128-bit FP addition */
 205 uint64_t HELPER(axb)(CPUS390XState *env, uint64_t ah, uint64_t al,
 206                      uint64_t bh, uint64_t bl)
 207 {
 208     float128 ret = float128_add(make_float128(ah, al),
 209                                 make_float128(bh, bl),
 210                                 &env->fpu_status);
 211     handle_exceptions(env, GETPC());
 212     return RET128(ret);
 213 }
 214
 215 /* 32-bit FP subtraction */
 216 uint64_t HELPER(seb)(CPUS390XState *env, uint64_t f1, uint64_t f2)
 217 {
 218     float32 ret = float32_sub(f1, f2, &env->fpu_status);
 219     handle_exceptions(env, GETPC());
 220     return ret;
 221 }
 222
 223 /* 64-bit FP subtraction */
 224 uint64_t HELPER(sdb)(CPUS390XState *env, uint64_t f1, uint64_t f2)
 225 {
 226     float64 ret = float64_sub(f1, f2, &env->fpu_status);
 227     handle_exceptions(env, GETPC());
 228     return ret;
 229 }
 230
 231 /* 128-bit FP subtraction */
 232 uint64_t HELPER(sxb)(CPUS390XState *env, uint64_t ah, uint64_t al,
 233                      uint64_t bh, uint64_t bl)
 234 {
 235     float128 ret = float128_sub(make_float128(ah, al),
 236                                 make_float128(bh, bl),
 237                                 &env->fpu_status);
 238     handle_exceptions(env, GETPC());
 239     return RET128(ret);
 240 }
 241
 242 /* 32-bit FP division */
 243 uint64_t HELPER(deb)(CPUS390XState *env, uint64_t f1, uint64_t f2)
 244 {
 245     float32 ret = float32_div(f1, f2, &env->fpu_status);
 246     handle_exceptions(env, GETPC());
 247     return ret;
 248 }
 249
 250 /* 64-bit FP division */
 251 uint64_t HELPER(ddb)(CPUS390XState *env, uint64_t f1, uint64_t f2)
 252 {
 253     float64 ret = float64_div(f1, f2, &env->fpu_status);
 254     handle_exceptions(env, GETPC());
 255     return ret;
 256 }
 257
 258 /* 128-bit FP division */
 259 uint64_t HELPER(dxb)(CPUS390XState *env, uint64_t ah, uint64_t al,
 260                      uint64_t bh, uint64_t bl)
 261 {
 262     float128 ret = float128_div(make_float128(ah, al),
 263                                 make_float128(bh, bl),
 264                                 &env->fpu_status);
 265     handle_exceptions(env, GETPC());
 266     return RET128(ret);
 267 }
 268
 269 /* 32-bit FP multiplication */
 270 uint64_t HELPER(meeb)(CPUS390XState *env, uint64_t f1, uint64_t f2)
 271 {
 272     float32 ret = float32_mul(f1, f2, &env->fpu_status);
 273     handle_exceptions(env, GETPC());
 274     return ret;
 275 }
 276
 277 /* 64-bit FP multiplication */
 278 uint64_t HELPER(mdb)(CPUS390XState *env, uint64_t f1, uint64_t f2)
 279 {
 280     float64 ret = float64_mul(f1, f2, &env->fpu_status);
 281     handle_exceptions(env, GETPC());
 282     return ret;
 283 }
 284
 285 /* 64/32-bit FP multiplication */
 286 uint64_t HELPER(mdeb)(CPUS390XState *env, uint64_t f1, uint64_t f2)
 287 {
 288     float64 ret = float32_to_float64(f2, &env->fpu_status);
 289     ret = float64_mul(f1, ret, &env->fpu_status);
 290     handle_exceptions(env, GETPC());
 291     return ret;
 292 }
 293
 294 /* 128-bit FP multiplication */
 295 uint64_t HELPER(mxb)(CPUS390XState *env, uint64_t ah, uint64_t al,
 296                      uint64_t bh, uint64_t bl)
 297 {
 298     float128 ret = float128_mul(make_float128(ah, al),
 299                                 make_float128(bh, bl),
 300                                 &env->fpu_status);
 301     handle_exceptions(env, GETPC());
 302     return RET128(ret);
 303 }
 304
 305 /* 128/64-bit FP multiplication */
 306 uint64_t HELPER(mxdb)(CPUS390XState *env, uint64_t ah, uint64_t al,
 307                       uint64_t f2)
 308 {
 309     float128 ret = float64_to_float128(f2, &env->fpu_status);
 310     ret = float128_mul(make_float128(ah, al), ret, &env->fpu_status);
 311     handle_exceptions(env, GETPC());
 312     return RET128(ret);
 313 }
 314
 315 /* convert 32-bit float to 64-bit float */
 316 uint64_t HELPER(ldeb)(CPUS390XState *env, uint64_t f2)
 317 {
 318     float64 ret = float32_to_float64(f2, &env->fpu_status);
 319     handle_exceptions(env, GETPC());
 320     return ret;
 321 }
 322
 323 /* convert 128-bit float to 64-bit float */
 324 uint64_t HELPER(ldxb)(CPUS390XState *env, uint64_t ah, uint64_t al)
 325 {
 326     float64 ret = float128_to_float64(make_float128(ah, al), &env->fpu_status);
 327     handle_exceptions(env, GETPC());
 328     return ret;
 329 }
 330
 331 /* convert 64-bit float to 128-bit float */
 332 uint64_t HELPER(lxdb)(CPUS390XState *env, uint64_t f2)
 333 {
 334     float128 ret = float64_to_float128(f2, &env->fpu_status);
 335     handle_exceptions(env, GETPC());
 336     return RET128(ret);
 337 }
 338
 339 /* convert 32-bit float to 128-bit float */
 340 uint64_t HELPER(lxeb)(CPUS390XState *env, uint64_t f2)
 341 {
 342     float128 ret = float32_to_float128(f2, &env->fpu_status);
 343     handle_exceptions(env, GETPC());
 344     return RET128(ret);
 345 }
 346
 347 /* convert 64-bit float to 32-bit float */
 348 uint64_t HELPER(ledb)(CPUS390XState *env, uint64_t f2)
 349 {
 350     float32 ret = float64_to_float32(f2, &env->fpu_status);
 351     handle_exceptions(env, GETPC());
 352     return ret;
 353 }
 354
 355 /* convert 128-bit float to 32-bit float */
 356 uint64_t HELPER(lexb)(CPUS390XState *env, uint64_t ah, uint64_t al)
 357 {
 358     float32 ret = float128_to_float32(make_float128(ah, al), &env->fpu_status);
 359     handle_exceptions(env, GETPC());
 360     return ret;
 361 }
 362
 363 /* 32-bit FP compare */
 364 uint32_t HELPER(ceb)(CPUS390XState *env, uint64_t f1, uint64_t f2)
 365 {
 366     int cmp = float32_compare_quiet(f1, f2, &env->fpu_status);
 367     handle_exceptions(env, GETPC());
 368     return float_comp_to_cc(env, cmp);
 369 }
 370
 371 /* 64-bit FP compare */
 372 uint32_t HELPER(cdb)(CPUS390XState *env, uint64_t f1, uint64_t f2)
 373 {
 374     int cmp = float64_compare_quiet(f1, f2, &env->fpu_status);
 375     handle_exceptions(env, GETPC());
 376     return float_comp_to_cc(env, cmp);
 377 }
 378
 379 /* 128-bit FP compare */
 380 uint32_t HELPER(cxb)(CPUS390XState *env, uint64_t ah, uint64_t al,
 381                      uint64_t bh, uint64_t bl)
 382 {
 383     int cmp = float128_compare_quiet(make_float128(ah, al),
 384                                      make_float128(bh, bl),
 385                                      &env->fpu_status);
 386     handle_exceptions(env, GETPC());
 387     return float_comp_to_cc(env, cmp);
 388 }
 389
 390 static int swap_round_mode(CPUS390XState *env, int m3)
 391 {
 392     int ret = env->fpu_status.float_rounding_mode;
 393     switch (m3) {
 394     case 0:
 395         /* current mode */
 396         break;
 397     case 1:
 398         /* biased round no nearest */
 399     case 4:
 400         /* round to nearest */
 401         set_float_rounding_mode(float_round_nearest_even, &env->fpu_status);
 402         break;
 403     case 5:
 404         /* round to zero */
 405         set_float_rounding_mode(float_round_to_zero, &env->fpu_status);
 406         break;
 407     case 6:
 408         /* round to +inf */
 409         set_float_rounding_mode(float_round_up, &env->fpu_status);
 410         break;
 411     case 7:
 412         /* round to -inf */
 413         set_float_rounding_mode(float_round_down, &env->fpu_status);
 414         break;
 415     }
 416     return ret;
 417 }
 418
 419 /* convert 32-bit float to 64-bit int */
 420 uint64_t HELPER(cgeb)(CPUS390XState *env, uint64_t v2, uint32_t m3)
 421 {
 422     int hold = swap_round_mode(env, m3);
 423     int64_t ret = float32_to_int64(v2, &env->fpu_status);
 424     set_float_rounding_mode(hold, &env->fpu_status);
 425     handle_exceptions(env, GETPC());
 426     return ret;
 427 }
 428
 429 /* convert 64-bit float to 64-bit int */
 430 uint64_t HELPER(cgdb)(CPUS390XState *env, uint64_t v2, uint32_t m3)
 431 {
 432     int hold = swap_round_mode(env, m3);
 433     int64_t ret = float64_to_int64(v2, &env->fpu_status);
 434     set_float_rounding_mode(hold, &env->fpu_status);
 435     handle_exceptions(env, GETPC());
 436     return ret;
 437 }
 438
 439 /* convert 128-bit float to 64-bit int */
 440 uint64_t HELPER(cgxb)(CPUS390XState *env, uint64_t h, uint64_t l, uint32_t m3)
 441 {
 442     int hold = swap_round_mode(env, m3);
 443     float128 v2 = make_float128(h, l);
 444     int64_t ret = float128_to_int64(v2, &env->fpu_status);
 445     set_float_rounding_mode(hold, &env->fpu_status);
 446     handle_exceptions(env, GETPC());
 447     return ret;
 448 }
 449
 450 /* convert 32-bit float to 32-bit int */
 451 uint64_t HELPER(cfeb)(CPUS390XState *env, uint64_t v2, uint32_t m3)
 452 {
 453     int hold = swap_round_mode(env, m3);
 454     int32_t ret = float32_to_int32(v2, &env->fpu_status);
 455     set_float_rounding_mode(hold, &env->fpu_status);
 456     handle_exceptions(env, GETPC());
 457     return ret;
 458 }
 459
 460 /* convert 64-bit float to 32-bit int */
 461 uint64_t HELPER(cfdb)(CPUS390XState *env, uint64_t v2, uint32_t m3)
 462 {
 463     int hold = swap_round_mode(env, m3);
 464     int32_t ret = float64_to_int32(v2, &env->fpu_status);
 465     set_float_rounding_mode(hold, &env->fpu_status);
 466     handle_exceptions(env, GETPC());
 467     return ret;
 468 }
 469
 470 /* convert 128-bit float to 32-bit int */
 471 uint64_t HELPER(cfxb)(CPUS390XState *env, uint64_t h, uint64_t l, uint32_t m3)
 472 {
 473     int hold = swap_round_mode(env, m3);
 474     float128 v2 = make_float128(h, l);
 475     int32_t ret = float128_to_int32(v2, &env->fpu_status);
 476     set_float_rounding_mode(hold, &env->fpu_status);
 477     handle_exceptions(env, GETPC());
 478     return ret;
 479 }
 480
 481 /* 32-bit FP multiply and add */
 482 uint64_t HELPER(maeb)(CPUS390XState *env, uint64_t f1,
 483                       uint64_t f2, uint64_t f3)
 484 {
 485     float32 ret = float32_muladd(f2, f3, f1, 0, &env->fpu_status);
 486     handle_exceptions(env, GETPC());
 487     return ret;
 488 }
 489
 490 /* 64-bit FP multiply and add */
 491 uint64_t HELPER(madb)(CPUS390XState *env, uint64_t f1,
 492                       uint64_t f2, uint64_t f3)
 493 {
 494     float64 ret = float64_muladd(f2, f3, f1, 0, &env->fpu_status);
 495     handle_exceptions(env, GETPC());
 496     return ret;
 497 }
 498
 499 /* 32-bit FP multiply and subtract */
 500 uint64_t HELPER(mseb)(CPUS390XState *env, uint64_t f1,
 501                       uint64_t f2, uint64_t f3)
 502 {
 503     float32 ret = float32_muladd(f2, f3, f1, float_muladd_negate_c,
 504                                  &env->fpu_status);
 505     handle_exceptions(env, GETPC());
 506     return ret;
 507 }
 508
 509 /* 64-bit FP multiply and subtract */
 510 uint64_t HELPER(msdb)(CPUS390XState *env, uint64_t f1,
 511                       uint64_t f2, uint64_t f3)
 512 {
 513     float64 ret = float64_muladd(f2, f3, f1, float_muladd_negate_c,
 514                                  &env->fpu_status);
 515     handle_exceptions(env, GETPC());
 516     return ret;
 517 }
 518
 519 /* test data class 32-bit */
 520 uint32_t HELPER(tceb)(uint64_t f1, uint64_t m2)
 521 {
 522     float32 v1 = f1;
 523     int neg = float32_is_neg(v1);
 524     uint32_t cc = 0;
 525
 526     if ((float32_is_zero(v1) && (m2 & (1 << (11-neg)))) ||
 527         (float32_is_infinity(v1) && (m2 & (1 << (5-neg)))) ||
 528         (float32_is_any_nan(v1) && (m2 & (1 << (3-neg)))) ||
 529         (float32_is_signaling_nan(v1) && (m2 & (1 << (1-neg))))) {
 530         cc = 1;
 531     } else if (m2 & (1 << (9-neg))) {
 532         /* assume normalized number */
 533         cc = 1;
 534     }
 535     /* FIXME: denormalized? */
 536     return cc;
 537 }
 538
 539 /* test data class 64-bit */
 540 uint32_t HELPER(tcdb)(uint64_t v1, uint64_t m2)
 541 {
 542     int neg = float64_is_neg(v1);
 543     uint32_t cc = 0;
 544
 545     if ((float64_is_zero(v1) && (m2 & (1 << (11-neg)))) ||
 546         (float64_is_infinity(v1) && (m2 & (1 << (5-neg)))) ||
 547         (float64_is_any_nan(v1) && (m2 & (1 << (3-neg)))) ||
 548         (float64_is_signaling_nan(v1) && (m2 & (1 << (1-neg))))) {
 549         cc = 1;
 550     } else if (m2 & (1 << (9-neg))) {
 551         /* assume normalized number */
 552         cc = 1;
 553     }
 554     /* FIXME: denormalized? */
 555     return cc;
 556 }
 557
 558 /* test data class 128-bit */
 559 uint32_t HELPER(tcxb)(uint64_t ah, uint64_t al, uint64_t m2)
 560 {
 561     float128 v1 = make_float128(ah, al);
 562     int neg = float128_is_neg(v1);
 563     uint32_t cc = 0;
 564
 565     if ((float128_is_zero(v1) && (m2 & (1 << (11-neg)))) ||
 566         (float128_is_infinity(v1) && (m2 & (1 << (5-neg)))) ||
 567         (float128_is_any_nan(v1) && (m2 & (1 << (3-neg)))) ||
 568         (float128_is_signaling_nan(v1) && (m2 & (1 << (1-neg))))) {
 569         cc = 1;
 570     } else if (m2 & (1 << (9-neg))) {
 571         /* assume normalized number */
 572         cc = 1;
 573     }
 574     /* FIXME: denormalized? */
 575     return cc;
 576 }
 577
 578 /* square root 32-bit */
 579 uint64_t HELPER(sqeb)(CPUS390XState *env, uint64_t f2)
 580 {
 581     float32 ret = float32_sqrt(f2, &env->fpu_status);
 582     handle_exceptions(env, GETPC());
 583     return ret;
 584 }
 585
 586 /* square root 64-bit */
 587 uint64_t HELPER(sqdb)(CPUS390XState *env, uint64_t f2)
 588 {
 589     float64 ret = float64_sqrt(f2, &env->fpu_status);
 590     handle_exceptions(env, GETPC());
 591     return ret;
 592 }
 593
 594 /* square root 128-bit */
 595 uint64_t HELPER(sqxb)(CPUS390XState *env, uint64_t ah, uint64_t al)
 596 {
 597     float128 ret = float128_sqrt(make_float128(ah, al), &env->fpu_status);
 598     handle_exceptions(env, GETPC());
 599     return RET128(ret);
 600 }