This is an archive of the discontinued LLVM Phabricator instance.

Differential D53918

Compile and test i128 math builtins for Win64
ClosedPublic

Authored by rnk on Oct 30 2018, 6:47 PM.

Details

Reviewers
joerg
mstorsjo
Commits
rGdffe5a3807c8: Compile and test i128 math builtins for Win64
rL345796: Compile and test i128 math builtins for Win64
rCRT345796: Compile and test i128 math builtins for Win64
Summary

Windows has always been LLP64, not LP64, so the macros were incorrect.
Check for _WIN64, since AArch64 sets that too.

The tests have to be fixed up in two main ways:

  1. Use 'ULL' suffixes to avoid sign extension when passing hex literals with the sign bit set to signed 128 arguments. Clang -fms-compatibility makes such hex literals signed, not unsigned.
  2. Disable various tests for 80-bit long double interoperation with i128 values.

Diff Detail

Event Timeline

rnk created this revision.Oct 30 2018, 6:47 PM
Herald added subscribers: aheejin, hiraditya, kristof.beyls, javed.absar. · View Herald TranscriptOct 30 2018, 6:47 PM
Harbormaster completed remote builds in B24374: Diff 171857.Oct 30 2018, 6:47 PM
rnk updated this revision to Diff 171858.Oct 30 2018, 6:50 PM
  • remove unintended parts of the diff
Harbormaster completed remote builds in B24375: Diff 171858.Oct 30 2018, 6:50 PM
mstorsjo accepted this revision.Oct 31 2018, 1:41 AM

LGTM

This revision is now accepted and ready to land.Oct 31 2018, 1:41 AM
rnk added inline comments.Oct 31 2018, 3:00 PM
compiler-rt/lib/builtins/int_types.h
68–74

I went to test this with a variety of compilers before submitting, but basically, this part here is problematic in MSVC builds. In those builds, the builtins are built with the host compiler (cl.exe), but the tests are built with clang. So, the tests think i128 math is supported, but they all produce undefined symbol errors because the helper functions have been compiled out.

This needs more thought.

rnk updated this revision to Diff 172054.Oct 31 2018, 5:01 PM
  • lit test config thing
Herald added a subscriber: mgorny. · View Herald TranscriptOct 31 2018, 5:01 PM
Harbormaster completed remote builds in B24430: Diff 172054.Oct 31 2018, 5:02 PM
Closed by commit rCRT345796: Compile and test i128 math builtins for Win64 (authored by rnk). · Explain WhyOct 31 2018, 5:02 PM
This revision was automatically updated to reflect the committed changes.
Herald added a subscriber: Restricted Project. · View Herald TranscriptOct 31 2018, 5:02 PM

Revision Contents

PathSize
compiler-rt/
lib/
builtins/
11 lines
test/
builtins/
Unit/
20 lines
8 lines
4 lines
10 lines
10 lines
10 lines
10 lines
12 lines
6 lines

Diff 171858

compiler-rt/lib/builtins/int_types.h

Show First 20 Lines • Show All 54 Lines • ▼ Show 20 Lines#if _YUGA_LITTLE_ENDIAN
su_int high; su_int high;
#else #else
su_int high; su_int high;
su_int low; su_int low;
#endif /* _YUGA_LITTLE_ENDIAN */ #endif /* _YUGA_LITTLE_ENDIAN */
}s; }s;
} udwords; } udwords;
#if (defined(__LP64__) || defined(__wasm__) || defined(__mips64)) || defined(__riscv) #if defined(__LP64__) || defined(__wasm__) || defined(__mips64) || \
defined(__riscv) || defined(_WIN64)
#define CRT_HAS_128BIT #define CRT_HAS_128BIT
#endif #endif
/* MSVC doesn't have a working 128bit integer type. Users should really compile
* compiler-rt with clang, but if they happen to be doing a standalone build for
* asan or something else, disable the 128 bit parts so things sort of work.
*/
#if defined(_MSC_VER) && !defined(__clang__)
#undef CRT_HAS_128BIT
#endif
rnkAuthorUnsubmitted
Not Done
ReplyInline Actions

I went to test this with a variety of compilers before submitting, but basically, this part here is problematic in MSVC builds. In those builds, the builtins are built with the host compiler (cl.exe), but the tests are built with clang. So, the tests think i128 math is supported, but they all produce undefined symbol errors because the helper functions have been compiled out.

