[compiler-rt][builtins] Factor out some common bit manipulations

[atrosinenko]

Summary

This patch incapsulates some commonly used hacks in a (hopefully) UB-free manner.

Some existing LibCall implementations contain constants like this one:

const di_int MIN = (di_int)1 << ((int)(sizeof(di_int) * CHAR_BIT) - 1);

UBSan complains on such expressions and that seems to be true positive.

This patch is expected to be NFC except for eliminating some UB. It consists of the following parts:

• implementing helpers in int_types.h
• replacing some typedefs with #defines so these type alises can be handled by the above machinery
• replacing some constants with these common helper invocations
  • this is expected to be unable to cause any performance regressions as these are actually compile-time constants
• fixing a couple of UBs in __neg?i2 LibCalls

[atrosinenko]

Reupload.

[MaskRay]

compiler-rt/lib/builtins/int_mulo_impl.inc

22

AFAIK LLVM_USE_SANITIZER does not instrument compiler-rt. libclang_rt.builtins- is at the bottom of the library layering. How did you enable sanitizers?

[atrosinenko]

Explicilty mention that UBSan have to be manually configured in trap-on-error mode to operate of builtins library.

[atrosinenko]

compiler-rt/lib/builtins/int_mulo_impl.inc

22

AFAIK LLVM_USE_SANITIZER does not instrument compiler-rt. libclang_rt.builtins- is at the bottom of the library layering. How did you enable sanitizers?

No, I have not managed to force CMake to enable UBSan on builtins. I just passed -fsanitize=undefined -fsanitize-undefined-trap-on-error cflags explicitly. The second option is exactly because I cannot link UBSan runtime libraries here but can enable -ggdb3 and look where sanitizer triggered.

So, this hack works for this particular setup, so I can manually run such checks at least manually at least on clang, etc.

compiler-rt/lib/builtins/fixdfdi.c

COMPILER_RT_ABI di_int __fixdfdi(double a) {
   return __fixunsdfdi(a);
 }
 
 #else
 // Support for systems that don't have hardware floating-point; there are no
 // flags to set, and we don't want to code-gen to an unknown soft-float
 // implementation.
 
-typedef di_int fixint_t;
-typedef du_int fixuint_t;
+#define fixint_t di_int
+#define fixuint_t du_int
 #include "fp_fixint_impl.inc"
 
 COMPILER_RT_ABI di_int __fixdfdi(fp_t a) { return __fixint(a); }
 
 #endif
 
 #if defined(__ARM_EABI__)
 #if defined(COMPILER_RT_ARMHF_TARGET)
 AEABI_RTABI di_int __aeabi_d2lz(fp_t a) { return __fixdfdi(a); }
 #else
 COMPILER_RT_ALIAS(__fixdfdi, __aeabi_d2lz)
 #endif
 #endif

compiler-rt/lib/builtins/fixdfsi.c

 //===-- fixdfsi.c - Implement __fixdfsi -----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #define DOUBLE_PRECISION
 #include "fp_lib.h"
-typedef si_int fixint_t;
-typedef su_int fixuint_t;
+#define fixint_t si_int
+#define fixuint_t su_int
 #include "fp_fixint_impl.inc"
 
 COMPILER_RT_ABI si_int __fixdfsi(fp_t a) { return __fixint(a); }
 
 #if defined(__ARM_EABI__)
 #if defined(COMPILER_RT_ARMHF_TARGET)
 AEABI_RTABI si_int __aeabi_d2iz(fp_t a) { return __fixdfsi(a); }
 #else
 COMPILER_RT_ALIAS(__fixdfsi, __aeabi_d2iz)
 #endif
 #endif

compiler-rt/lib/builtins/fixdfti.c

 //===-- fixdfti.c - Implement __fixdfti -----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "int_lib.h"
 
 #ifdef CRT_HAS_128BIT
 #define DOUBLE_PRECISION
 #include "fp_lib.h"
 
-typedef ti_int fixint_t;
-typedef tu_int fixuint_t;
+#define fixint_t ti_int
+#define fixuint_t tu_int
 #include "fp_fixint_impl.inc"
 
 COMPILER_RT_ABI ti_int __fixdfti(fp_t a) { return __fixint(a); }
 
 #endif // CRT_HAS_128BIT

compiler-rt/lib/builtins/fixsfdi.c

COMPILER_RT_ABI di_int __fixsfdi(float a) {
   return __fixunssfdi(a);
 }
 
 #else
 // Support for systems that don't have hardware floating-point; there are no
 // flags to set, and we don't want to code-gen to an unknown soft-float
 // implementation.
 
