wrap.c.inc (28376B)
1 /* 2 * In this file we wrap QEMU FP functions to look like softfloat/testfloat's, 3 * so that we can use the testfloat infrastructure as-is. 4 * 5 * This file must be included directly from fp-test.c. We could compile it 6 * separately, but it would be tedious to add declarations for all the wrappers. 7 */ 8 9 static signed char sf_tininess_to_qemu(uint_fast8_t mode) 10 { 11 switch (mode) { 12 case softfloat_tininess_beforeRounding: 13 return float_tininess_before_rounding; 14 case softfloat_tininess_afterRounding: 15 return float_tininess_after_rounding; 16 default: 17 g_assert_not_reached(); 18 } 19 } 20 21 static signed char sf_rounding_to_qemu(uint_fast8_t mode) 22 { 23 switch (mode) { 24 case softfloat_round_near_even: 25 return float_round_nearest_even; 26 case softfloat_round_minMag: 27 return float_round_to_zero; 28 case softfloat_round_min: 29 return float_round_down; 30 case softfloat_round_max: 31 return float_round_up; 32 case softfloat_round_near_maxMag: 33 return float_round_ties_away; 34 case softfloat_round_odd: 35 return float_round_to_odd; 36 default: 37 g_assert_not_reached(); 38 } 39 } 40 41 static uint_fast8_t qemu_flags_to_sf(uint8_t qflags) 42 { 43 uint_fast8_t ret = 0; 44 45 if (qflags & float_flag_invalid) { 46 ret |= softfloat_flag_invalid; 47 } 48 if (qflags & float_flag_divbyzero) { 49 ret |= softfloat_flag_infinite; 50 } 51 if (qflags & float_flag_overflow) { 52 ret |= softfloat_flag_overflow; 53 } 54 if (qflags & float_flag_underflow) { 55 ret |= softfloat_flag_underflow; 56 } 57 if (qflags & float_flag_inexact) { 58 ret |= softfloat_flag_inexact; 59 } 60 return ret; 61 } 62 63 /* 64 * floatx80 and float128 cannot be cast between qemu and softfloat, because 65 * in softfloat the order of the fields depends on the host's endianness. 66 */ 67 static extFloat80_t qemu_to_soft80(floatx80 a) 68 { 69 extFloat80_t ret; 70 71 ret.signif = a.low; 72 ret.signExp = a.high; 73 return ret; 74 } 75 76 static floatx80 soft_to_qemu80(extFloat80_t a) 77 { 78 floatx80 ret; 79 80 ret.low = a.signif; 81 ret.high = a.signExp; 82 return ret; 83 } 84 85 static float128_t qemu_to_soft128(float128 a) 86 { 87 float128_t ret; 88 struct uint128 *to = (struct uint128 *)&ret; 89 90 to->v0 = a.low; 91 to->v64 = a.high; 92 return ret; 93 } 94 95 static float128 soft_to_qemu128(float128_t a) 96 { 97 struct uint128 *from = (struct uint128 *)&a; 98 float128 ret; 99 100 ret.low = from->v0; 101 ret.high = from->v64; 102 return ret; 103 } 104 105 /* conversions */ 106 #define WRAP_SF_TO_SF_IEEE(name, func, a_type, b_type) \ 107 static b_type##_t name(a_type##_t a) \ 108 { \ 109 a_type *ap = (a_type *)&a; \ 110 b_type ret; \ 111 \ 112 ret = func(*ap, true, &qsf); \ 113 return *(b_type##_t *)&ret; \ 114 } 115 116 WRAP_SF_TO_SF_IEEE(qemu_f16_to_f32, float16_to_float32, float16, float32) 117 WRAP_SF_TO_SF_IEEE(qemu_f16_to_f64, float16_to_float64, float16, float64) 118 119 WRAP_SF_TO_SF_IEEE(qemu_f32_to_f16, float32_to_float16, float32, float16) 120 WRAP_SF_TO_SF_IEEE(qemu_f64_to_f16, float64_to_float16, float64, float16) 121 #undef WRAP_SF_TO_SF_IEEE 122 123 #define WRAP_SF_TO_SF(name, func, a_type, b_type) \ 124 static b_type##_t name(a_type##_t a) \ 125 { \ 126 a_type *ap = (a_type *)&a; \ 127 b_type ret; \ 128 \ 129 ret = func(*ap, &qsf); \ 130 return *(b_type##_t *)&ret; \ 131 } 132 133 WRAP_SF_TO_SF(qemu_f32_to_f64, float32_to_float64, float32, float64) 134 WRAP_SF_TO_SF(qemu_f64_to_f32, float64_to_float32, float64, float32) 135 #undef WRAP_SF_TO_SF 136 137 #define WRAP_SF_TO_80(name, func, type) \ 138 static void name(type##_t a, extFloat80_t *res) \ 139 { \ 140 floatx80 ret; \ 141 type *ap = (type *)&a; \ 142 \ 143 ret = func(*ap, &qsf); \ 144 *res = qemu_to_soft80(ret); \ 145 } 146 147 WRAP_SF_TO_80(qemu_f32_to_extF80M, float32_to_floatx80, float32) 148 WRAP_SF_TO_80(qemu_f64_to_extF80M, float64_to_floatx80, float64) 149 #undef WRAP_SF_TO_80 150 151 #define WRAP_SF_TO_128(name, func, type) \ 152 static void name(type##_t a, float128_t *res) \ 153 { \ 154 float128 ret; \ 155 type *ap = (type *)&a; \ 156 \ 157 ret = func(*ap, &qsf); \ 158 *res = qemu_to_soft128(ret); \ 159 } 160 161 WRAP_SF_TO_128(qemu_f32_to_f128M, float32_to_float128, float32) 162 WRAP_SF_TO_128(qemu_f64_to_f128M, float64_to_float128, float64) 163 #undef WRAP_SF_TO_128 164 165 /* Note: exact is ignored since qemu's softfloat assumes it is set */ 166 #define WRAP_SF_TO_INT(name, func, type, fast_type) \ 167 static fast_type name(type##_t a, uint_fast8_t round, bool exact) \ 168 { \ 169 type *ap = (type *)&a; \ 170 \ 171 qsf.float_rounding_mode = sf_rounding_to_qemu(round); \ 172 return func(*ap, &qsf); \ 173 } 174 175 WRAP_SF_TO_INT(qemu_f16_to_ui32, float16_to_uint32, float16, uint_fast32_t) 176 WRAP_SF_TO_INT(qemu_f16_to_ui64, float16_to_uint64, float16, uint_fast64_t) 177 178 WRAP_SF_TO_INT(qemu_f32_to_ui32, float32_to_uint32, float32, uint_fast32_t) 179 WRAP_SF_TO_INT(qemu_f32_to_ui64, float32_to_uint64, float32, uint_fast64_t) 180 181 WRAP_SF_TO_INT(qemu_f64_to_ui32, float64_to_uint32, float64, uint_fast32_t) 182 WRAP_SF_TO_INT(qemu_f64_to_ui64, float64_to_uint64, float64, uint_fast64_t) 183 184 WRAP_SF_TO_INT(qemu_f16_to_i32, float16_to_int32, float16, int_fast32_t) 185 WRAP_SF_TO_INT(qemu_f16_to_i64, float16_to_int64, float16, int_fast64_t) 186 187 WRAP_SF_TO_INT(qemu_f32_to_i32, float32_to_int32, float32, int_fast32_t) 188 WRAP_SF_TO_INT(qemu_f32_to_i64, float32_to_int64, float32, int_fast64_t) 189 190 WRAP_SF_TO_INT(qemu_f64_to_i32, float64_to_int32, float64, int_fast32_t) 191 WRAP_SF_TO_INT(qemu_f64_to_i64, float64_to_int64, float64, int_fast64_t) 192 #undef WRAP_SF_TO_INT 193 194 /* Note: exact is ignored since qemu's softfloat assumes it is set */ 195 #define WRAP_SF_TO_INT_MINMAG(name, func, type, fast_type) \ 196 static fast_type name(type##_t a, bool exact) \ 197 { \ 198 type *ap = (type *)&a; \ 199 \ 200 return func(*ap, &qsf); \ 201 } 202 203 WRAP_SF_TO_INT_MINMAG(qemu_f16_to_ui32_r_minMag, 204 float16_to_uint32_round_to_zero, float16, uint_fast32_t) 205 WRAP_SF_TO_INT_MINMAG(qemu_f16_to_ui64_r_minMag, 206 float16_to_uint64_round_to_zero, float16, uint_fast64_t) 207 208 WRAP_SF_TO_INT_MINMAG(qemu_f16_to_i32_r_minMag, 209 float16_to_int32_round_to_zero, float16, int_fast32_t) 210 WRAP_SF_TO_INT_MINMAG(qemu_f16_to_i64_r_minMag, 211 float16_to_int64_round_to_zero, float16, int_fast64_t) 212 213 WRAP_SF_TO_INT_MINMAG(qemu_f32_to_ui32_r_minMag, 214 float32_to_uint32_round_to_zero, float32, uint_fast32_t) 215 WRAP_SF_TO_INT_MINMAG(qemu_f32_to_ui64_r_minMag, 216 float32_to_uint64_round_to_zero, float32, uint_fast64_t) 217 218 WRAP_SF_TO_INT_MINMAG(qemu_f32_to_i32_r_minMag, 219 float32_to_int32_round_to_zero, float32, int_fast32_t) 220 WRAP_SF_TO_INT_MINMAG(qemu_f32_to_i64_r_minMag, 221 float32_to_int64_round_to_zero, float32, int_fast64_t) 222 223 WRAP_SF_TO_INT_MINMAG(qemu_f64_to_ui32_r_minMag, 224 float64_to_uint32_round_to_zero, float64, uint_fast32_t) 225 WRAP_SF_TO_INT_MINMAG(qemu_f64_to_ui64_r_minMag, 226 float64_to_uint64_round_to_zero, float64, uint_fast64_t) 227 228 WRAP_SF_TO_INT_MINMAG(qemu_f64_to_i32_r_minMag, 229 float64_to_int32_round_to_zero, float64, int_fast32_t) 230 WRAP_SF_TO_INT_MINMAG(qemu_f64_to_i64_r_minMag, 231 float64_to_int64_round_to_zero, float64, int_fast64_t) 232 #undef WRAP_SF_TO_INT_MINMAG 233 234 #define WRAP_80_TO_SF(name, func, type) \ 235 static type##_t name(const extFloat80_t *ap) \ 236 { \ 237 floatx80 a; \ 238 type ret; \ 239 \ 240 a = soft_to_qemu80(*ap); \ 241 ret = func(a, &qsf); \ 242 return *(type##_t *)&ret; \ 243 } 244 245 WRAP_80_TO_SF(qemu_extF80M_to_f32, floatx80_to_float32, float32) 246 WRAP_80_TO_SF(qemu_extF80M_to_f64, floatx80_to_float64, float64) 247 #undef WRAP_80_TO_SF 248 249 #define WRAP_128_TO_SF(name, func, type) \ 250 static type##_t name(const float128_t *ap) \ 251 { \ 252 float128 a; \ 253 type ret; \ 254 \ 255 a = soft_to_qemu128(*ap); \ 256 ret = func(a, &qsf); \ 257 return *(type##_t *)&ret; \ 258 } 259 260 WRAP_128_TO_SF(qemu_f128M_to_f32, float128_to_float32, float32) 261 WRAP_128_TO_SF(qemu_f128M_to_f64, float128_to_float64, float64) 262 #undef WRAP_128_TO_SF 263 264 static void qemu_extF80M_to_f128M(const extFloat80_t *from, float128_t *to) 265 { 266 floatx80 qfrom; 267 float128 qto; 268 269 qfrom = soft_to_qemu80(*from); 270 qto = floatx80_to_float128(qfrom, &qsf); 271 *to = qemu_to_soft128(qto); 272 } 273 274 static void qemu_f128M_to_extF80M(const float128_t *from, extFloat80_t *to) 275 { 276 float128 qfrom; 277 floatx80 qto; 278 279 qfrom = soft_to_qemu128(*from); 280 qto = float128_to_floatx80(qfrom, &qsf); 281 *to = qemu_to_soft80(qto); 282 } 283 284 #define WRAP_INT_TO_SF(name, func, int_type, type) \ 285 static type##_t name(int_type a) \ 286 { \ 287 type ret; \ 288 \ 289 ret = func(a, &qsf); \ 290 return *(type##_t *)&ret; \ 291 } 292 293 WRAP_INT_TO_SF(qemu_ui32_to_f16, uint32_to_float16, uint32_t, float16) 294 WRAP_INT_TO_SF(qemu_ui32_to_f32, uint32_to_float32, uint32_t, float32) 295 WRAP_INT_TO_SF(qemu_ui32_to_f64, uint32_to_float64, uint32_t, float64) 296 297 WRAP_INT_TO_SF(qemu_ui64_to_f16, uint64_to_float16, uint64_t, float16) 298 WRAP_INT_TO_SF(qemu_ui64_to_f32, uint64_to_float32, uint64_t, float32) 299 WRAP_INT_TO_SF(qemu_ui64_to_f64, uint64_to_float64, uint64_t, float64) 300 301 WRAP_INT_TO_SF(qemu_i32_to_f16, int32_to_float16, int32_t, float16) 302 WRAP_INT_TO_SF(qemu_i32_to_f32, int32_to_float32, int32_t, float32) 303 WRAP_INT_TO_SF(qemu_i32_to_f64, int32_to_float64, int32_t, float64) 304 305 WRAP_INT_TO_SF(qemu_i64_to_f16, int64_to_float16, int64_t, float16) 306 WRAP_INT_TO_SF(qemu_i64_to_f32, int64_to_float32, int64_t, float32) 307 WRAP_INT_TO_SF(qemu_i64_to_f64, int64_to_float64, int64_t, float64) 308 #undef WRAP_INT_TO_SF 309 310 #define WRAP_INT_TO_80(name, func, int_type) \ 311 static void name(int_type a, extFloat80_t *res) \ 312 { \ 313 floatx80 ret; \ 314 \ 315 ret = func(a, &qsf); \ 316 *res = qemu_to_soft80(ret); \ 317 } 318 319 WRAP_INT_TO_80(qemu_i32_to_extF80M, int32_to_floatx80, int32_t) 320 WRAP_INT_TO_80(qemu_i64_to_extF80M, int64_to_floatx80, int64_t) 321 #undef WRAP_INT_TO_80 322 323 /* Note: exact is ignored since qemu's softfloat assumes it is set */ 324 #define WRAP_80_TO_INT(name, func, fast_type) \ 325 static fast_type name(const extFloat80_t *ap, uint_fast8_t round, \ 326 bool exact) \ 327 { \ 328 floatx80 a; \ 329 \ 330 a = soft_to_qemu80(*ap); \ 331 qsf.float_rounding_mode = sf_rounding_to_qemu(round); \ 332 return func(a, &qsf); \ 333 } 334 335 WRAP_80_TO_INT(qemu_extF80M_to_i32, floatx80_to_int32, int_fast32_t) 336 WRAP_80_TO_INT(qemu_extF80M_to_i64, floatx80_to_int64, int_fast64_t) 337 #undef WRAP_80_TO_INT 338 339 /* Note: exact is ignored since qemu's softfloat assumes it is set */ 340 #define WRAP_80_TO_INT_MINMAG(name, func, fast_type) \ 341 static fast_type name(const extFloat80_t *ap, bool exact) \ 342 { \ 343 floatx80 a; \ 344 \ 345 a = soft_to_qemu80(*ap); \ 346 return func(a, &qsf); \ 347 } 348 349 WRAP_80_TO_INT_MINMAG(qemu_extF80M_to_i32_r_minMag, 350 floatx80_to_int32_round_to_zero, int_fast32_t) 351 WRAP_80_TO_INT_MINMAG(qemu_extF80M_to_i64_r_minMag, 352 floatx80_to_int64_round_to_zero, int_fast64_t) 353 #undef WRAP_80_TO_INT_MINMAG 354 355 /* Note: exact is ignored since qemu's softfloat assumes it is set */ 356 #define WRAP_128_TO_INT(name, func, fast_type) \ 357 static fast_type name(const float128_t *ap, uint_fast8_t round, \ 358 bool exact) \ 359 { \ 360 float128 a; \ 361 \ 362 a = soft_to_qemu128(*ap); \ 363 qsf.float_rounding_mode = sf_rounding_to_qemu(round); \ 364 return func(a, &qsf); \ 365 } 366 367 WRAP_128_TO_INT(qemu_f128M_to_i32, float128_to_int32, int_fast32_t) 368 WRAP_128_TO_INT(qemu_f128M_to_i64, float128_to_int64, int_fast64_t) 369 370 WRAP_128_TO_INT(qemu_f128M_to_ui32, float128_to_uint32, uint_fast32_t) 371 WRAP_128_TO_INT(qemu_f128M_to_ui64, float128_to_uint64, uint_fast64_t) 372 #undef WRAP_128_TO_INT 373 374 /* Note: exact is ignored since qemu's softfloat assumes it is set */ 375 #define WRAP_128_TO_INT_MINMAG(name, func, fast_type) \ 376 static fast_type name(const float128_t *ap, bool exact) \ 377 { \ 378 float128 a; \ 379 \ 380 a = soft_to_qemu128(*ap); \ 381 return func(a, &qsf); \ 382 } 383 384 WRAP_128_TO_INT_MINMAG(qemu_f128M_to_i32_r_minMag, 385 float128_to_int32_round_to_zero, int_fast32_t) 386 WRAP_128_TO_INT_MINMAG(qemu_f128M_to_i64_r_minMag, 387 float128_to_int64_round_to_zero, int_fast64_t) 388 389 WRAP_128_TO_INT_MINMAG(qemu_f128M_to_ui32_r_minMag, 390 float128_to_uint32_round_to_zero, uint_fast32_t) 391 WRAP_128_TO_INT_MINMAG(qemu_f128M_to_ui64_r_minMag, 392 float128_to_uint64_round_to_zero, uint_fast64_t) 393 #undef WRAP_128_TO_INT_MINMAG 394 395 #define WRAP_INT_TO_128(name, func, int_type) \ 396 static void name(int_type a, float128_t *res) \ 397 { \ 398 float128 ret; \ 399 \ 400 ret = func(a, &qsf); \ 401 *res = qemu_to_soft128(ret); \ 402 } 403 404 WRAP_INT_TO_128(qemu_ui64_to_f128M, uint64_to_float128, uint64_t) 405 406 WRAP_INT_TO_128(qemu_i32_to_f128M, int32_to_float128, int32_t) 407 WRAP_INT_TO_128(qemu_i64_to_f128M, int64_to_float128, int64_t) 408 #undef WRAP_INT_TO_128 409 410 /* Note: exact is ignored since qemu's softfloat assumes it is set */ 411 #define WRAP_ROUND_TO_INT(name, func, type) \ 412 static type##_t name(type##_t a, uint_fast8_t round, bool exact) \ 413 { \ 414 type *ap = (type *)&a; \ 415 type ret; \ 416 \ 417 qsf.float_rounding_mode = sf_rounding_to_qemu(round); \ 418 ret = func(*ap, &qsf); \ 419 return *(type##_t *)&ret; \ 420 } 421 422 WRAP_ROUND_TO_INT(qemu_f16_roundToInt, float16_round_to_int, float16) 423 WRAP_ROUND_TO_INT(qemu_f32_roundToInt, float32_round_to_int, float32) 424 WRAP_ROUND_TO_INT(qemu_f64_roundToInt, float64_round_to_int, float64) 425 #undef WRAP_ROUND_TO_INT 426 427 static void qemu_extF80M_roundToInt(const extFloat80_t *ap, uint_fast8_t round, 428 bool exact, extFloat80_t *res) 429 { 430 floatx80 a; 431 floatx80 ret; 432 433 a = soft_to_qemu80(*ap); 434 qsf.float_rounding_mode = sf_rounding_to_qemu(round); 435 ret = floatx80_round_to_int(a, &qsf); 436 *res = qemu_to_soft80(ret); 437 } 438 439 static void qemu_f128M_roundToInt(const float128_t *ap, uint_fast8_t round, 440 bool exact, float128_t *res) 441 { 442 float128 a; 443 float128 ret; 444 445 a = soft_to_qemu128(*ap); 446 qsf.float_rounding_mode = sf_rounding_to_qemu(round); 447 ret = float128_round_to_int(a, &qsf); 448 *res = qemu_to_soft128(ret); 449 } 450 451 /* operations */ 452 #define WRAP1(name, func, type) \ 453 static type##_t name(type##_t a) \ 454 { \ 455 type *ap = (type *)&a; \ 456 type ret; \ 457 \ 458 ret = func(*ap, &qsf); \ 459 return *(type##_t *)&ret; \ 460 } 461 462 #define WRAP2(name, func, type) \ 463 static type##_t name(type##_t a, type##_t b) \ 464 { \ 465 type *ap = (type *)&a; \ 466 type *bp = (type *)&b; \ 467 type ret; \ 468 \ 469 ret = func(*ap, *bp, &qsf); \ 470 return *(type##_t *)&ret; \ 471 } 472 473 #define WRAP_COMMON_OPS(b) \ 474 WRAP1(qemu_f##b##_sqrt, float##b##_sqrt, float##b) \ 475 WRAP2(qemu_f##b##_add, float##b##_add, float##b) \ 476 WRAP2(qemu_f##b##_sub, float##b##_sub, float##b) \ 477 WRAP2(qemu_f##b##_mul, float##b##_mul, float##b) \ 478 WRAP2(qemu_f##b##_div, float##b##_div, float##b) 479 480 WRAP_COMMON_OPS(16) 481 WRAP_COMMON_OPS(32) 482 WRAP_COMMON_OPS(64) 483 #undef WRAP_COMMON 484 485 WRAP2(qemu_f32_rem, float32_rem, float32) 486 WRAP2(qemu_f64_rem, float64_rem, float64) 487 #undef WRAP2 488 #undef WRAP1 489 490 #define WRAP1_80(name, func) \ 491 static void name(const extFloat80_t *ap, extFloat80_t *res) \ 492 { \ 493 floatx80 a; \ 494 floatx80 ret; \ 495 \ 496 a = soft_to_qemu80(*ap); \ 497 ret = func(a, &qsf); \ 498 *res = qemu_to_soft80(ret); \ 499 } 500 501 WRAP1_80(qemu_extF80M_sqrt, floatx80_sqrt) 502 #undef WRAP1_80 503 504 #define WRAP1_128(name, func) \ 505 static void name(const float128_t *ap, float128_t *res) \ 506 { \ 507 float128 a; \ 508 float128 ret; \ 509 \ 510 a = soft_to_qemu128(*ap); \ 511 ret = func(a, &qsf); \ 512 *res = qemu_to_soft128(ret); \ 513 } 514 515 WRAP1_128(qemu_f128M_sqrt, float128_sqrt) 516 #undef WRAP1_128 517 518 #define WRAP2_80(name, func) \ 519 static void name(const extFloat80_t *ap, const extFloat80_t *bp, \ 520 extFloat80_t *res) \ 521 { \ 522 floatx80 a; \ 523 floatx80 b; \ 524 floatx80 ret; \ 525 \ 526 a = soft_to_qemu80(*ap); \ 527 b = soft_to_qemu80(*bp); \ 528 ret = func(a, b, &qsf); \ 529 *res = qemu_to_soft80(ret); \ 530 } 531 532 WRAP2_80(qemu_extF80M_add, floatx80_add) 533 WRAP2_80(qemu_extF80M_sub, floatx80_sub) 534 WRAP2_80(qemu_extF80M_mul, floatx80_mul) 535 WRAP2_80(qemu_extF80M_div, floatx80_div) 536 WRAP2_80(qemu_extF80M_rem, floatx80_rem) 537 #undef WRAP2_80 538 539 #define WRAP2_128(name, func) \ 540 static void name(const float128_t *ap, const float128_t *bp, \ 541 float128_t *res) \ 542 { \ 543 float128 a; \ 544 float128 b; \ 545 float128 ret; \ 546 \ 547 a = soft_to_qemu128(*ap); \ 548 b = soft_to_qemu128(*bp); \ 549 ret = func(a, b, &qsf); \ 550 *res = qemu_to_soft128(ret); \ 551 } 552 553 WRAP2_128(qemu_f128M_add, float128_add) 554 WRAP2_128(qemu_f128M_sub, float128_sub) 555 WRAP2_128(qemu_f128M_mul, float128_mul) 556 WRAP2_128(qemu_f128M_div, float128_div) 557 WRAP2_128(qemu_f128M_rem, float128_rem) 558 #undef WRAP2_128 559 560 #define WRAP_MULADD(name, func, type) \ 561 static type##_t name(type##_t a, type##_t b, type##_t c) \ 562 { \ 563 type *ap = (type *)&a; \ 564 type *bp = (type *)&b; \ 565 type *cp = (type *)&c; \ 566 type ret; \ 567 \ 568 ret = func(*ap, *bp, *cp, 0, &qsf); \ 569 return *(type##_t *)&ret; \ 570 } 571 572 WRAP_MULADD(qemu_f16_mulAdd, float16_muladd, float16) 573 WRAP_MULADD(qemu_f32_mulAdd, float32_muladd, float32) 574 WRAP_MULADD(qemu_f64_mulAdd, float64_muladd, float64) 575 #undef WRAP_MULADD 576 577 static void qemu_f128M_mulAdd(const float128_t *ap, const float128_t *bp, 578 const float128_t *cp, float128_t *res) 579 { 580 float128 a, b, c, ret; 581 582 a = soft_to_qemu128(*ap); 583 b = soft_to_qemu128(*bp); 584 c = soft_to_qemu128(*cp); 585 ret = float128_muladd(a, b, c, 0, &qsf); 586 *res = qemu_to_soft128(ret); 587 } 588 589 #define WRAP_CMP16(name, func, retcond) \ 590 static bool name(float16_t a, float16_t b) \ 591 { \ 592 float16 *ap = (float16 *)&a; \ 593 float16 *bp = (float16 *)&b; \ 594 int ret; \ 595 \ 596 ret = func(*ap, *bp, &qsf); \ 597 return retcond; \ 598 } 599 600 WRAP_CMP16(qemu_f16_eq_signaling, float16_compare, ret == 0) 601 WRAP_CMP16(qemu_f16_eq, float16_compare_quiet, ret == 0) 602 WRAP_CMP16(qemu_f16_le, float16_compare, ret <= 0) 603 WRAP_CMP16(qemu_f16_lt, float16_compare, ret < 0) 604 WRAP_CMP16(qemu_f16_le_quiet, float16_compare_quiet, ret <= 0) 605 WRAP_CMP16(qemu_f16_lt_quiet, float16_compare_quiet, ret < 0) 606 #undef WRAP_CMP16 607 608 #define WRAP_CMP(name, func, type) \ 609 static bool name(type##_t a, type##_t b) \ 610 { \ 611 type *ap = (type *)&a; \ 612 type *bp = (type *)&b; \ 613 \ 614 return !!func(*ap, *bp, &qsf); \ 615 } 616 617 #define GEN_WRAP_CMP(b) \ 618 WRAP_CMP(qemu_f##b##_eq_signaling, float##b##_eq, float##b) \ 619 WRAP_CMP(qemu_f##b##_eq, float##b##_eq_quiet, float##b) \ 620 WRAP_CMP(qemu_f##b##_le, float##b##_le, float##b) \ 621 WRAP_CMP(qemu_f##b##_lt, float##b##_lt, float##b) \ 622 WRAP_CMP(qemu_f##b##_le_quiet, float##b##_le_quiet, float##b) \ 623 WRAP_CMP(qemu_f##b##_lt_quiet, float##b##_lt_quiet, float##b) 624 625 GEN_WRAP_CMP(32) 626 GEN_WRAP_CMP(64) 627 #undef GEN_WRAP_CMP 628 #undef WRAP_CMP 629 630 #define WRAP_CMP80(name, func) \ 631 static bool name(const extFloat80_t *ap, const extFloat80_t *bp) \ 632 { \ 633 floatx80 a; \ 634 floatx80 b; \ 635 \ 636 a = soft_to_qemu80(*ap); \ 637 b = soft_to_qemu80(*bp); \ 638 return !!func(a, b, &qsf); \ 639 } 640 641 WRAP_CMP80(qemu_extF80M_eq_signaling, floatx80_eq) 642 WRAP_CMP80(qemu_extF80M_eq, floatx80_eq_quiet) 643 WRAP_CMP80(qemu_extF80M_le, floatx80_le) 644 WRAP_CMP80(qemu_extF80M_lt, floatx80_lt) 645 WRAP_CMP80(qemu_extF80M_le_quiet, floatx80_le_quiet) 646 WRAP_CMP80(qemu_extF80M_lt_quiet, floatx80_lt_quiet) 647 #undef WRAP_CMP80 648 649 #define WRAP_CMP128(name, func) \ 650 static bool name(const float128_t *ap, const float128_t *bp) \ 651 { \ 652 float128 a; \ 653 float128 b; \ 654 \ 655 a = soft_to_qemu128(*ap); \ 656 b = soft_to_qemu128(*bp); \ 657 return !!func(a, b, &qsf); \ 658 } 659 660 WRAP_CMP128(qemu_f128M_eq_signaling, float128_eq) 661 WRAP_CMP128(qemu_f128M_eq, float128_eq_quiet) 662 WRAP_CMP128(qemu_f128M_le, float128_le) 663 WRAP_CMP128(qemu_f128M_lt, float128_lt) 664 WRAP_CMP128(qemu_f128M_le_quiet, float128_le_quiet) 665 WRAP_CMP128(qemu_f128M_lt_quiet, float128_lt_quiet) 666 #undef WRAP_CMP128