This needs more thought.

rnk: I went to test this with a variety of compilers before submitting, but basically, this part…
#ifdef CRT_HAS_128BIT #ifdef CRT_HAS_128BIT
typedef int ti_int __attribute__ ((mode (TI))); typedef int ti_int __attribute__ ((mode (TI)));
typedef unsigned tu_int __attribute__ ((mode (TI))); typedef unsigned tu_int __attribute__ ((mode (TI)));
typedef union typedef union
{ {
ti_int all; ti_int all;
struct struct
▲ Show 20 Lines • Show All 102 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/fixunsdfti_test.c

Show First 20 Lines • Show All 93 Lines • ▼ Show 20 Lines
#if !TARGET_LIBGCC #if !TARGET_LIBGCC
if (test__fixunsdfti(-0x1.FFFFFEp+62, 0)) if (test__fixunsdfti(-0x1.FFFFFEp+62, 0))
return 1; return 1;
if (test__fixunsdfti(-0x1.FFFFFCp+62, 0)) if (test__fixunsdfti(-0x1.FFFFFCp+62, 0))
return 1; return 1;
#endif #endif
if (test__fixunsdfti(0x1.FFFFFFFFFFFFFp+63, 0xFFFFFFFFFFFFF800LL)) if (test__fixunsdfti(0x1.FFFFFFFFFFFFFp+63, 0xFFFFFFFFFFFFF800ULL))
return 1; return 1;
if (test__fixunsdfti(0x1.0000000000000p+63, 0x8000000000000000LL)) if (test__fixunsdfti(0x1.0000000000000p+63, 0x8000000000000000ULL))
return 1; return 1;
if (test__fixunsdfti(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00LL)) if (test__fixunsdfti(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00ULL))
return 1; return 1;
if (test__fixunsdfti(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800LL)) if (test__fixunsdfti(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800ULL))
return 1; return 1;
if (test__fixunsdfti(0x1.FFFFFFFFFFFFFp+127, make_ti(0xFFFFFFFFFFFFF800LL, 0))) if (test__fixunsdfti(0x1.FFFFFFFFFFFFFp+127, make_ti(0xFFFFFFFFFFFFF800ULL, 0)))
return 1; return 1;
if (test__fixunsdfti(0x1.0000000000000p+127, make_ti(0x8000000000000000LL, 0))) if (test__fixunsdfti(0x1.0000000000000p+127, make_ti(0x8000000000000000ULL, 0)))
return 1; return 1;
if (test__fixunsdfti(0x1.FFFFFFFFFFFFFp+126, make_ti(0x7FFFFFFFFFFFFC00LL, 0))) if (test__fixunsdfti(0x1.FFFFFFFFFFFFFp+126, make_ti(0x7FFFFFFFFFFFFC00ULL, 0)))
return 1; return 1;
if (test__fixunsdfti(0x1.FFFFFFFFFFFFEp+126, make_ti(0x7FFFFFFFFFFFF800LL, 0))) if (test__fixunsdfti(0x1.FFFFFFFFFFFFEp+126, make_ti(0x7FFFFFFFFFFFF800ULL, 0)))
return 1; return 1;
if (test__fixunsdfti(0x1.0000000000000p+128, make_ti(0xFFFFFFFFFFFFFFFFLL, if (test__fixunsdfti(0x1.0000000000000p+128, make_ti(0xFFFFFFFFFFFFFFFFULL,
0xFFFFFFFFFFFFFFFFLL))) 0xFFFFFFFFFFFFFFFFULL)))
return 1; return 1;
#if !TARGET_LIBGCC #if !TARGET_LIBGCC
if (test__fixunsdfti(-0x1.FFFFFFFFFFFFFp+62, 0)) if (test__fixunsdfti(-0x1.FFFFFFFFFFFFFp+62, 0))
return 1; return 1;
if (test__fixunsdfti(-0x1.FFFFFFFFFFFFEp+62, 0)) if (test__fixunsdfti(-0x1.FFFFFFFFFFFFEp+62, 0))
return 1; return 1;
#endif #endif
#endif #endif
return 0; return 0;
} }

compiler-rt/test/builtins/Unit/fixunssfti_test.c