-typedef di_int fixint_t;
-typedef du_int fixuint_t;
+#define fixint_t di_int
+#define fixuint_t du_int
 #include "fp_fixint_impl.inc"
 
 COMPILER_RT_ABI di_int __fixsfdi(fp_t a) { return __fixint(a); }
 
 #endif
 
 #if defined(__ARM_EABI__)
 #if defined(COMPILER_RT_ARMHF_TARGET)
 AEABI_RTABI di_int __aeabi_f2lz(fp_t a) { return __fixsfdi(a); }
 #else
 COMPILER_RT_ALIAS(__fixsfdi, __aeabi_f2lz)
 #endif
 #endif

compiler-rt/lib/builtins/fixsfsi.c

 //===-- fixsfsi.c - Implement __fixsfsi -----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #define SINGLE_PRECISION
 #include "fp_lib.h"
-typedef si_int fixint_t;
-typedef su_int fixuint_t;
+#define fixint_t si_int
+#define fixuint_t su_int
 #include "fp_fixint_impl.inc"
 
 COMPILER_RT_ABI si_int __fixsfsi(fp_t a) { return __fixint(a); }
 
 #if defined(__ARM_EABI__)
 #if defined(COMPILER_RT_ARMHF_TARGET)
 AEABI_RTABI si_int __aeabi_f2iz(fp_t a) { return __fixsfsi(a); }
 #else
 COMPILER_RT_ALIAS(__fixsfsi, __aeabi_f2iz)
 #endif
 #endif

compiler-rt/lib/builtins/fixsfti.c

 //===-- fixsfti.c - Implement __fixsfti -----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "int_lib.h"
 
 #ifdef CRT_HAS_128BIT
 #define SINGLE_PRECISION
 #include "fp_lib.h"
-
-typedef ti_int fixint_t;
-typedef tu_int fixuint_t;
+#define fixint_t ti_int
+#define fixuint_t tu_int
 #include "fp_fixint_impl.inc"
 
 COMPILER_RT_ABI ti_int __fixsfti(fp_t a) { return __fixint(a); }
 
 #endif // CRT_HAS_128BIT

compiler-rt/lib/builtins/fixtfdi.c

 //===-- fixtfdi.c - Implement __fixtfdi -----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #define QUAD_PRECISION
 #include "fp_lib.h"
 
 #if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
-typedef di_int fixint_t;
-typedef du_int fixuint_t;
+#define fixint_t di_int
+#define fixuint_t du_int
 #include "fp_fixint_impl.inc"
 
 COMPILER_RT_ABI di_int __fixtfdi(fp_t a) { return __fixint(a); }
 #endif

compiler-rt/lib/builtins/fixtfsi.c

 //===-- fixtfsi.c - Implement __fixtfsi -----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #define QUAD_PRECISION
 #include "fp_lib.h"
 
 #if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
-typedef si_int fixint_t;
-typedef su_int fixuint_t;
+#define fixint_t si_int
+#define fixuint_t su_int
 #include "fp_fixint_impl.inc"
 
 COMPILER_RT_ABI si_int __fixtfsi(fp_t a) { return __fixint(a); }
 #endif

compiler-rt/lib/builtins/fixtfti.c

 //===-- fixtfti.c - Implement __fixtfti -----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #define QUAD_PRECISION
 #include "fp_lib.h"
 
 #if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
-typedef ti_int fixint_t;
-typedef tu_int fixuint_t;
+#define fixint_t ti_int
+#define fixuint_t tu_int
 #include "fp_fixint_impl.inc"
 
 COMPILER_RT_ABI ti_int __fixtfti(fp_t a) { return __fixint(a); }
 #endif

compiler-rt/lib/builtins/fp_fixint_impl.inc

 //===-- lib/fixdfsi.c - Double-precision -> integer conversion ----*- C -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements float to integer conversion for the
 // compiler-rt library.
 //
 //===----------------------------------------------------------------------===//
 
 #include "fp_lib.h"
 
 static __inline fixint_t __fixint(fp_t a) {
-  const fixint_t fixint_max = (fixint_t)((~(fixuint_t)0) / 2);
-  const fixint_t fixint_min = -fixint_max - 1;
+  const fixint_t fixint_max = MAX_SIGNED(fixint_t);
+  const fixint_t fixint_min = MIN_SIGNED(fixint_t);
   // Break a into sign, exponent, significand parts.
   const rep_t aRep = toRep(a);
   const rep_t aAbs = aRep & absMask;
   const fixint_t sign = aRep & signBit ? -1 : 1;
   const int exponent = (aAbs >> significandBits) - exponentBias;
   const rep_t significand = (aAbs & significandMask) | implicitBit;
 
   // If exponent is negative, the result is zero.
   if (exponent < 0)
     return 0;
 
   // If the value is too large for the integer type, saturate.
   if ((unsigned)exponent >= sizeof(fixint_t) * CHAR_BIT)
     return sign == 1 ? fixint_max : fixint_min;
 
   // If 0 <= exponent < significandBits, right shift to get the result.
   // Otherwise, shift left.
   if (exponent < significandBits)
     return sign * (significand >> (significandBits - exponent));
   else
     return sign * ((fixint_t)significand << (exponent - significandBits));
 }

