[331] | 1 | /*
|
---|
| 2 | * Test 128-bit floating-point arithmetic on arm64:
|
---|
| 3 | * build with two different compilers and compare the output.
|
---|
| 4 | *
|
---|
| 5 | * Copyright (c) 2015 Edmund Grimley Evans
|
---|
| 6 | *
|
---|
| 7 | * Copying and distribution of this file, with or without modification,
|
---|
| 8 | * are permitted in any medium without royalty provided the copyright
|
---|
| 9 | * notice and this notice are preserved. This file is offered as-is,
|
---|
| 10 | * without any warranty.
|
---|
| 11 | */
|
---|
| 12 |
|
---|
| 13 | #include <stdint.h>
|
---|
| 14 | #include <stdio.h>
|
---|
| 15 | #include <stdlib.h>
|
---|
| 16 | #include <string.h>
|
---|
| 17 |
|
---|
| 18 | #define check(x) ((x) ? (void)0 : check_fail(#x, __FILE__, __LINE__))
|
---|
| 19 |
|
---|
| 20 | void check_fail(const char *assertion, const char *file, unsigned int line)
|
---|
| 21 | {
|
---|
| 22 | printf("%s:%d: Check (%s) failed.", file, line, assertion);
|
---|
| 23 | exit(1);
|
---|
| 24 | }
|
---|
| 25 |
|
---|
| 26 | typedef struct {
|
---|
| 27 | unsigned long long x0, x1;
|
---|
| 28 | } u128_t;
|
---|
| 29 |
|
---|
| 30 | float copy_fi(uint32_t x)
|
---|
| 31 | {
|
---|
| 32 | float f;
|
---|
| 33 | memcpy(&f, &x, 4);
|
---|
| 34 | return f;
|
---|
| 35 | }
|
---|
| 36 |
|
---|
| 37 | double copy_di(uint64_t x)
|
---|
| 38 | {
|
---|
| 39 | double f;
|
---|
| 40 | memcpy(&f, &x, 8);
|
---|
| 41 | return f;
|
---|
| 42 | }
|
---|
| 43 |
|
---|
| 44 | long double copy_ldi(u128_t x)
|
---|
| 45 | {
|
---|
| 46 | long double f;
|
---|
| 47 | memcpy(&f, &x, 16);
|
---|
| 48 | return f;
|
---|
| 49 | }
|
---|
| 50 |
|
---|
| 51 | uint32_t copy_if(float f)
|
---|
| 52 | {
|
---|
| 53 | uint32_t x;
|
---|
| 54 | memcpy(&x, &f, 4);
|
---|
| 55 | return x;
|
---|
| 56 | }
|
---|
| 57 |
|
---|
| 58 | uint64_t copy_id(double f)
|
---|
| 59 | {
|
---|
| 60 | uint64_t x;
|
---|
| 61 | memcpy(&x, &f, 8);
|
---|
| 62 | return x;
|
---|
| 63 | }
|
---|
| 64 |
|
---|
| 65 | u128_t copy_ild(long double f)
|
---|
| 66 | {
|
---|
| 67 | u128_t x;
|
---|
| 68 | memcpy(&x, &f, 16);
|
---|
| 69 | return x;
|
---|
| 70 | }
|
---|
| 71 |
|
---|
| 72 | long double make(int sgn, int exp, uint64_t high, uint64_t low)
|
---|
| 73 | {
|
---|
| 74 | u128_t x = { low,
|
---|
| 75 | (0x0000ffffffffffff & high) |
|
---|
| 76 | (0x7fff000000000000 & (uint64_t)exp << 48) |
|
---|
| 77 | (0x8000000000000000 & (uint64_t)sgn << 63) };
|
---|
| 78 | return copy_ldi(x);
|
---|
| 79 | }
|
---|
| 80 |
|
---|
| 81 | void cmp(long double a, long double b)
|
---|
| 82 | {
|
---|
| 83 | u128_t ax = copy_ild(a);
|
---|
| 84 | u128_t bx = copy_ild(b);
|
---|
| 85 | int eq = (a == b);
|
---|
| 86 | int ne = (a != b);
|
---|
| 87 | int lt = (a < b);
|
---|
| 88 | int le = (a <= b);
|
---|
| 89 | int gt = (a > b);
|
---|
| 90 | int ge = (a >= b);
|
---|
| 91 |
|
---|
| 92 | check(eq == 0 || eq == 1);
|
---|
| 93 | check(lt == 0 || lt == 1);
|
---|
| 94 | check(gt == 0 || gt == 1);
|
---|
| 95 | check(ne == !eq && le == (lt | eq) && ge == (gt | eq));
|
---|
| 96 | check(eq + lt + gt < 2);
|
---|
| 97 |
|
---|
| 98 | printf("cmp %016llx%016llx %016llx%016llx %d %d %d\n",
|
---|
| 99 | ax.x1, ax.x0, bx.x1, bx.x0, lt, eq, gt);
|
---|
| 100 | }
|
---|
| 101 |
|
---|
| 102 | void cmps(void)
|
---|
| 103 | {
|
---|
| 104 | int i, j;
|
---|
| 105 |
|
---|
| 106 | for (i = 0; i < 2; i++)
|
---|
| 107 | for (j = 0; j < 2; j++)
|
---|
| 108 | cmp(make(i, 0, 0, 0), make(j, 0, 0, 0));
|
---|
| 109 |
|
---|
| 110 | for (i = 0; i < 2; i++) {
|
---|
| 111 | for (j = 0; j < 64; j++) {
|
---|
| 112 | long double f1 = make(i, 32767, (uint64_t)1 << j, 0);
|
---|
| 113 | long double f2 = make(i, 32767, 0, (uint64_t)1 << j);
|
---|
| 114 | cmp(f1, 0);
|
---|
| 115 | cmp(f2, 0);
|
---|
| 116 | cmp(0, f1);
|
---|
| 117 | cmp(0, f2);
|
---|
| 118 | }
|
---|
| 119 | }
|
---|
| 120 |
|
---|
| 121 | for (i = 0; i < 6; i++)
|
---|
| 122 | for (j = 0; j < 6; j++)
|
---|
| 123 | cmp(make(i & 1, i >> 1, 0, 0),
|
---|
| 124 | make(j & 1, j >> 1, 0, 0));
|
---|
| 125 |
|
---|
| 126 | for (i = 0; i < 2; i++) {
|
---|
| 127 | for (j = 0; j < 2; j++) {
|
---|
| 128 | int a, b;
|
---|
| 129 | for (a = 0; a < 2; a++) {
|
---|
| 130 | for (b = 0; b < 2; b++) {
|
---|
| 131 | cmp(make(i, j, a, b), make(i, j, 0, 0));
|
---|
| 132 | cmp(make(i, j, 0, 0), make(i, j, a, b));
|
---|
| 133 | }
|
---|
| 134 | }
|
---|
| 135 | }
|
---|
| 136 | }
|
---|
| 137 | }
|
---|
| 138 |
|
---|
| 139 | void xop(const char *name, long double a, long double b, long double c)
|
---|
| 140 | {
|
---|
| 141 | u128_t ax = copy_ild(a);
|
---|
| 142 | u128_t bx = copy_ild(b);
|
---|
| 143 | u128_t cx = copy_ild(c);
|
---|
| 144 | printf("%s %016llx%016llx %016llx%016llx %016llx%016llx\n",
|
---|
| 145 | name, ax.x1, ax.x0, bx.x1, bx.x0, cx.x1, cx.x0);
|
---|
| 146 | }
|
---|
| 147 |
|
---|
| 148 | void fadd(long double a, long double b)
|
---|
| 149 | {
|
---|
| 150 | xop("add", a, b, a + b);
|
---|
| 151 | }
|
---|
| 152 |
|
---|
| 153 | void fsub(long double a, long double b)
|
---|
| 154 | {
|
---|
| 155 | xop("sub", a, b, a - b);
|
---|
| 156 | }
|
---|
| 157 |
|
---|
| 158 | void fmul(long double a, long double b)
|
---|
| 159 | {
|
---|
| 160 | xop("mul", a, b, a * b);
|
---|
| 161 | }
|
---|
| 162 |
|
---|
| 163 | void fdiv(long double a, long double b)
|
---|
| 164 | {
|
---|
| 165 | xop("div", a, b, a / b);
|
---|
| 166 | }
|
---|
| 167 |
|
---|
| 168 | void nanz(void)
|
---|
| 169 | {
|
---|
| 170 | // Check NaNs:
|
---|
| 171 | {
|
---|
| 172 | long double x[7];
|
---|
| 173 | int i, j, n = 0;
|
---|
| 174 | x[n++] = make(0, 32000, 0x95132b76effc, 0xd79035214b4f8d53);
|
---|
| 175 | x[n++] = make(1, 32001, 0xbe71d7a51587, 0x30601c6815d6c3ac);
|
---|
| 176 | x[n++] = make(0, 32767, 0, 1);
|
---|
| 177 | x[n++] = make(0, 32767, (uint64_t)1 << 46, 0);
|
---|
| 178 | x[n++] = make(1, 32767, (uint64_t)1 << 47, 0);
|
---|
| 179 | x[n++] = make(1, 32767, 0x7596c7099ad5, 0xe25fed2c58f73fc9);
|
---|
| 180 | x[n++] = make(0, 32767, 0x835d143360f9, 0x5e315efb35630666);
|
---|
| 181 | check(n == sizeof(x) / sizeof(*x));
|
---|
| 182 | for (i = 0; i < n; i++) {
|
---|
| 183 | for (j = 0; j < n; j++) {
|
---|
| 184 | fadd(x[i], x[j]);
|
---|
| 185 | fsub(x[i], x[j]);
|
---|
| 186 | fmul(x[i], x[j]);
|
---|
| 187 | fdiv(x[i], x[j]);
|
---|
| 188 | }
|
---|
| 189 | }
|
---|
| 190 | }
|
---|
| 191 |
|
---|
| 192 | // Check infinities and zeroes:
|
---|
| 193 | {
|
---|
| 194 | long double x[6];
|
---|
| 195 | int i, j, n = 0;
|
---|
| 196 | x[n++] = make(1, 32000, 0x62acda85f700, 0x47b6c9f35edc4044);
|
---|
| 197 | x[n++] = make(0, 32001, 0x94b7abf55af7, 0x9f425fe354428e19);
|
---|
| 198 | x[n++] = make(0, 32767, 0, 0);
|
---|
| 199 | x[n++] = make(1, 32767, 0, 0);
|
---|
| 200 | x[n++] = make(0, 0, 0, 0);
|
---|
| 201 | x[n++] = make(1, 0, 0, 0);
|
---|
| 202 | check(n == sizeof(x) / sizeof(*x));
|
---|
| 203 | for (i = 0; i < n; i++) {
|
---|
| 204 | for (j = 0; j < n; j++) {
|
---|
| 205 | fadd(x[i], x[j]);
|
---|
| 206 | fsub(x[i], x[j]);
|
---|
| 207 | fmul(x[i], x[j]);
|
---|
| 208 | fdiv(x[i], x[j]);
|
---|
| 209 | }
|
---|
| 210 | }
|
---|
| 211 | }
|
---|
| 212 | }
|
---|
| 213 |
|
---|
| 214 | void adds(void)
|
---|
| 215 | {
|
---|
| 216 | // Check shifting and add/sub:
|
---|
| 217 | {
|
---|
| 218 | int i;
|
---|
| 219 | for (i = -130; i <= 130; i++) {
|
---|
| 220 | int s1 = (uint32_t)i % 3 < 1;
|
---|
| 221 | int s2 = (uint32_t)i % 5 < 2;
|
---|
| 222 | fadd(make(s1, 16384 , 0x502c065e4f71a65d, 0xd2f9bdb031f4f031),
|
---|
| 223 | make(s2, 16384 + i, 0xae267395a9bc1033, 0xb56b5800da1ba448));
|
---|
| 224 | }
|
---|
| 225 | }
|
---|
| 226 |
|
---|
| 227 | // Check normalisation:
|
---|
| 228 | {
|
---|
| 229 | uint64_t a0 = 0xc6bab0a6afbef5ed;
|
---|
| 230 | uint64_t a1 = 0x4f84136c4a2e9b52;
|
---|
| 231 | int ee[] = { 0, 1, 10000 };
|
---|
| 232 | int e, i;
|
---|
| 233 | for (e = 0; e < sizeof(ee) / sizeof(*ee); e++) {
|
---|
| 234 | int exp = ee[e];
|
---|
| 235 | fsub(make(0, exp, a1, a0), make(0, 0, 0, 0));
|
---|
| 236 | for (i = 63; i >= 0; i--)
|
---|
| 237 | fsub(make(0, exp, a1 | (uint64_t)1 << i >> 1, a0),
|
---|
| 238 | make(0, exp, a1 >> i << i, 0));
|
---|
| 239 | for (i = 63; i >=0; i--)
|
---|
| 240 | fsub(make(0, exp, a1, a0 | (uint64_t)1 << i >> 1),
|
---|
| 241 | make(0, exp, a1, a0 >> i << i));
|
---|
| 242 | }
|
---|
| 243 | }
|
---|
| 244 |
|
---|
| 245 | // Carry/overflow from rounding:
|
---|
| 246 | {
|
---|
| 247 | fadd(make(0, 114, -1, -1), make(0, 1, 0, 0));
|
---|
| 248 | fadd(make(0, 32766, -1, -1), make(0, 32653, 0, 0));
|
---|
| 249 | fsub(make(1, 32766, -1, -1), make(0, 32653, 0, 0));
|
---|
| 250 | }
|
---|
| 251 | }
|
---|
| 252 |
|
---|
| 253 | void muls(void)
|
---|
| 254 | {
|
---|
| 255 | int i, j;
|
---|
| 256 |
|
---|
| 257 | {
|
---|
| 258 | long double max = make(0, 32766, -1, -1);
|
---|
| 259 | long double min = make(0, 0, 0, 1);
|
---|
| 260 | fmul(max, max);
|
---|
| 261 | fmul(max, min);
|
---|
| 262 | fmul(min, min);
|
---|
| 263 | }
|
---|
| 264 |
|
---|
| 265 | for (i = 117; i > 0; i--)
|
---|
| 266 | fmul(make(0, 16268, 0x643dcea76edc, 0xe0877a598403627a),
|
---|
| 267 | make(i & 1, i, 0, 0));
|
---|
| 268 |
|
---|
| 269 | fmul(make(0, 16383, -1, -3), make(0, 16383, 0, 1));
|
---|
| 270 | // Round to next exponent:
|
---|
| 271 | fmul(make(0, 16383, -1, -2), make(0, 16383, 0, 1));
|
---|
| 272 | // Round from subnormal to normal:
|
---|
| 273 | fmul(make(0, 1, -1, -1), make(0, 16382, 0, 0));
|
---|
| 274 |
|
---|
| 275 | for (i = 0; i < 2; i++)
|
---|
| 276 | for (j = 0; j < 112; j++)
|
---|
| 277 | fmul(make(0, 16383, (uint64_t)1 << i, 0),
|
---|
| 278 | make(0, 16383,
|
---|
| 279 | j < 64 ? 0 : (uint64_t)1 << (j - 64),
|
---|
| 280 | j < 64 ? (uint64_t)1 << j : 0));
|
---|
| 281 | }
|
---|
| 282 |
|
---|
| 283 | void divs(void)
|
---|
| 284 | {
|
---|
| 285 | int i;
|
---|
| 286 |
|
---|
| 287 | {
|
---|
| 288 | long double max = make(0, 32766, -1, -1);
|
---|
| 289 | long double min = make(0, 0, 0, 1);
|
---|
| 290 | fdiv(max, max);
|
---|
| 291 | fdiv(max, min);
|
---|
| 292 | fdiv(min, max);
|
---|
| 293 | fdiv(min, min);
|
---|
| 294 | }
|
---|
| 295 |
|
---|
| 296 | for (i = 0; i < 64; i++)
|
---|
| 297 | fdiv(make(0, 16383, -1, -1), make(0, 16383, -1, -(uint64_t)1 << i));
|
---|
| 298 | for (i = 0; i < 48; i++)
|
---|
| 299 | fdiv(make(0, 16383, -1, -1), make(0, 16383, -(uint64_t)1 << i, 0));
|
---|
| 300 | }
|
---|
| 301 |
|
---|
| 302 | void cvtlsw(int32_t a)
|
---|
| 303 | {
|
---|
| 304 | long double f = a;
|
---|
| 305 | u128_t x = copy_ild(f);
|
---|
| 306 | printf("cvtlsw %08lx %016llx%016llx\n", (long)(uint32_t)a, x.x1, x.x0);
|
---|
| 307 | }
|
---|
| 308 |
|
---|
| 309 | void cvtlsx(int64_t a)
|
---|
| 310 | {
|
---|
| 311 | long double f = a;
|
---|
| 312 | u128_t x = copy_ild(f);
|
---|
| 313 | printf("cvtlsx %016llx %016llx%016llx\n",
|
---|
| 314 | (long long)(uint64_t)a, x.x1, x.x0);
|
---|
| 315 | }
|
---|
| 316 |
|
---|
| 317 | void cvtluw(uint32_t a)
|
---|
| 318 | {
|
---|
| 319 | long double f = a;
|
---|
| 320 | u128_t x = copy_ild(f);
|
---|
| 321 | printf("cvtluw %08lx %016llx%016llx\n", (long)a, x.x1, x.x0);
|
---|
| 322 | }
|
---|
| 323 |
|
---|
| 324 | void cvtlux(uint64_t a)
|
---|
| 325 | {
|
---|
| 326 | long double f = a;
|
---|
| 327 | u128_t x = copy_ild(f);
|
---|
| 328 | printf("cvtlux %016llx %016llx%016llx\n", (long long)a, x.x1, x.x0);
|
---|
| 329 | }
|
---|
| 330 |
|
---|
| 331 | void cvtil(long double a)
|
---|
| 332 | {
|
---|
| 333 | u128_t x = copy_ild(a);
|
---|
| 334 | int32_t b1 = a;
|
---|
| 335 | int64_t b2 = a;
|
---|
| 336 | uint32_t b3 = a;
|
---|
| 337 | uint64_t b4 = a;
|
---|
| 338 | printf("cvtswl %016llx%016llx %08lx\n",
|
---|
| 339 | x.x1, x.x0, (long)(uint32_t)b1);
|
---|
| 340 | printf("cvtsxl %016llx%016llx %016llx\n",
|
---|
| 341 | x.x1, x.x0, (long long)(uint64_t)b2);
|
---|
| 342 | printf("cvtuwl %016llx%016llx %08lx\n",
|
---|
| 343 | x.x1, x.x0, (long)b3);
|
---|
| 344 | printf("cvtuxl %016llx%016llx %016llx\n",
|
---|
| 345 | x.x1, x.x0, (long long)b4);
|
---|
| 346 | }
|
---|
| 347 |
|
---|
| 348 | void cvtlf(float a)
|
---|
| 349 | {
|
---|
| 350 | uint32_t ax = copy_if(a);
|
---|
| 351 | long double b = a;
|
---|
| 352 | u128_t bx = copy_ild(b);
|
---|
| 353 | printf("cvtlf %08lx %016llx%016llx\n", (long)ax, bx.x1, bx.x0);
|
---|
| 354 | }
|
---|
| 355 |
|
---|
| 356 | void cvtld(double a)
|
---|
| 357 | {
|
---|
| 358 | uint64_t ax = copy_id(a);
|
---|
| 359 | long double b = a;
|
---|
| 360 | u128_t bx = copy_ild(b);
|
---|
| 361 | printf("cvtld %016llx %016llx%016llx\n", (long long)ax, bx.x1, bx.x0);
|
---|
| 362 | }
|
---|
| 363 |
|
---|
| 364 | void cvtfl(long double a)
|
---|
| 365 | {
|
---|
| 366 | u128_t ax = copy_ild(a);
|
---|
| 367 | float b = a;
|
---|
| 368 | uint32_t bx = copy_if(b);
|
---|
| 369 | printf("cvtfl %016llx%016llx %08lx\n", ax.x1, ax.x0, (long)bx);
|
---|
| 370 | }
|
---|
| 371 |
|
---|
| 372 | void cvtdl(long double a)
|
---|
| 373 | {
|
---|
| 374 | u128_t ax = copy_ild(a);
|
---|
| 375 | double b = a;
|
---|
| 376 | uint64_t bx = copy_id(b);
|
---|
| 377 | printf("cvtdl %016llx%016llx %016llx\n", ax.x1, ax.x0, (long long)bx);
|
---|
| 378 | }
|
---|
| 379 |
|
---|
| 380 | void cvts(void)
|
---|
| 381 | {
|
---|
| 382 | int i, j;
|
---|
| 383 |
|
---|
| 384 | {
|
---|
| 385 | uint32_t x = 0xad040c5b;
|
---|
| 386 | cvtlsw(0);
|
---|
| 387 | for (i = 0; i < 31; i++)
|
---|
| 388 | cvtlsw(x >> (31 - i));
|
---|
| 389 | for (i = 0; i < 31; i++)
|
---|
| 390 | cvtlsw(-(x >> (31 - i)));
|
---|
| 391 | cvtlsw(0x80000000);
|
---|
| 392 | }
|
---|
| 393 | {
|
---|
| 394 | uint64_t x = 0xb630a248cad9afd2;
|
---|
| 395 | cvtlsx(0);
|
---|
| 396 | for (i = 0; i < 63; i++)
|
---|
| 397 | cvtlsx(x >> (63 - i));
|
---|
| 398 | for (i = 0; i < 63; i++)
|
---|
| 399 | cvtlsx(-(x >> (63 - i)));
|
---|
| 400 | cvtlsx(0x8000000000000000);
|
---|
| 401 | }
|
---|
| 402 | {
|
---|
| 403 | uint32_t x = 0xad040c5b;
|
---|
| 404 | cvtluw(0);
|
---|
| 405 | for (i = 0; i < 32; i++)
|
---|
| 406 | cvtluw(x >> (31 - i));
|
---|
| 407 | }
|
---|
| 408 | {
|
---|
| 409 | uint64_t x = 0xb630a248cad9afd2;
|
---|
| 410 | cvtlux(0);
|
---|
| 411 | for (i = 0; i < 64; i++)
|
---|
| 412 | cvtlux(x >> (63 - i));
|
---|
| 413 | }
|
---|
| 414 |
|
---|
| 415 | for (i = 0; i < 2; i++) {
|
---|
| 416 | cvtil(make(i, 32767, 0, 1));
|
---|
| 417 | cvtil(make(i, 32767, (uint64_t)1 << 47, 0));
|
---|
| 418 | cvtil(make(i, 32767, 123, 456));
|
---|
| 419 | cvtil(make(i, 32767, 0, 0));
|
---|
| 420 | cvtil(make(i, 16382, -1, -1));
|
---|
| 421 | cvtil(make(i, 16383, -1, -1));
|
---|
| 422 | cvtil(make(i, 16384, 0x7fffffffffff, -1));
|
---|
| 423 | cvtil(make(i, 16384, 0x800000000000, 0));
|
---|
| 424 | for (j = 0; j < 68; j++)
|
---|
| 425 | cvtil(make(i, 16381 + j, 0xd4822c0a10ec, 0x1fe2f8b2669f5c9d));
|
---|
| 426 | }
|
---|
| 427 |
|
---|
| 428 | cvtlf(copy_fi(0x00000000));
|
---|
| 429 | cvtlf(copy_fi(0x456789ab));
|
---|
| 430 | cvtlf(copy_fi(0x7f800000));
|
---|
| 431 | cvtlf(copy_fi(0x7f923456));
|
---|
| 432 | cvtlf(copy_fi(0x7fdbcdef));
|
---|
| 433 | cvtlf(copy_fi(0x80000000));
|
---|
| 434 | cvtlf(copy_fi(0xabcdef12));
|
---|
| 435 | cvtlf(copy_fi(0xff800000));
|
---|
| 436 | cvtlf(copy_fi(0xff923456));
|
---|
| 437 | cvtlf(copy_fi(0xffdbcdef));
|
---|
| 438 |
|
---|
| 439 | cvtld(copy_di(0x0000000000000000));
|
---|
| 440 | cvtld(copy_di(0x456789abcdef0123));
|
---|
| 441 | cvtld(copy_di(0x7ff0000000000000));
|
---|
| 442 | cvtld(copy_di(0x7ff123456789abcd));
|
---|
| 443 | cvtld(copy_di(0x7ffabcdef1234567));
|
---|
| 444 | cvtld(copy_di(0x8000000000000000));
|
---|
| 445 | cvtld(copy_di(0xcdef123456789abc));
|
---|
| 446 | cvtld(copy_di(0xfff0000000000000));
|
---|
| 447 | cvtld(copy_di(0xfff123456789abcd));
|
---|
| 448 | cvtld(copy_di(0xfffabcdef1234567));
|
---|
| 449 |
|
---|
| 450 | for (i = 0; i < 2; i++) { \
|
---|
| 451 | cvtfl(make(i, 0, 0, 0));
|
---|
| 452 | cvtfl(make(i, 16232, -1, -1));
|
---|
| 453 | cvtfl(make(i, 16233, 0, 0));
|
---|
| 454 | cvtfl(make(i, 16233, 0, 1));
|
---|
| 455 | cvtfl(make(i, 16383, 0xab0ffd000000, 0));
|
---|
| 456 | cvtfl(make(i, 16383, 0xab0ffd000001, 0));
|
---|
| 457 | cvtfl(make(i, 16383, 0xab0ffeffffff, 0));
|
---|
| 458 | cvtfl(make(i, 16383, 0xab0fff000000, 0));
|
---|
| 459 | cvtfl(make(i, 16383, 0xab0fff000001, 0));
|
---|
| 460 | cvtfl(make(i, 16510, 0xfffffeffffff, -1));
|
---|
| 461 | cvtfl(make(i, 16510, 0xffffff000000, 0));
|
---|
| 462 | cvtfl(make(i, 16511, 0, 0));
|
---|
| 463 | cvtfl(make(i, 32767, 0, 0));
|
---|
| 464 | cvtfl(make(i, 32767, 0, 1));
|
---|
| 465 | cvtfl(make(i, 32767, 0x4cbe01ac5f40, 0x75cee3c6afbb00b5));
|
---|
| 466 | cvtfl(make(i, 32767, 0x800000000000, 1));
|
---|
| 467 | cvtfl(make(i, 32767, 0xa11caaaf6a52, 0x696033e871eab099));
|
---|
| 468 | }
|
---|
| 469 |
|
---|
| 470 | for (i = 0; i < 2; i++) {
|
---|
| 471 | cvtdl(make(i, 0, 0, 0));
|
---|
| 472 | cvtdl(make(i, 15307, -1, -1));
|
---|
| 473 | cvtdl(make(i, 15308, 0, 0));
|
---|
| 474 | cvtdl(make(i, 15308, 0, 1));
|
---|
| 475 | cvtdl(make(i, 16383, 0xabc123abc0ff, 0xe800000000000000));
|
---|
| 476 | cvtdl(make(i, 16383, 0xabc123abc0ff, 0xe800000000000001));
|
---|
| 477 | cvtdl(make(i, 16383, 0xabc123abc0ff, 0xf7ffffffffffffff));
|
---|
| 478 | cvtdl(make(i, 16383, 0xabc123abc0ff, 0xf800000000000000));
|
---|
| 479 | cvtdl(make(i, 16383, 0xabc123abc0ff, 0xf800000000000001));
|
---|
| 480 | cvtdl(make(i, 17406, 0xffffffffffff, 0xf7ffffffffffffff));
|
---|
| 481 | cvtdl(make(i, 17406, 0xffffffffffff, 0xf800000000000000));
|
---|
| 482 | cvtdl(make(i, 17407, 0, 0));
|
---|
| 483 | cvtdl(make(i, 32767, 0, 0));
|
---|
| 484 | cvtdl(make(i, 32767, 0, 1));
|
---|
| 485 | cvtdl(make(i, 32767, 0x4cbe01ac5f40, 0x75cee3c6afbb00b5));
|
---|
| 486 | cvtdl(make(i, 32767, 0x800000000000, 1));
|
---|
| 487 | cvtdl(make(i, 32767, 0xa11caaaf6a52, 0x696033e871eab099));
|
---|
| 488 | }
|
---|
| 489 | }
|
---|
| 490 |
|
---|
| 491 | void tests(void)
|
---|
| 492 | {
|
---|
| 493 | cmps();
|
---|
| 494 | nanz();
|
---|
| 495 | adds();
|
---|
| 496 | muls();
|
---|
| 497 | divs();
|
---|
| 498 | cvts();
|
---|
| 499 | }
|
---|
| 500 |
|
---|
| 501 | int main()
|
---|
| 502 | {
|
---|
| 503 | #ifdef __aarch64__
|
---|
| 504 | tests();
|
---|
| 505 | #else
|
---|
| 506 | printf("This test program is intended for a little-endian architecture\n"
|
---|
| 507 | "with an IEEE-standard 128-bit long double.\n");
|
---|
| 508 | #endif
|
---|
| 509 | return 0;
|
---|
| 510 | }
|
---|