Show First 20 Lines • Show All 81 Lines • ▼ Show 20 Lines#if !TARGET_LIBGCC
if (test__fixunssfti(-1.99F, 0)) if (test__fixunssfti(-1.99F, 0))
return 1; return 1;
if (test__fixunssfti(-2.0F, 0)) if (test__fixunssfti(-2.0F, 0))
return 1; return 1;
if (test__fixunssfti(-2.01F, 0)) if (test__fixunssfti(-2.01F, 0))
return 1; return 1;
#endif #endif
if (test__fixunssfti(0x1.FFFFFEp+63F, 0xFFFFFF0000000000LL)) if (test__fixunssfti(0x1.FFFFFEp+63F, 0xFFFFFF0000000000ULL))
return 1; return 1;
if (test__fixunssfti(0x1.000000p+63F, 0x8000000000000000LL)) if (test__fixunssfti(0x1.000000p+63F, 0x8000000000000000ULL))
return 1; return 1;
if (test__fixunssfti(0x1.FFFFFEp+62F, 0x7FFFFF8000000000LL)) if (test__fixunssfti(0x1.FFFFFEp+62F, 0x7FFFFF8000000000LL))
return 1; return 1;
if (test__fixunssfti(0x1.FFFFFCp+62F, 0x7FFFFF0000000000LL)) if (test__fixunssfti(0x1.FFFFFCp+62F, 0x7FFFFF0000000000LL))
return 1; return 1;
if (test__fixunssfti(0x1.FFFFFEp+127F, make_ti(0xFFFFFF0000000000LL, 0))) if (test__fixunssfti(0x1.FFFFFEp+127F, make_ti(0xFFFFFF0000000000ULL, 0)))
return 1; return 1;
if (test__fixunssfti(0x1.000000p+127F, make_ti(0x8000000000000000LL, 0))) if (test__fixunssfti(0x1.000000p+127F, make_ti(0x8000000000000000ULL, 0)))
return 1; return 1;
if (test__fixunssfti(0x1.FFFFFEp+126F, make_ti(0x7FFFFF8000000000LL, 0))) if (test__fixunssfti(0x1.FFFFFEp+126F, make_ti(0x7FFFFF8000000000LL, 0)))
return 1; return 1;
if (test__fixunssfti(0x1.FFFFFCp+126F, make_ti(0x7FFFFF0000000000LL, 0))) if (test__fixunssfti(0x1.FFFFFCp+126F, make_ti(0x7FFFFF0000000000LL, 0)))
return 1; return 1;
#if !TARGET_LIBGCC #if !TARGET_LIBGCC
if (test__fixunssfti(-0x1.FFFFFEp+62F, 0x0000000000000000LL)) if (test__fixunssfti(-0x1.FFFFFEp+62F, 0x0000000000000000LL))
Show All 12 Lines

compiler-rt/test/builtins/Unit/fixunsxfti_test.c

