| 1 | /* |
| 2 | * x86 FPREM test - executes the FPREM and FPREM1 instructions with corner case |
| 3 | * operands and prints the operands, result and FPU status word. |
| 4 | * |
| 5 | * Run this on real hardware, then under QEMU, and diff the outputs, to compare |
| 6 | * QEMU's implementation to your hardware. The 'run-test-i386-fprem' make |
| 7 | * target does this. |
| 8 | * |
| 9 | * Copyright (c) 2003 Fabrice Bellard |
| 10 | * Copyright (c) 2012 Catalin Patulea |
| 11 | * |
| 12 | * This program is free software; you can redistribute it and/or modify |
| 13 | * it under the terms of the GNU General Public License as published by |
| 14 | * the Free Software Foundation; either version 2 of the License, or |
| 15 | * (at your option) any later version. |
| 16 | * |
| 17 | * This program is distributed in the hope that it will be useful, |
| 18 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 19 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 20 | * GNU General Public License for more details. |
| 21 | * |
| 22 | * You should have received a copy of the GNU General Public License |
| 23 | * along with this program; if not, see <http://www.gnu.org/licenses/>. |
| 24 | */ |
| 25 | |
| 26 | #include <stdio.h> |
| 27 | #include <stdint.h> |
| 28 | |
| 29 | #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) |
| 30 | |
| 31 | /* |
| 32 | * Inspired by <ieee754.h>'s union ieee854_long_double, but with single |
| 33 | * long long mantissa fields and assuming little-endianness for simplicity. |
| 34 | */ |
| 35 | union float80u { |
| 36 | long double d; |
| 37 | |
| 38 | /* This is the IEEE 854 double-extended-precision format. */ |
| 39 | struct { |
| 40 | unsigned long long mantissa:63; |
| 41 | unsigned int one:1; |
| 42 | unsigned int exponent:15; |
| 43 | unsigned int negative:1; |
| 44 | unsigned int empty:16; |
| 45 | } __attribute__((packed)) ieee; |
| 46 | |
| 47 | /* This is for NaNs in the IEEE 854 double-extended-precision format. */ |
| 48 | struct { |
| 49 | unsigned long long mantissa:62; |
| 50 | unsigned int quiet_nan:1; |
| 51 | unsigned int one:1; |
| 52 | unsigned int exponent:15; |
| 53 | unsigned int negative:1; |
| 54 | unsigned int empty:16; |
| 55 | } __attribute__((packed)) ieee_nan; |
| 56 | }; |
| 57 | |
| 58 | #define IEEE854_LONG_DOUBLE_BIAS 0x3fff |
| 59 | |
| 60 | static const union float80u q_nan = { |
| 61 | .ieee_nan.negative = 0, /* X */ |
| 62 | .ieee_nan.exponent = 0x7fff, |
| 63 | .ieee_nan.one = 1, |
| 64 | .ieee_nan.quiet_nan = 1, |
| 65 | .ieee_nan.mantissa = 0, |
| 66 | }; |
| 67 | |
| 68 | static const union float80u s_nan = { |
| 69 | .ieee_nan.negative = 0, /* X */ |
| 70 | .ieee_nan.exponent = 0x7fff, |
| 71 | .ieee_nan.one = 1, |
| 72 | .ieee_nan.quiet_nan = 0, |
| 73 | .ieee_nan.mantissa = 1, /* nonzero */ |
| 74 | }; |
| 75 | |
| 76 | static const union float80u pos_inf = { |
| 77 | .ieee.negative = 0, |
| 78 | .ieee.exponent = 0x7fff, |
| 79 | .ieee.one = 1, |
| 80 | .ieee.mantissa = 0, |
| 81 | }; |
| 82 | |
| 83 | static const union float80u pseudo_pos_inf = { /* "unsupported" */ |
| 84 | .ieee.negative = 0, |
| 85 | .ieee.exponent = 0x7fff, |
| 86 | .ieee.one = 0, |
| 87 | .ieee.mantissa = 0, |
| 88 | }; |
| 89 | |
| 90 | static const union float80u pos_denorm = { |
| 91 | .ieee.negative = 0, |
| 92 | .ieee.exponent = 0, |
| 93 | .ieee.one = 0, |
| 94 | .ieee.mantissa = 1, |
| 95 | }; |
| 96 | |
| 97 | static const union float80u smallest_positive_norm = { |
| 98 | .ieee.negative = 0, |
| 99 | .ieee.exponent = 1, |
| 100 | .ieee.one = 1, |
| 101 | .ieee.mantissa = 0, |
| 102 | }; |
| 103 | |
| 104 | static void fninit() |
| 105 | { |
| 106 | asm volatile ("fninit\n"); |
| 107 | } |
| 108 | |
| 109 | static long double fprem(long double a, long double b, uint16_t *sw) |
| 110 | { |
| 111 | long double result; |
| 112 | asm volatile ("fprem\n" |
| 113 | "fnstsw %1\n" |
| 114 | : "=t" (result), "=m" (*sw) |
| 115 | : "0" (a), "u" (b) |
| 116 | : "st(1)"); |
| 117 | return result; |
| 118 | } |
| 119 | |
| 120 | static long double fprem1(long double a, long double b, uint16_t *sw) |
| 121 | { |
| 122 | long double result; |
| 123 | asm volatile ("fprem1\n" |
| 124 | "fnstsw %1\n" |
| 125 | : "=t" (result), "=m" (*sw) |
| 126 | : "0" (a), "u" (b) |
| 127 | : "st(1)"); |
| 128 | return result; |
| 129 | } |
| 130 | |
| 131 | #define FPUS_IE (1 << 0) |
| 132 | #define FPUS_DE (1 << 1) |
| 133 | #define FPUS_ZE (1 << 2) |
| 134 | #define FPUS_OE (1 << 3) |
| 135 | #define FPUS_UE (1 << 4) |
| 136 | #define FPUS_PE (1 << 5) |
| 137 | #define FPUS_SF (1 << 6) |
| 138 | #define FPUS_SE (1 << 7) |
| 139 | #define FPUS_C0 (1 << 8) |
| 140 | #define FPUS_C1 (1 << 9) |
| 141 | #define FPUS_C2 (1 << 10) |
| 142 | #define FPUS_TOP 0x3800 |
| 143 | #define FPUS_C3 (1 << 14) |
| 144 | #define FPUS_B (1 << 15) |
| 145 | |
| 146 | #define FPUS_EMASK 0x007f |
| 147 | |
| 148 | #define FPUC_EM 0x3f |
| 149 | |
| 150 | static void psw(uint16_t sw) |
| 151 | { |
| 152 | printf("SW: C3 TopC2C1C0\n"); |
| 153 | printf("SW: %c %d %3d %d %d %d %c %c %c %c %c %c %c %c\n", |
| 154 | sw & FPUS_B ? 'B' : 'b', |
| 155 | !!(sw & FPUS_C3), |
| 156 | (sw & FPUS_TOP) >> 11, |
| 157 | !!(sw & FPUS_C2), |
| 158 | !!(sw & FPUS_C1), |
| 159 | !!(sw & FPUS_C0), |
| 160 | (sw & FPUS_SE) ? 'S' : 's', |
| 161 | (sw & FPUS_SF) ? 'F' : 'f', |
| 162 | (sw & FPUS_PE) ? 'P' : 'p', |
| 163 | (sw & FPUS_UE) ? 'U' : 'u', |
| 164 | (sw & FPUS_OE) ? 'O' : 'o', |
| 165 | (sw & FPUS_ZE) ? 'Z' : 'z', |
| 166 | (sw & FPUS_DE) ? 'D' : 'd', |
| 167 | (sw & FPUS_IE) ? 'I' : 'i'); |
| 168 | } |
| 169 | |
| 170 | static void do_fprem(long double a, long double b) |
| 171 | { |
| 172 | const union float80u au = {.d = a}; |
| 173 | const union float80u bu = {.d = b}; |
| 174 | union float80u ru; |
| 175 | uint16_t sw; |
| 176 | |
| 177 | printf("A: S=%d Exp=%04x Int=%d (QNaN=%d) Sig=%016llx (%.06Le)\n", |
| 178 | au.ieee.negative, au.ieee.exponent, au.ieee.one, |
| 179 | au.ieee_nan.quiet_nan, (unsigned long long)au.ieee.mantissa, |
| 180 | a); |
| 181 | printf("B: S=%d Exp=%04x Int=%d (QNaN=%d) Sig=%016llx (%.06Le)\n", |
| 182 | bu.ieee.negative, bu.ieee.exponent, bu.ieee.one, |
| 183 | bu.ieee_nan.quiet_nan, (unsigned long long)bu.ieee.mantissa, |
| 184 | b); |
| 185 | fflush(stdout); |
| 186 | |
| 187 | fninit(); |
| 188 | ru.d = fprem(a, b, &sw); |
| 189 | psw(sw); |
| 190 | |
| 191 | printf("R : S=%d Exp=%04x Int=%d (QNaN=%d) Sig=%016llx (%.06Le)\n", |
| 192 | ru.ieee.negative, ru.ieee.exponent, ru.ieee.one, |
| 193 | ru.ieee_nan.quiet_nan, (unsigned long long)ru.ieee.mantissa, |
| 194 | ru.d); |
| 195 | |
| 196 | fninit(); |
| 197 | ru.d = fprem1(a, b, &sw); |
| 198 | psw(sw); |
| 199 | |
| 200 | printf("R1: S=%d Exp=%04x Int=%d (QNaN=%d) Sig=%016llx (%.06Le)\n", |
| 201 | ru.ieee.negative, ru.ieee.exponent, ru.ieee.one, |
| 202 | ru.ieee_nan.quiet_nan, (unsigned long long)ru.ieee.mantissa, |
| 203 | ru.d); |
| 204 | |
| 205 | printf("\n"); |
| 206 | } |
| 207 | |
| 208 | static void do_fprem_stack_underflow(void) |
| 209 | { |
| 210 | const long double a = 1.0; |
| 211 | union float80u ru; |
| 212 | uint16_t sw; |
| 213 | |
| 214 | fninit(); |
| 215 | asm volatile ("fprem\n" |
| 216 | "fnstsw %1\n" |
| 217 | : "=t" (ru.d), "=m" (sw) |
| 218 | : "0" (a) |
| 219 | : "st(1)"); |
| 220 | psw(sw); |
| 221 | |
| 222 | printf("R: S=%d Exp=%04x Int=%d (QNaN=%d) Sig=%016llx (%.06Le)\n", |
| 223 | ru.ieee.negative, ru.ieee.exponent, ru.ieee.one, |
| 224 | ru.ieee_nan.quiet_nan, (unsigned long long)ru.ieee.mantissa, |
| 225 | ru.d); |
| 226 | printf("\n"); |
| 227 | } |
| 228 | |
| 229 | static void test_fprem_cases(void) |
| 230 | { |
| 231 | printf("= stack underflow =\n"); |
| 232 | do_fprem_stack_underflow(); |
| 233 | |
| 234 | printf("= invalid operation =\n"); |
| 235 | do_fprem(q_nan.d, 1.0); |
| 236 | do_fprem(s_nan.d, 1.0); |
| 237 | do_fprem(1.0, 0.0); |
| 238 | do_fprem(pos_inf.d, 1.0); |
| 239 | do_fprem(pseudo_pos_inf.d, 1.0); |
| 240 | |
| 241 | printf("= denormal =\n"); |
| 242 | do_fprem(pos_denorm.d, 1.0); |
| 243 | do_fprem(1.0, pos_denorm.d); |
| 244 | |
| 245 | do_fprem(smallest_positive_norm.d, smallest_positive_norm.d); |
| 246 | |
| 247 | /* printf("= underflow =\n"); */ |
| 248 | /* TODO: Is there a case where FPREM raises underflow? */ |
| 249 | } |
| 250 | |
| 251 | static void test_fprem_pairs(void) |
| 252 | { |
| 253 | unsigned long long count; |
| 254 | |
| 255 | unsigned int negative_index_a = 0; |
| 256 | unsigned int negative_index_b = 0; |
| 257 | static const unsigned int negative_values[] = { |
| 258 | 0, |
| 259 | 1, |
| 260 | }; |
| 261 | |
| 262 | unsigned int exponent_index_a = 0; |
| 263 | unsigned int exponent_index_b = 0; |
| 264 | static const unsigned int exponent_values[] = { |
| 265 | 0, |
| 266 | 1, |
| 267 | 2, |
| 268 | IEEE854_LONG_DOUBLE_BIAS - 1, |
| 269 | IEEE854_LONG_DOUBLE_BIAS, |
| 270 | IEEE854_LONG_DOUBLE_BIAS + 1, |
| 271 | 0x7ffd, |
| 272 | 0x7ffe, |
| 273 | 0x7fff, |
| 274 | }; |
| 275 | |
| 276 | unsigned int one_index_a = 0; |
| 277 | unsigned int one_index_b = 0; |
| 278 | static const unsigned int one_values[] = { |
| 279 | 0, |
| 280 | 1, |
| 281 | }; |
| 282 | |
| 283 | unsigned int quiet_nan_index_a = 0; |
| 284 | unsigned int quiet_nan_index_b = 0; |
| 285 | static const unsigned int quiet_nan_values[] = { |
| 286 | 0, |
| 287 | 1, |
| 288 | }; |
| 289 | |
| 290 | unsigned int mantissa_index_a = 0; |
| 291 | unsigned int mantissa_index_b = 0; |
| 292 | static const unsigned long long mantissa_values[] = { |
| 293 | 0, |
| 294 | 1, |
| 295 | 2, |
| 296 | 0x3ffffffffffffffdULL, |
| 297 | 0x3ffffffffffffffeULL, |
| 298 | 0x3fffffffffffffffULL, |
| 299 | }; |
| 300 | |
| 301 | for (count = 0; ; ++count) { |
| 302 | #define INIT_FIELD(var, field) \ |
| 303 | .ieee_nan.field = field##_values[field##_index_##var] |
| 304 | const union float80u a = { |
| 305 | INIT_FIELD(a, negative), |
| 306 | INIT_FIELD(a, exponent), |
| 307 | INIT_FIELD(a, one), |
| 308 | INIT_FIELD(a, quiet_nan), |
| 309 | INIT_FIELD(a, mantissa), |
| 310 | }; |
| 311 | const union float80u b = { |
| 312 | INIT_FIELD(b, negative), |
| 313 | INIT_FIELD(b, exponent), |
| 314 | INIT_FIELD(b, one), |
| 315 | INIT_FIELD(b, quiet_nan), |
| 316 | INIT_FIELD(b, mantissa), |
| 317 | }; |
| 318 | #undef INIT_FIELD |
| 319 | |
| 320 | do_fprem(a.d, b.d); |
| 321 | |
| 322 | int carry = 1; |
| 323 | #define CARRY_INTO(var, field) do { \ |
| 324 | if (carry) { \ |
| 325 | if (++field##_index_##var == ARRAY_SIZE(field##_values)) { \ |
| 326 | field##_index_##var = 0; \ |
| 327 | } else { \ |
| 328 | carry = 0; \ |
| 329 | } \ |
| 330 | } \ |
| 331 | } while (0) |
| 332 | CARRY_INTO(b, mantissa); |
| 333 | CARRY_INTO(b, quiet_nan); |
| 334 | CARRY_INTO(b, one); |
| 335 | CARRY_INTO(b, exponent); |
| 336 | CARRY_INTO(b, negative); |
| 337 | CARRY_INTO(a, mantissa); |
| 338 | CARRY_INTO(a, quiet_nan); |
| 339 | CARRY_INTO(a, one); |
| 340 | CARRY_INTO(a, exponent); |
| 341 | CARRY_INTO(a, negative); |
| 342 | #undef CARRY_INTO |
| 343 | |
| 344 | if (carry) { |
| 345 | break; |
| 346 | } |
| 347 | } |
| 348 | |
| 349 | fprintf(stderr, "test-i386-fprem: tested %llu cases\n", count); |
| 350 | } |
| 351 | |
| 352 | int main(int argc, char **argv) |
| 353 | { |
| 354 | test_fprem_cases(); |
| 355 | test_fprem_pairs(); |
| 356 | return 0; |
| 357 | } |