compiler-rt/lib/builtins/int_mulo_impl.inc

 //===----------------------------------------------------------------------===//
 
 #include "int_lib.h"
 
 // Returns: a * b
 
 // Effects: sets *overflow to 1  if a * b overflows
 
-static __inline fixint_t __muloXi4(fixint_t a, fixint_t b, int *overflow) {
-  const int N = (int)(sizeof(fixint_t) * CHAR_BIT);
-  const fixint_t MIN = (fixint_t)1 << (N - 1);
-  const fixint_t MAX = ~MIN;
+// UBSan may be useful for testing the compiler-rt/builtins library by manually
+// setting CFLAGS="-fsanitize=undefined -fsanitize-undefined-trap-on-error"
+// when configuring compiler-rt and then running check-builtins.
+// The problem with __mulo[sdt]i4 LibCalls is that they may recursively call
+// themselves indefinitely when compiled with UBSan.
+#if defined(__clang__)
+#define NO_UBSAN __attribute__((no_sanitize("undefined")))
+#else
+#define NO_UBSAN
+#endif
+
+static __inline NO_UBSAN fixint_t __muloXi4(fixint_t a, fixint_t b, int *overflow) {
+  const int N = bitsizeof(fixint_t);
+  const fixint_t MIN = MIN_SIGNED(fixint_t);
+  const fixint_t MAX = MAX_SIGNED(fixint_t);
   *overflow = 0;
   fixint_t result = a * b;
   if (a == MIN) {
     if (b != 0 && b != 1)
       *overflow = 1;
     return result;
   }
   if (b == MIN) {
     if (a != 0 && a != 1)
       *overflow = 1;
     return result;
   }
   fixint_t sa = a >> (N - 1);
   fixint_t abs_a = (a ^ sa) - sa;
   fixint_t sb = b >> (N - 1);
   fixint_t abs_b = (b ^ sb) - sb;
   if (abs_a < 2 || abs_b < 2)
     return result;
   if (sa == sb) {
     if (abs_a > MAX / abs_b)
       *overflow = 1;
   } else {
     if (abs_a > MIN / -abs_b)
       *overflow = 1;
   }
   return result;
 }

compiler-rt/lib/builtins/int_mulv_impl.inc

 //===----------------------------------------------------------------------===//
 
 #include "int_lib.h"
 
 // Returns: a * b
 
 // Effects: aborts if a * b overflows
 
 static __inline fixint_t __mulvXi3(fixint_t a, fixint_t b) {
-  const int N = (int)(sizeof(fixint_t) * CHAR_BIT);
-  const fixint_t MIN = (fixint_t)1 << (N - 1);
-  const fixint_t MAX = ~MIN;
+  const int N = bitsizeof(fixint_t);
+  const fixint_t MIN = MIN_SIGNED(fixint_t);
+  const fixint_t MAX = MAX_SIGNED(fixint_t);
   if (a == MIN) {
     if (b == 0 || b == 1)
       return a * b;
     compilerrt_abort();
   }
   if (b == MIN) {
     if (a == 0 || a == 1)
       return a * b;
     compilerrt_abort();
   }
   fixint_t sa = a >> (N - 1);
   fixint_t abs_a = (a ^ sa) - sa;
   fixint_t sb = b >> (N - 1);
   fixint_t abs_b = (b ^ sb) - sb;
   if (abs_a < 2 || abs_b < 2)
     return a * b;
   if (sa == sb) {
     if (abs_a > MAX / abs_b)
       compilerrt_abort();
   } else {
     if (abs_a > MIN / -abs_b)
       compilerrt_abort();
   }
   return a * b;
 }

compiler-rt/lib/builtins/int_types.h

-//===-- int_lib.h - configuration header for compiler-rt  -----------------===//
+//===-- int_types.h - type definitions for compiler-rt --------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is not part of the interface of this library.
 //
 // This file defines various standard types, most importantly a number of unions
 // used to access parts of larger types.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef INT_TYPES_H
 #define INT_TYPES_H
 
 #include "int_endianness.h"
 
 // si_int is defined in Linux sysroot's asm-generic/siginfo.h
 #ifdef si_int
 #undef si_int
 #endif
 typedef int32_t si_int;
 typedef uint32_t su_int;
 #if UINT_MAX == 0xFFFFFFFF
 #define clzsi __builtin_clz
 #define ctzsi __builtin_ctz
 #elif ULONG_MAX == 0xFFFFFFFF
 #define clzsi __builtin_clzl
 #define ctzsi __builtin_ctzl
 #else
 #error could not determine appropriate clzsi macro for this system
 #endif
 
 typedef int64_t di_int;
 typedef uint64_t du_int;
 
+// Helpers for standard type aliases to get signed from unsigned and vice versa
+#define AS_SIGNED(type) type##_AS_SIGNED
+#define AS_UNSIGNED(type) type##_AS_UNSIGNED
+#define si_int_AS_SIGNED si_int
+#define su_int_AS_SIGNED si_int
+#define di_int_AS_SIGNED di_int
+#define du_int_AS_SIGNED di_int
+#define ti_int_AS_SIGNED ti_int
+#define tu_int_AS_SIGNED ti_int
+#define si_int_AS_UNSIGNED su_int
+#define su_int_AS_UNSIGNED su_int
+#define di_int_AS_UNSIGNED du_int
+#define du_int_AS_UNSIGNED du_int
+#define ti_int_AS_UNSIGNED tu_int
+#define tu_int_AS_UNSIGNED tu_int
+
+// Misc macroses incapsulating common hacks.
+// Supposed to replace the ad-hoc UB-prone implementations.
+#define bitsizeof(type_or_value) ((int)(sizeof(type_or_value) * CHAR_BIT))
+#define SIGN_BIT(type) ((AS_UNSIGNED(type))1 << (bitsizeof(type) - 1))
+#define MIN_SIGNED(type) ((AS_SIGNED(type))SIGN_BIT(type))
+#define MAX_SIGNED(type) ((AS_SIGNED(type))(SIGN_BIT(type) - 1U))
+#define MAX_UNSIGNED(type) (~(AS_UNSIGNED(type))0))
+
 typedef union {
   di_int all;
   struct {
 #if _YUGA_LITTLE_ENDIAN
     su_int low;
     si_int high;
 #else
     si_int high;

compiler-rt/lib/builtins/negdi2.c

 
 #include "int_lib.h"
 
 // Returns: -a
 
 COMPILER_RT_ABI di_int __negdi2(di_int a) {
   // Note: this routine is here for API compatibility; any sane compiler
   // should expand it inline.
-  return -a;
+  return -(du_int)a;
 }

compiler-rt/lib/builtins/negti2.c

 
 #ifdef CRT_HAS_128BIT
 
 // Returns: -a
 
 COMPILER_RT_ABI ti_int __negti2(ti_int a) {
   // Note: this routine is here for API compatibility; any sane compiler
   // should expand it inline.
-  return -a;
+  return -(tu_int)a;
 }
 
 #endif // CRT_HAS_128BIT

compiler-rt/lib/builtins/negvdi2.c

 
 #include "int_lib.h"
 
 // Returns: -a
 
 // Effects: aborts if -a overflows
 
 COMPILER_RT_ABI di_int __negvdi2(di_int a) {
-  const di_int MIN = (di_int)1 << ((int)(sizeof(di_int) * CHAR_BIT) - 1);
-  if (a == MIN)
+  if (a == MIN_SIGNED(di_int))
     compilerrt_abort();
   return -a;
 }

compiler-rt/lib/builtins/negvsi2.c

 
 #include "int_lib.h"
 
 // Returns: -a
 
 // Effects: aborts if -a overflows
 
 COMPILER_RT_ABI si_int __negvsi2(si_int a) {
-  const si_int MIN = (si_int)1 << ((int)(sizeof(si_int) * CHAR_BIT) - 1);
-  if (a == MIN)
+  if (a == MIN_SIGNED(si_int))
     compilerrt_abort();
   return -a;
 }

compiler-rt/lib/builtins/negvti2.c

 
 #ifdef CRT_HAS_128BIT
 
 // Returns: -a
 
 // Effects: aborts if -a overflows
 
 COMPILER_RT_ABI ti_int __negvti2(ti_int a) {
-  const ti_int MIN = (ti_int)1 << ((int)(sizeof(ti_int) * CHAR_BIT) - 1);
-  if (a == MIN)
+  if (a == MIN_SIGNED(ti_int))
     compilerrt_abort();
   return -a;
 }
 
 #endif // CRT_HAS_128BIT