Show All 11 Lines
// //
// This file tests __fixunsxfti for the compiler_rt library. // This file tests __fixunsxfti for the compiler_rt library.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
#ifdef CRT_HAS_128BIT #if defined(CRT_HAS_128BIT) && HAS_80_BIT_LONG_DOUBLE
// Returns: convert a to a unsigned long long, rounding toward zero. // Returns: convert a to a unsigned long long, rounding toward zero.
// Negative values all become zero. // Negative values all become zero.
// Assumption: long double is an intel 80 bit floating point type padded with 6 bytes // Assumption: long double is an intel 80 bit floating point type padded with 6 bytes
// tu_int is a 64 bit integral type // tu_int is a 64 bit integral type
// value in long double is representable in tu_int or is negative // value in long double is representable in tu_int or is negative
// (no range checking performed) // (no range checking performed)
Show All 21 Lines
char assumption_1[sizeof(tu_int) == 2*sizeof(du_int)] = {0}; char assumption_1[sizeof(tu_int) == 2*sizeof(du_int)] = {0};
char assumption_2[sizeof(tu_int)*CHAR_BIT == 128] = {0}; char assumption_2[sizeof(tu_int)*CHAR_BIT == 128] = {0};
char assumption_3[sizeof(long double)*CHAR_BIT == 128] = {0}; char assumption_3[sizeof(long double)*CHAR_BIT == 128] = {0};
#endif #endif
int main() int main()
{ {
#ifdef CRT_HAS_128BIT #if defined(CRT_HAS_128BIT) && HAS_80_BIT_LONG_DOUBLE
if (test__fixunsxfti(0.0, 0)) if (test__fixunsxfti(0.0, 0))
return 1; return 1;
if (test__fixunsxfti(0.5, 0)) if (test__fixunsxfti(0.5, 0))
return 1; return 1;
if (test__fixunsxfti(0.99, 0)) if (test__fixunsxfti(0.99, 0))
return 1; return 1;
if (test__fixunsxfti(1.0, 1)) if (test__fixunsxfti(1.0, 1))
▲ Show 20 Lines • Show All 78 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/fixxfti_test.c

Show All 11 Lines
// //
// This file tests __fixxfti for the compiler_rt library. // This file tests __fixxfti for the compiler_rt library.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "int_lib.h" #include "int_lib.h"
#include <stdio.h> #include <stdio.h>
#ifdef CRT_HAS_128BIT #if defined(CRT_HAS_128BIT) && HAS_80_BIT_LONG_DOUBLE
// Returns: convert a to a signed long long, rounding toward zero. // Returns: convert a to a signed long long, rounding toward zero.
// Assumption: long double is an intel 80 bit floating point type padded with 6 bytes // Assumption: long double is an intel 80 bit floating point type padded with 6 bytes
// su_int is a 32 bit integral type // su_int is a 32 bit integral type
// value in long double is representable in ti_int (no range checking performed) // value in long double is representable in ti_int (no range checking performed)
// gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee | // gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee |
Show All 11 Lines if (x != expected)
utwords expectedt; utwords expectedt;
expectedt.all = expected; expectedt.all = expected;
printf("error in __fixxfti(%LA) = 0x%.16llX%.16llX, expected 0x%.16llX%.16llX\n", printf("error in __fixxfti(%LA) = 0x%.16llX%.16llX, expected 0x%.16llX%.16llX\n",
a, xt.s.high, xt.s.low, expectedt.s.high, expectedt.s.low); a, xt.s.high, xt.s.low, expectedt.s.high, expectedt.s.low);
} }
return x != expected; return x != expected;
} }
char assumption_1[sizeof(ti_int) == 2*sizeof(di_int)] = {0}; COMPILE_TIME_ASSERT(sizeof(ti_int) == 2*sizeof(di_int));
char assumption_2[sizeof(su_int)*CHAR_BIT == 32] = {0}; COMPILE_TIME_ASSERT(sizeof(su_int)*CHAR_BIT == 32);
char assumption_3[sizeof(long double)*CHAR_BIT == 128] = {0}; COMPILE_TIME_ASSERT(sizeof(long double)*CHAR_BIT == 128);
#endif #endif
int main() int main()
{ {
#ifdef CRT_HAS_128BIT #if defined(CRT_HAS_128BIT) && HAS_80_BIT_LONG_DOUBLE
if (test__fixxfti(0.0, 0)) if (test__fixxfti(0.0, 0))
return 1; return 1;
if (test__fixxfti(0.5, 0)) if (test__fixxfti(0.5, 0))
return 1; return 1;
if (test__fixxfti(0.99, 0)) if (test__fixxfti(0.99, 0))
return 1; return 1;
if (test__fixxfti(1.0, 1)) if (test__fixxfti(1.0, 1))
▲ Show 20 Lines • Show All 85 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/floattixf_test.c

Show All 12 Lines
// This file tests __floattixf for the compiler_rt library. // This file tests __floattixf for the compiler_rt library.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "int_lib.h" #include "int_lib.h"
#include <float.h> #include <float.h>
#include <stdio.h> #include <stdio.h>
#ifdef CRT_HAS_128BIT #if defined(CRT_HAS_128BIT) && HAS_80_BIT_LONG_DOUBLE
// Returns: convert a to a long double, rounding toward even. // Returns: convert a to a long double, rounding toward even.
// Assumption: long double is a IEEE 80 bit floating point type padded to 128 bits // Assumption: long double is a IEEE 80 bit floating point type padded to 128 bits
// ti_int is a 128 bit integral type // ti_int is a 128 bit integral type
// gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee | // gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee |
// 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm // 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
COMPILER_RT_ABI long double __floattixf(ti_int a); COMPILER_RT_ABI long double __floattixf(ti_int a);
int test__floattixf(ti_int a, long double expected) int test__floattixf(ti_int a, long double expected)
{ {
long double x = __floattixf(a); long double x = __floattixf(a);
if (x != expected) if (x != expected)
{ {
twords at; twords at;
at.all = a; at.all = a;
printf("error in __floattixf(0x%.16llX%.16llX) = %LA, expected %LA\n", printf("error in __floattixf(0x%.16llX%.16llX) = %LA, expected %LA\n",
at.s.high, at.s.low, x, expected); at.s.high, at.s.low, x, expected);
} }
return x != expected; return x != expected;
} }
char assumption_1[sizeof(ti_int) == 2*sizeof(di_int)] = {0}; COMPILE_TIME_ASSERT(sizeof(ti_int) == 2*sizeof(di_int));
char assumption_2[sizeof(ti_int)*CHAR_BIT == 128] = {0}; COMPILE_TIME_ASSERT(sizeof(ti_int)*CHAR_BIT == 128);
char assumption_3[sizeof(long double)*CHAR_BIT == 128] = {0}; COMPILE_TIME_ASSERT(sizeof(long double)*CHAR_BIT == 128);
#endif #endif
int main() int main()
{ {
#ifdef CRT_HAS_128BIT #if defined(CRT_HAS_128BIT) && HAS_80_BIT_LONG_DOUBLE
if (test__floattixf(0, 0.0)) if (test__floattixf(0, 0.0))
return 1; return 1;
if (test__floattixf(1, 1.0)) if (test__floattixf(1, 1.0))
return 1; return 1;
if (test__floattixf(2, 2.0)) if (test__floattixf(2, 2.0))
return 1; return 1;
if (test__floattixf(20, 20.0)) if (test__floattixf(20, 20.0))
▲ Show 20 Lines • Show All 153 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/floatuntisf_test.c

Show All 10 Lines
// This file tests __floatuntisf for the compiler_rt library. // This file tests __floatuntisf for the compiler_rt library.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "int_lib.h" #include "int_lib.h"
#include <float.h> #include <float.h>
#include <stdio.h> #include <stdio.h>
#ifdef CRT_HAS_128BIT #if defined(CRT_HAS_128BIT) && HAS_80_BIT_LONG_DOUBLE
// Returns: convert a to a float, rounding toward even. // Returns: convert a to a float, rounding toward even.
// Assumption: float is a IEEE 32 bit floating point type // Assumption: float is a IEEE 32 bit floating point type
// tu_int is a 128 bit integral type // tu_int is a 128 bit integral type
// seee eeee emmm mmmm mmmm mmmm mmmm mmmm // seee eeee emmm mmmm mmmm mmmm mmmm mmmm
COMPILER_RT_ABI float __floatuntisf(tu_int a); COMPILER_RT_ABI float __floatuntisf(tu_int a);
int test__floatuntisf(tu_int a, float expected) int test__floatuntisf(tu_int a, float expected)
{ {
float x = __floatuntisf(a); float x = __floatuntisf(a);
if (x != expected) if (x != expected)
{ {
utwords at; utwords at;
at.all = a; at.all = a;
printf("error in __floatuntisf(0x%.16llX%.16llX) = %a, expected %a\n", printf("error in __floatuntisf(0x%.16llX%.16llX) = %a, expected %a\n",
at.s.high, at.s.low, x, expected); at.s.high, at.s.low, x, expected);
} }
return x != expected; return x != expected;
} }
char assumption_1[sizeof(tu_int) == 2*sizeof(du_int)] = {0}; COMPILE_TIME_ASSERT(sizeof(tu_int) == 2*sizeof(du_int));
char assumption_2[sizeof(tu_int)*CHAR_BIT == 128] = {0}; COMPILE_TIME_ASSERT(sizeof(tu_int)*CHAR_BIT == 128);
char assumption_3[sizeof(float)*CHAR_BIT == 32] = {0}; COMPILE_TIME_ASSERT(sizeof(float)*CHAR_BIT == 32);
#endif #endif
int main() int main()
{ {
#ifdef CRT_HAS_128BIT #if defined(CRT_HAS_128BIT) && HAS_80_BIT_LONG_DOUBLE
if (test__floatuntisf(0, 0.0F)) if (test__floatuntisf(0, 0.0F))
return 1; return 1;
if (test__floatuntisf(1, 1.0F)) if (test__floatuntisf(1, 1.0F))
return 1; return 1;
if (test__floatuntisf(2, 2.0F)) if (test__floatuntisf(2, 2.0F))
return 1; return 1;
if (test__floatuntisf(20, 20.0F)) if (test__floatuntisf(20, 20.0F))
▲ Show 20 Lines • Show All 107 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/floatuntixf_test.c

Show All 12 Lines
// This file tests __floatuntixf for the compiler_rt library. // This file tests __floatuntixf for the compiler_rt library.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "int_lib.h" #include "int_lib.h"
#include <float.h> #include <float.h>
#include <stdio.h> #include <stdio.h>
#ifdef CRT_HAS_128BIT #if defined(CRT_HAS_128BIT) && HAS_80_BIT_LONG_DOUBLE
// Returns: convert a to a long double, rounding toward even. // Returns: convert a to a long double, rounding toward even.
// Assumption: long double is a IEEE 80 bit floating point type padded to 128 bits // Assumption: long double is a IEEE 80 bit floating point type padded to 128 bits
// tu_int is a 128 bit integral type // tu_int is a 128 bit integral type
// gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee | // gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee |
// 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm // 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm
COMPILER_RT_ABI long double __floatuntixf(tu_int a); COMPILER_RT_ABI long double __floatuntixf(tu_int a);
int test__floatuntixf(tu_int a, long double expected) int test__floatuntixf(tu_int a, long double expected)
{ {
long double x = __floatuntixf(a); long double x = __floatuntixf(a);
if (x != expected) if (x != expected)
{ {
utwords at; utwords at;
at.all = a; at.all = a;
printf("error in __floatuntixf(0x%.16llX%.16llX) = %LA, expected %LA\n", printf("error in __floatuntixf(0x%.16llX%.16llX) = %LA, expected %LA\n",
at.s.high, at.s.low, x, expected); at.s.high, at.s.low, x, expected);
} }
return x != expected; return x != expected;
} }
char assumption_1[sizeof(tu_int) == 2*sizeof(du_int)] = {0}; COMPILE_TIME_ASSERT(sizeof(tu_int) == 2*sizeof(du_int));
char assumption_2[sizeof(tu_int)*CHAR_BIT == 128] = {0}; COMPILE_TIME_ASSERT(sizeof(tu_int)*CHAR_BIT == 128);
char assumption_3[sizeof(long double)*CHAR_BIT == 128] = {0}; COMPILE_TIME_ASSERT(sizeof(long double)*CHAR_BIT == 128);
#endif #endif
int main() int main()
{ {
#ifdef CRT_HAS_128BIT #if defined(CRT_HAS_128BIT) && HAS_80_BIT_LONG_DOUBLE
if (test__floatuntixf(0, 0.0)) if (test__floatuntixf(0, 0.0))
return 1; return 1;
if (test__floatuntixf(1, 1.0)) if (test__floatuntixf(1, 1.0))
return 1; return 1;
if (test__floatuntixf(2, 2.0)) if (test__floatuntixf(2, 2.0))
return 1; return 1;
if (test__floatuntixf(20, 20.0)) if (test__floatuntixf(20, 20.0))
▲ Show 20 Lines • Show All 160 Lines • Show Last 20 Lines

compiler-rt/test/builtins/Unit/modti3_test.c

Show First 20 Lines • Show All 57 Lines • ▼ Show 20 Lines if (test__modti3(5, 3, 2))
return 1; return 1;
if (test__modti3(5, -3, 2)) if (test__modti3(5, -3, 2))
return 1; return 1;
if (test__modti3(-5, 3, -2)) if (test__modti3(-5, 3, -2))
return 1; return 1;
if (test__modti3(-5, -3, -2)) if (test__modti3(-5, -3, -2))
return 1; return 1;
if (test__modti3(0x8000000000000000LL, 1, 0x0LL)) if (test__modti3(0x8000000000000000ULL, 1, 0x0LL))
return 1; return 1;
if (test__modti3(0x8000000000000000LL, -1, 0x0LL)) if (test__modti3(0x8000000000000000ULL, -1, 0x0LL))
return 1; return 1;
if (test__modti3(0x8000000000000000LL, 2, 0x0LL)) if (test__modti3(0x8000000000000000ULL, 2, 0x0LL))
return 1; return 1;
if (test__modti3(0x8000000000000000LL, -2, 0x0LL)) if (test__modti3(0x8000000000000000ULL, -2, 0x0LL))
return 1; return 1;
if (test__modti3(0x8000000000000000LL, 3, 2)) if (test__modti3(0x8000000000000000ULL, 3, 2))
return 1; return 1;
if (test__modti3(0x8000000000000000LL, -3, 2)) if (test__modti3(0x8000000000000000ULL, -3, 2))
return 1; return 1;
if (test__modti3(make_ti(0x8000000000000000LL, 0), 1, 0x0LL)) if (test__modti3(make_ti(0x8000000000000000LL, 0), 1, 0x0LL))
return 1; return 1;
if (test__modti3(make_ti(0x8000000000000000LL, 0), -1, 0x0LL)) if (test__modti3(make_ti(0x8000000000000000LL, 0), -1, 0x0LL))
return 1; return 1;
if (test__modti3(make_ti(0x8000000000000000LL, 0), 2, 0x0LL)) if (test__modti3(make_ti(0x8000000000000000LL, 0), 2, 0x0LL))
return 1; return 1;
Show All 12 Lines

compiler-rt/test/builtins/Unit/mulvti3_test.c

Show First 20 Lines • Show All 93 Lines • ▼ Show 20 Lines if (test__mulvti3(1, -10, -10))
return 1; return 1;
if (test__mulvti3(-10, 1, -10)) if (test__mulvti3(-10, 1, -10))
return 1; return 1;
if (test__mulvti3(1, -81985529216486895LL, -81985529216486895LL)) if (test__mulvti3(1, -81985529216486895LL, -81985529216486895LL))
return 1; return 1;
if (test__mulvti3(-81985529216486895LL, 1, -81985529216486895LL)) if (test__mulvti3(-81985529216486895LL, 1, -81985529216486895LL))
return 1; return 1;
if (test__mulvti3(3037000499LL, 3037000499LL, 9223372030926249001LL)) if (test__mulvti3(3037000499LL, 3037000499LL, 9223372030926249001ULL))
return 1; return 1;
if (test__mulvti3(-3037000499LL, 3037000499LL, -9223372030926249001LL)) if (test__mulvti3(-3037000499LL, 3037000499LL, -9223372030926249001LL))
return 1; return 1;
if (test__mulvti3(3037000499LL, -3037000499LL, -9223372030926249001LL)) if (test__mulvti3(3037000499LL, -3037000499LL, -9223372030926249001LL))
return 1; return 1;
if (test__mulvti3(-3037000499LL, -3037000499LL, 9223372030926249001LL)) if (test__mulvti3(-3037000499LL, -3037000499LL, 9223372030926249001ULL))
return 1; return 1;
if (test__mulvti3(4398046511103LL, 2097152LL, 9223372036852678656LL)) if (test__mulvti3(4398046511103LL, 2097152LL, 9223372036852678656LL))
return 1; return 1;
if (test__mulvti3(-4398046511103LL, 2097152LL, -9223372036852678656LL)) if (test__mulvti3(-4398046511103LL, 2097152LL, -9223372036852678656LL))
return 1; return 1;
if (test__mulvti3(4398046511103LL, -2097152LL, -9223372036852678656LL)) if (test__mulvti3(4398046511103LL, -2097152LL, -9223372036852678656LL))
return 1; return 1;
if (test__mulvti3(-4398046511103LL, -2097152LL, 9223372036852678656LL)) if (test__mulvti3(-4398046511103LL, -2097152LL, 9223372036852678656LL))
return 1; return 1;
if (test__mulvti3(2097152LL, 4398046511103LL, 9223372036852678656LL)) if (test__mulvti3(2097152LL, 4398046511103LL, 9223372036852678656ULL))
return 1; return 1;
if (test__mulvti3(-2097152LL, 4398046511103LL, -9223372036852678656LL)) if (test__mulvti3(-2097152LL, 4398046511103LL, -9223372036852678656LL))
return 1; return 1;
if (test__mulvti3(2097152LL, -4398046511103LL, -9223372036852678656LL)) if (test__mulvti3(2097152LL, -4398046511103LL, -9223372036852678656LL))
return 1; return 1;
if (test__mulvti3(-2097152LL, -4398046511103LL, 9223372036852678656LL)) if (test__mulvti3(-2097152LL, -4398046511103LL, 9223372036852678656LL))
return 1; return 1;
▲ Show 20 Lines • Show All 133 Lines • Show Last 20 Lines