Compile and test i128 math builtins for Win64

[rnk]

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.

[rnk]

• remove unintended parts of the diff

[mstorsjo]

LGTM

[rnk]

compiler-rt/lib/builtins/int_types.h

68–74 ↗

(On Diff #171858)

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]

• lit test config thing

lib/builtins/int_types.h

#if _YUGA_LITTLE_ENDIAN
         su_int high;
 #else
         su_int high;
         su_int low;
 #endif /* _YUGA_LITTLE_ENDIAN */
     }s;
 } 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
 #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
+
 #ifdef CRT_HAS_128BIT
 typedef int      ti_int __attribute__ ((mode (TI)));
 typedef unsigned tu_int __attribute__ ((mode (TI)));
 
 typedef union
 {
     ti_int all;
     struct

test/builtins/CMakeLists.txt

 set(BUILTINS_LIT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
 
 set(BUILTINS_TEST_DEPS ${SANITIZER_COMMON_LIT_TEST_DEPS} builtins)
 set(BUILTINS_TESTSUITES ${CMAKE_CURRENT_BINARY_DIR}/TestCases)
 
 # Test cases.
 configure_lit_site_cfg(
   ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in
   ${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg
 )
 
 #Unit tests.
 
 include(builtin-config-ix)
 
+# Indicate if this is an MSVC environment.
 pythonize_bool(MSVC)
 
+# Indicate if the compiler for the builtins library was MSVC. If the builtins
+# compiler was clang-cl, we will enable some features that the host compiler
+# will not, like C99 _Complex and int128.
+set(BUILTINS_IS_MSVC OFF)
+if (MSVC AND NOT "${CMAKE_C_COMPILER_ID}" MATCHES "Clang")
+  set(BUILTINS_IS_MSVC ON)
+endif()
+pythonize_bool(BUILTINS_IS_MSVC)
+
 #TODO: Add support for Apple.
 if (NOT APPLE)
 foreach(arch ${BUILTIN_SUPPORTED_ARCH})
   set(BUILTINS_TEST_TARGET_ARCH ${arch})
   string(TOLOWER "-${arch}-${OS_NAME}" BUILTINS_TEST_CONFIG_SUFFIX)
   get_test_cc_for_arch(${arch} BUILTINS_TEST_TARGET_CC BUILTINS_TEST_TARGET_CFLAGS)
   if (${arch} STREQUAL "armhf")
     list(APPEND BUILTINS_TEST_TARGET_CFLAGS -fomit-frame-pointer -DCOMPILER_RT_ARMHF_TARGET)

test/builtins/Unit/absvti2_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
+// REQUIRES: int128
 //===-- absvti2_test.c - Test __absvti2 -----------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

test/builtins/Unit/addvti3_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
+// REQUIRES: int128
 //===-- addvti3_test.c - Test __addvti3 -----------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

test/builtins/Unit/ashlti3_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
+// REQUIRES: int128
 //===-- ashlti3_test.c - Test __ashlti3 -----------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

test/builtins/Unit/ashrti3_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
+// REQUIRES: int128
 //===-- ashrti3_test.c - Test __ashrti3 -----------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

test/builtins/Unit/clzti2_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
+// REQUIRES: int128
 //===-- clzti2_test.c - Test __clzti2 -------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

test/builtins/Unit/cmpti2_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
+// REQUIRES: int128
 //===-- cmpti2_test.c - Test __cmpti2 -------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

test/builtins/Unit/ctzti2_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
+// REQUIRES: int128
 //===-- ctzti2_test.c - Test __ctzti2 -------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

test/builtins/Unit/divti3_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
+// REQUIRES: int128
 //===-- divti3_test.c - Test __divti3 -------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

test/builtins/Unit/ffsti2_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
+// REQUIRES: int128
 //===-- ffsti2_test.c - Test __ffsti2 -------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

test/builtins/Unit/fixdfti_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
+// REQUIRES: int128
 //===-- fixdfti_test.c - Test __fixdfti -----------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

test/builtins/Unit/fixsfti_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
+// REQUIRES: int128
 //===-- fixsfti_test.c - Test __fixsfti -----------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

test/builtins/Unit/fixunsdfti_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
+// REQUIRES: int128
 //===-- fixunsdfti_test.c - Test __fixunsdfti -----------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

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

test/builtins/Unit/fixunssfti_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
+// REQUIRES: int128
 //===-- fixunssfti_test.c - Test __fixunssfti -----------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
#if !TARGET_LIBGCC
     if (test__fixunssfti(-1.99F, 0))
         return 1;
     if (test__fixunssfti(-2.0F, 0))
         return 1;
     if (test__fixunssfti(-2.01F, 0))
         return 1;
 #endif
 
-    if (test__fixunssfti(0x1.FFFFFEp+63F, 0xFFFFFF0000000000LL))
+    if (test__fixunssfti(0x1.FFFFFEp+63F, 0xFFFFFF0000000000ULL))
         return 1;
-    if (test__fixunssfti(0x1.000000p+63F, 0x8000000000000000LL))
+    if (test__fixunssfti(0x1.000000p+63F, 0x8000000000000000ULL))
         return 1;
     if (test__fixunssfti(0x1.FFFFFEp+62F, 0x7FFFFF8000000000LL))
         return 1;
     if (test__fixunssfti(0x1.FFFFFCp+62F, 0x7FFFFF0000000000LL))
         return 1;
 
-    if (test__fixunssfti(0x1.FFFFFEp+127F, make_ti(0xFFFFFF0000000000LL, 0)))
+    if (test__fixunssfti(0x1.FFFFFEp+127F, make_ti(0xFFFFFF0000000000ULL, 0)))
         return 1;
-    if (test__fixunssfti(0x1.000000p+127F, make_ti(0x8000000000000000LL, 0)))
+    if (test__fixunssfti(0x1.000000p+127F, make_ti(0x8000000000000000ULL, 0)))
         return 1;
     if (test__fixunssfti(0x1.FFFFFEp+126F, make_ti(0x7FFFFF8000000000LL, 0)))
         return 1;
     if (test__fixunssfti(0x1.FFFFFCp+126F, make_ti(0x7FFFFF0000000000LL, 0)))
         return 1;
 
 #if !TARGET_LIBGCC
     if (test__fixunssfti(-0x1.FFFFFEp+62F, 0x0000000000000000LL))

test/builtins/Unit/fixunsxfti_test.c

 //
 // This file tests __fixunsxfti for the compiler_rt library.
 //
 //===----------------------------------------------------------------------===//
 
 #include "int_lib.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.
 //          Negative values all become zero.
 
 // Assumption: long double is an intel 80 bit floating point type padded with 6 bytes
 //             tu_int is a 64 bit integral type
 //             value in long double is representable in tu_int or is negative 
 //                 (no range checking performed)

 char assumption_1[sizeof(tu_int) == 2*sizeof(du_int)] = {0};
 char assumption_2[sizeof(tu_int)*CHAR_BIT == 128] = {0};
 char assumption_3[sizeof(long double)*CHAR_BIT == 128] = {0};
 
 #endif
 
 int main()
 {
-#ifdef CRT_HAS_128BIT
+#if defined(CRT_HAS_128BIT) && HAS_80_BIT_LONG_DOUBLE
     if (test__fixunsxfti(0.0, 0))
         return 1;
 
     if (test__fixunsxfti(0.5, 0))
         return 1;
     if (test__fixunsxfti(0.99, 0))
         return 1;
     if (test__fixunsxfti(1.0, 1))

test/builtins/Unit/fixxfti_test.c

 //
 // This file tests __fixxfti for the compiler_rt library.
 //
 //===----------------------------------------------------------------------===//
 
 #include "int_lib.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.
 
 // Assumption: long double is an intel 80 bit floating point type padded with 6 bytes
 //             su_int is a 32 bit integral type
 //             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 |
if (x != expected)
         utwords expectedt;
         expectedt.all = expected;
         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);
     }
     return x != expected;
 }
 
-char assumption_1[sizeof(ti_int) == 2*sizeof(di_int)] = {0};
-char assumption_2[sizeof(su_int)*CHAR_BIT == 32] = {0};
-char assumption_3[sizeof(long double)*CHAR_BIT == 128] = {0};
+COMPILE_TIME_ASSERT(sizeof(ti_int) == 2*sizeof(di_int));
+COMPILE_TIME_ASSERT(sizeof(su_int)*CHAR_BIT == 32);
+COMPILE_TIME_ASSERT(sizeof(long double)*CHAR_BIT == 128);
 
 #endif
 
 int main()
 {
-#ifdef CRT_HAS_128BIT
+#if defined(CRT_HAS_128BIT) && HAS_80_BIT_LONG_DOUBLE
     if (test__fixxfti(0.0, 0))
         return 1;
 
     if (test__fixxfti(0.5, 0))
         return 1;
     if (test__fixxfti(0.99, 0))
         return 1;
     if (test__fixxfti(1.0, 1))

test/builtins/Unit/floattidf_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
+// REQUIRES: int128
 //===-- floattidf.c - Test __floattidf ------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

test/builtins/Unit/floattisf_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
+// REQUIRES: int128
 //===-- floattisf_test.c - Test __floattisf -------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

test/builtins/Unit/floattixf_test.c

 // This file tests __floattixf for the compiler_rt library.
 //
 //===----------------------------------------------------------------------===//
 
 #include "int_lib.h"
 #include <float.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.
 
 // Assumption: long double is a IEEE 80 bit floating point type padded to 128 bits
 //             ti_int is a 128 bit integral type
 
 // 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
 
 COMPILER_RT_ABI long double __floattixf(ti_int a);
 
 int test__floattixf(ti_int a, long double expected)
 {
     long double x = __floattixf(a);
     if (x != expected)
     {
         twords at;
         at.all = a;
         printf("error in __floattixf(0x%.16llX%.16llX) = %LA, expected %LA\n",
                at.s.high, at.s.low, x, expected);
     }
     return x != expected;
 }
 
-char assumption_1[sizeof(ti_int) == 2*sizeof(di_int)] = {0};
-char assumption_2[sizeof(ti_int)*CHAR_BIT == 128] = {0};
-char assumption_3[sizeof(long double)*CHAR_BIT == 128] = {0};
+COMPILE_TIME_ASSERT(sizeof(ti_int) == 2*sizeof(di_int));
+COMPILE_TIME_ASSERT(sizeof(ti_int)*CHAR_BIT == 128);
+COMPILE_TIME_ASSERT(sizeof(long double)*CHAR_BIT == 128);
 
 #endif
 
 int main()
 {
-#ifdef CRT_HAS_128BIT
+#if defined(CRT_HAS_128BIT) && HAS_80_BIT_LONG_DOUBLE
     if (test__floattixf(0, 0.0))
         return 1;
 
     if (test__floattixf(1, 1.0))
         return 1;
     if (test__floattixf(2, 2.0))
         return 1;
     if (test__floattixf(20, 20.0))

test/builtins/Unit/floatuntidf_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
+// REQUIRES: int128
 //===-- floatuntidf.c - Test __floatuntidf --------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

test/builtins/Unit/floatuntisf_test.c

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

test/builtins/Unit/floatuntixf_test.c

 // This file tests __floatuntixf for the compiler_rt library.
 //
 //===----------------------------------------------------------------------===//
 
 #include "int_lib.h"
 #include <float.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.
 
 // Assumption: long double is a IEEE 80 bit floating point type padded to 128 bits
 //             tu_int is a 128 bit integral type
 
 // 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
 
 COMPILER_RT_ABI long double __floatuntixf(tu_int a);
 
 int test__floatuntixf(tu_int a, long double expected)
 {
     long double x = __floatuntixf(a);
     if (x != expected)
     {
         utwords at;
         at.all = a;
         printf("error in __floatuntixf(0x%.16llX%.16llX) = %LA, expected %LA\n",
                at.s.high, at.s.low, x, expected);
     }
     return x != expected;
 }
 
-char assumption_1[sizeof(tu_int) == 2*sizeof(du_int)] = {0};
-char assumption_2[sizeof(tu_int)*CHAR_BIT == 128] = {0};
-char assumption_3[sizeof(long double)*CHAR_BIT == 128] = {0};
+COMPILE_TIME_ASSERT(sizeof(tu_int) == 2*sizeof(du_int));
+COMPILE_TIME_ASSERT(sizeof(tu_int)*CHAR_BIT == 128);
+COMPILE_TIME_ASSERT(sizeof(long double)*CHAR_BIT == 128);
 
 #endif
 
 int main()
 {
-#ifdef CRT_HAS_128BIT
+#if defined(CRT_HAS_128BIT) && HAS_80_BIT_LONG_DOUBLE
     if (test__floatuntixf(0, 0.0))
         return 1;
 
     if (test__floatuntixf(1, 1.0))
         return 1;
     if (test__floatuntixf(2, 2.0))
         return 1;
     if (test__floatuntixf(20, 20.0))

test/builtins/Unit/lit.cfg

 
 # Platform-specific default Builtins_OPTIONS for lit tests.
 default_builtins_opts = ''
 
 # Setup source root.
 config.test_source_root = os.path.dirname(__file__)
 
 # Path to the static library
-is_msvc = get_required_attr(config, "builtins_is_msvc")
+is_msvc = get_required_attr(config, "is_msvc")
 if is_msvc:
   base_lib = os.path.join(config.compiler_rt_libdir, "clang_rt.builtins%s.lib "
                           % config.target_suffix)
   config.substitutions.append( ("%librt ", base_lib) )
 else:
   base_lib = os.path.join(config.compiler_rt_libdir, "libclang_rt.builtins%s.a"
                           % config.target_suffix)
   config.substitutions.append( ("%librt ", base_lib + ' -lc -lm ') )

 clang_builtins_static_cflags = ([""] +
                             config.debug_info_flags + target_cflags)
 clang_builtins_static_cxxflags = config.cxx_mode_flags + \
                                  clang_builtins_static_cflags
 
 clang_builtins_cflags = clang_builtins_static_cflags
 clang_builtins_cxxflags = clang_builtins_static_cxxflags
 
+# FIXME: Right now we don't compile the C99 complex builtins when using
+# clang-cl. Fix that.
 if not is_msvc:
   config.available_features.add('c99-complex')
 
+builtins_is_msvc = get_required_attr(config, "builtins_is_msvc")
+if not builtins_is_msvc:
+  config.available_features.add('int128')
+
 clang_wrapper = ""
 
 def build_invocation(compile_flags):
   return " " + " ".join([clang_wrapper, config.clang] + compile_flags) + " "
 
 
 target_arch = config.target_arch
 if (target_arch == "arm"):

test/builtins/Unit/lit.site.cfg.in

 @LIT_SITE_CFG_IN_HEADER@
 
 config.name_suffix = "@BUILTINS_TEST_CONFIG_SUFFIX@"
 config.builtins_lit_source_dir = "@BUILTINS_LIT_SOURCE_DIR@/Unit"
 config.target_cflags = "@BUILTINS_TEST_TARGET_CFLAGS@"
 config.target_arch = "@BUILTINS_TEST_TARGET_ARCH@"
-config.builtins_is_msvc = @MSVC_PYBOOL@
+config.is_msvc = @MSVC_PYBOOL@
+config.builtins_is_msvc = @BUILTINS_IS_MSVC_PYBOOL@
 # Load common config for all compiler-rt lit tests.
 lit_config.load_config(config, "@COMPILER_RT_BINARY_DIR@/test/lit.common.configured")
 
 # Load tool-specific config that would do the real work.
 lit_config.load_config(config, "@BUILTINS_LIT_SOURCE_DIR@/Unit/lit.cfg")

test/builtins/Unit/lshrti3_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
+// REQUIRES: int128
 //===-- lshrti3_test.c - Test __lshrti3 -----------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

test/builtins/Unit/modti3_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
+// REQUIRES: int128
 //===-- modti3_test.c - Test __modti3 -------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
if (test__modti3(5, 3, 2))
         return 1;
     if (test__modti3(5, -3, 2))
         return 1;
     if (test__modti3(-5, 3, -2))
         return 1;
     if (test__modti3(-5, -3, -2))
         return 1;
 
-    if (test__modti3(0x8000000000000000LL, 1, 0x0LL))
+    if (test__modti3(0x8000000000000000ULL, 1, 0x0LL))
         return 1;
-    if (test__modti3(0x8000000000000000LL, -1, 0x0LL))
+    if (test__modti3(0x8000000000000000ULL, -1, 0x0LL))
         return 1;
-    if (test__modti3(0x8000000000000000LL, 2, 0x0LL))
+    if (test__modti3(0x8000000000000000ULL, 2, 0x0LL))
         return 1;
-    if (test__modti3(0x8000000000000000LL, -2, 0x0LL))
+    if (test__modti3(0x8000000000000000ULL, -2, 0x0LL))
         return 1;
-    if (test__modti3(0x8000000000000000LL, 3, 2))
+    if (test__modti3(0x8000000000000000ULL, 3, 2))
         return 1;
-    if (test__modti3(0x8000000000000000LL, -3, 2))
+    if (test__modti3(0x8000000000000000ULL, -3, 2))
         return 1;
 
     if (test__modti3(make_ti(0x8000000000000000LL, 0), 1, 0x0LL))
         return 1;
     if (test__modti3(make_ti(0x8000000000000000LL, 0), -1, 0x0LL))
         return 1;
     if (test__modti3(make_ti(0x8000000000000000LL, 0), 2, 0x0LL))
         return 1;

test/builtins/Unit/muloti4_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
+// REQUIRES: int128
 //===-- muloti4_test.c - Test __muloti4 -----------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

test/builtins/Unit/multi3_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
+// REQUIRES: int128
 //===-- multi3_test.c - Test __multi3 -------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

test/builtins/Unit/mulvti3_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
+// REQUIRES: int128
 //===-- mulvti3_test.c - Test __mulvti3 -----------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
if (test__mulvti3(1, -10, -10))
         return 1;
     if (test__mulvti3(-10, 1, -10))
         return 1;
     if (test__mulvti3(1, -81985529216486895LL, -81985529216486895LL))
         return 1;
     if (test__mulvti3(-81985529216486895LL, 1, -81985529216486895LL))
         return 1;
 
-    if (test__mulvti3(3037000499LL, 3037000499LL, 9223372030926249001LL))
+    if (test__mulvti3(3037000499LL, 3037000499LL, 9223372030926249001ULL))
         return 1;
     if (test__mulvti3(-3037000499LL, 3037000499LL, -9223372030926249001LL))
         return 1;
     if (test__mulvti3(3037000499LL, -3037000499LL, -9223372030926249001LL))
         return 1;
-    if (test__mulvti3(-3037000499LL, -3037000499LL, 9223372030926249001LL))
+    if (test__mulvti3(-3037000499LL, -3037000499LL, 9223372030926249001ULL))
         return 1;
 
     if (test__mulvti3(4398046511103LL, 2097152LL, 9223372036852678656LL))
         return 1;
     if (test__mulvti3(-4398046511103LL, 2097152LL, -9223372036852678656LL))
         return 1;
     if (test__mulvti3(4398046511103LL, -2097152LL, -9223372036852678656LL))
         return 1;
     if (test__mulvti3(-4398046511103LL, -2097152LL, 9223372036852678656LL))
         return 1;
 
-    if (test__mulvti3(2097152LL, 4398046511103LL, 9223372036852678656LL))
+    if (test__mulvti3(2097152LL, 4398046511103LL, 9223372036852678656ULL))
         return 1;
     if (test__mulvti3(-2097152LL, 4398046511103LL, -9223372036852678656LL))
         return 1;
     if (test__mulvti3(2097152LL, -4398046511103LL, -9223372036852678656LL))
         return 1;
     if (test__mulvti3(-2097152LL, -4398046511103LL, 9223372036852678656LL))
         return 1;
 

test/builtins/Unit/negti2_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
+// REQUIRES: int128
 //===-- negti2_test.c - Test __negti2 -------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

test/builtins/Unit/negvti2_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
+// REQUIRES: int128
 //===-- negvti2_test.c - Test __negvti2 -----------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

test/builtins/Unit/parityti2_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
+// REQUIRES: int128
 //===-- parityti2_test.c - Test __parityti2 -------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

test/builtins/Unit/popcountti2_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
+// REQUIRES: int128
 //===-- popcountti2_test.c - Test __popcountti2 ----------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

test/builtins/Unit/subvti3_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
+// REQUIRES: int128
 //===-- subvti3_test.c - Test __subvti3 -----------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

test/builtins/Unit/ucmpti2_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
+// REQUIRES: int128
 //===-- ucmpti2_test.c - Test __ucmpti2 -----------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

test/builtins/Unit/udivmodti4_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
+// REQUIRES: int128
 //===-- udivmodti4_test.c - Test __udivmodti4 -----------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

test/builtins/Unit/udivti3_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
+// REQUIRES: int128
 //===-- udivti3_test.c - Test __udivti3 -----------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

test/builtins/Unit/umodti3_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
+// REQUIRES: int128
 //===-- umodti3_test.c - Test __umodti3 -----------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//