[compiler-rt] [builtins] Support conversion between fp16 and fp128

This patch adds both extendhftf2 and trunctfhf2 to support
conversion between half-precision and quad-precision floating-point
values. They are enabled iff the compiler supports _Float16.

Some notes on ARM plaforms: while __fp16 is supported on all
architectures, _Float16 is supported only for 32-bit ARM, 64-bit ARM,
and SPIR (as indicated by clang/docs/LanguageExtensions.rst).  Also,
__fp16 is a storage format and promoted to 'float' for argument passing
and 64-bit ARM supports floating-point convert precision to half as
base armv8-a instruction.

It means that although extendhfsf2, truncdfhf2 __truncsfhf2 will be
built for 64-bit ARM, they will be never used in practice (compiler
won't emit libcall to them). This patch does not change the ABI for
32-bit ARM, it will continue to pass _Float16 as uint16.

Differential Revision: https://reviews.llvm.org/D91732

compiler-rt/cmake/builtin-config-ix.cmake

@@ -22,6 +22,13 @@ int foo(int x, int y) {
 }
 ")
 
+builtin_check_c_compiler_source(COMPILER_RT_HAS_FLOAT16
+"
+_Float16 foo(_Float16 x) {
+ return x;
+}
+"
+)
 
 set(ARM64 aarch64)
 set(ARM32 arm armhf armv6m armv7m armv7em armv7 armv7s armv7k)

compiler-rt/lib/builtins/CMakeLists.txt

@@ -179,6 +179,7 @@ set(GENERIC_TF_SOURCES
   divtc3.c
   divtf3.c
   extenddftf2.c
+  extendhftf2.c
   extendsftf2.c
   fixtfdi.c
   fixtfsi.c
@@ -197,6 +198,7 @@ set(GENERIC_TF_SOURCES
   powitf2.c
   subtf3.c
   trunctfdf2.c
+  trunctfhf2.c
   trunctfsf2.c
 )
 
@@ -628,6 +630,8 @@ if (APPLE)
 else ()
   set(BUILTIN_CFLAGS "")
 
+  append_list_if(COMPILER_RT_HAS_FLOAT16 -DCOMPILER_RT_HAS_FLOAT16 BUILTIN_CFLAGS)
+
   append_list_if(COMPILER_RT_HAS_STD_C11_FLAG -std=c11 BUILTIN_CFLAGS)
 
   # These flags would normally be added to CMAKE_C_FLAGS by the llvm

compiler-rt/lib/builtins/extendhftf2.c

@@ -0,0 +1,23 @@
+//===-- lib/extendhftf2.c - half -> quad conversion ---------------*- C -*-===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+#define QUAD_PRECISION
+#include "fp_lib.h"
+
+#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT) &&                     \
+    defined(COMPILER_RT_HAS_FLOAT16)
+#define SRC_HALF
+#define DST_QUAD
+#include "fp_extend_impl.inc"
+
+COMPILER_RT_ABI long double __extendhftf2(_Float16 a) {
+  return __extendXfYf2__(a);
+}
+
+#endif

compiler-rt/lib/builtins/trunctfhf2.c

@@ -0,0 +1,23 @@
+//===-- lib/trunctfhf2.c - quad -> half conversion ----------------*- C -*-===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+#define QUAD_PRECISION
+#include "fp_lib.h"
+
+#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT) &&                     \
+    defined(COMPILER_RT_HAS_FLOAT16)
+#define SRC_QUAD
+#define DST_HALF
+#include "fp_trunc_impl.inc"
+
+COMPILER_RT_ABI _Float16 __trunctfhf2(long double a) {
+   return __truncXfYf2__(a);
+}
+
+#endif

compiler-rt/test/builtins/CMakeLists.txt

@@ -44,6 +44,8 @@ foreach(arch ${BUILTIN_TEST_ARCH})
     string(REPLACE ";" " " BUILTINS_TEST_TARGET_CFLAGS "${BUILTINS_TEST_TARGET_CFLAGS}")
   endif()
 
+  append_list_if(COMPILER_RT_HAS_FLOAT16 -DCOMPILER_RT_HAS_FLOAT16 BUILTINS_TEST_TARGET_CFLAGS)
+
   # Compute builtins available in library and add them as lit features.
   if(APPLE)
     # TODO: Support other Apple platforms.

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

@@ -0,0 +1,95 @@
+// RUN: %clang_builtins %s %librt -o %t && %run %t
+// REQUIRES: librt_has_extendhftf2
+
+#include "int_lib.h"
+#include <stdio.h>
+
+#if __LDBL_MANT_DIG__ == 113 && defined(COMPILER_RT_HAS_FLOAT16)
+
+#include "fp_test.h"
+
+COMPILER_RT_ABI long double __extendhftf2(TYPE_FP16 a);
+
+int test__extendhftf2(TYPE_FP16 a, uint64_t expectedHi, uint64_t expectedLo) {
+  long double x = __extendhftf2(a);
+  int ret = compareResultLD(x, expectedHi, expectedLo);
+
+  if (ret) {
+    printf("error in test__extendhftf2(%#.4x) = %.20Lf, "
+           "expected %.20Lf\n",
+           toRep16(a), x,
+           fromRep128(expectedHi, expectedLo));
+  }
+  return ret;
+}
+
+char assumption_1[sizeof(TYPE_FP16) * CHAR_BIT == 16] = {0};
+
+#endif
+
+int main() {
+#if __LDBL_MANT_DIG__ == 113 && defined(COMPILER_RT_HAS_FLOAT16)
+  // qNaN
+  if (test__extendhftf2(makeQNaN16(),
+                        UINT64_C(0x7fff800000000000),
+                        UINT64_C(0x0)))
+    return 1;
+  // NaN
+  if (test__extendhftf2(makeNaN16(UINT16_C(0x0100)),
+                        UINT64_C(0x7fff400000000000),
+                        UINT64_C(0x0)))
+    return 1;
+  // inf
+  if (test__extendhftf2(makeInf16(),
+                        UINT64_C(0x7fff000000000000),
+                        UINT64_C(0x0)))
+    return 1;
+  if (test__extendhftf2(-makeInf16(),
+                        UINT64_C(0xffff000000000000),
+                        UINT64_C(0x0)))
+    return 1;
+  // zero
+  if (test__extendhftf2(fromRep16(0x0U),
+                        UINT64_C(0x0), UINT64_C(0x0)))
+    return 1;
+  if (test__extendhftf2(fromRep16(0x8000U),
+                        UINT64_C(0x8000000000000000),
+                        UINT64_C(0x0)))
+    return 1;
+  // denormal
+  if (test__extendhftf2(fromRep16(0x0010U),
+                        UINT64_C(0x3feb000000000000),
+                        UINT64_C(0x0000000000000000)))
+    return 1;
+  if (test__extendhftf2(fromRep16(0x0001U),
+                        UINT64_C(0x3fe7000000000000),
+                        UINT64_C(0x0000000000000000)))
+    return 1;
+  if (test__extendhftf2(fromRep16(0x8001U),
+                        UINT64_C(0xbfe7000000000000),
+                        UINT64_C(0x0000000000000000)))
+    return 1;
+
+  // pi
+  if (test__extendhftf2(fromRep16(0x4248U),
+                        UINT64_C(0x4000920000000000),
+                        UINT64_C(0x0000000000000000)))
+    return 1;
+  if (test__extendhftf2(fromRep16(0xc248U),
+                        UINT64_C(0xc000920000000000),
+                        UINT64_C(0x0000000000000000)))
+    return 1;
+
+  if (test__extendhftf2(fromRep16(0x508cU),
+                        UINT64_C(0x4004230000000000),
+                        UINT64_C(0x0)))
+    return 1;
+  if (test__extendhftf2(fromRep16(0x1bb7U),
+                        UINT64_C(0x3ff6edc000000000),
+                        UINT64_C(0x0)))
+    return 1;
+#else
+  printf("skipped\n");
+#endif
+  return 0;
+}

compiler-rt/test/builtins/Unit/fp_test.h

@@ -3,13 +3,25 @@
 #include <string.h>
 #include <stdint.h>
 
+#ifdef COMPILER_RT_HAS_FLOAT16
+#define TYPE_FP16 _Float16
+#else
+#define TYPE_FP16 uint16_t
+#endif
+
 enum EXPECTED_RESULT {
     LESS_0, LESS_EQUAL_0, EQUAL_0, GREATER_0, GREATER_EQUAL_0, NEQUAL_0
 };
 
-static inline uint16_t fromRep16(uint16_t x)
+static inline TYPE_FP16 fromRep16(uint16_t x)
 {
+#ifdef COMPILER_RT_HAS_FLOAT16
+    TYPE_FP16 ret;
+    memcpy(&ret, &x, sizeof(ret));
+    return ret;
+#else
     return x;
+#endif
 }
 
 static inline float fromRep32(uint32_t x)
@@ -36,9 +48,15 @@ static inline long double fromRep128(uint64_t hi, uint64_t lo)
 }
 #endif
 
-static inline uint16_t toRep16(uint16_t x)
+static inline uint16_t toRep16(TYPE_FP16 x)
 {
+#ifdef COMPILER_RT_HAS_FLOAT16
+    uint16_t ret;
+    memcpy(&ret, &x, sizeof(ret));
+    return ret;
+#else
     return x;
+#endif
 }
 
 static inline uint32_t toRep32(float x)
@@ -64,7 +82,7 @@ static inline __uint128_t toRep128(long double x)
 }
 #endif
 
-static inline int compareResultH(uint16_t result,
+static inline int compareResultH(TYPE_FP16 result,
                                  uint16_t expected)
 {
     uint16_t rep = toRep16(result);
@@ -199,7 +217,7 @@ static inline char *expectedStr(enum EXPECTED_RESULT expected)
     return "";
 }
 
-static inline uint16_t makeQNaN16(void)
+static inline TYPE_FP16 makeQNaN16(void)
 {
     return fromRep16(0x7e00U);
 }
@@ -221,7 +239,7 @@ static inline long double makeQNaN128(void)
 }
 #endif
 
-static inline uint16_t makeNaN16(uint16_t rand)
+static inline TYPE_FP16 makeNaN16(uint16_t rand)
 {
     return fromRep16(0x7c00U | (rand & 0x7fffU));
 }
@@ -243,7 +261,7 @@ static inline long double makeNaN128(uint64_t rand)
 }
 #endif
 
-static inline uint16_t makeInf16(void)
+static inline TYPE_FP16 makeInf16(void)
 {
     return fromRep16(0x7c00U);
 }

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

@@ -0,0 +1,125 @@
+// RUN: %clang_builtins %s %librt -o %t && %run %t
+// REQUIRES: librt_has_trunctfhf2
+
+#include "int_lib.h"
+#include <stdio.h>
+
+#if __LDBL_MANT_DIG__ == 113 && defined(COMPILER_RT_HAS_FLOAT16)
+
+#include "fp_test.h"
+
+TYPE_FP16 __trunctfhf2(long double a);
+
+int test__trunctfhf2(long double a, uint16_t expected) {
+  TYPE_FP16 x = __trunctfhf2(a);
+  int ret = compareResultH(x, expected);
+
+  if (ret) {
+    printf("error in test__trunctfhf2(%.20Lf) = %#.4x, "
+           "expected %#.4x\n",
+           a, toRep16(x), expected);
+  }
+  return ret;
+}
+
+char assumption_1[sizeof(TYPE_FP16) * CHAR_BIT == 16] = {0};
+
+#endif
+
+int main() {
+#if __LDBL_MANT_DIG__ == 113 && defined(COMPILER_RT_HAS_FLOAT16)
+  // qNaN
+  if (test__trunctfhf2(makeQNaN128(),
+                       UINT16_C(0x7e00)))
+    return 1;
+  // NaN
+  if (test__trunctfhf2(makeNaN128(UINT64_C(0x810000000000)),
+                       UINT16_C(0x7e00)))
+    return 1;
+  // inf
+  if (test__trunctfhf2(makeInf128(),
+                       UINT16_C(0x7c00)))
+    return 1;
+  if (test__trunctfhf2(-makeInf128(),
+                       UINT16_C(0xfc00)))
+    return 1;
+  // zero
+  if (test__trunctfhf2(0.0L, UINT16_C(0x0)))
+    return 1;
+  if (test__trunctfhf2(-0.0L, UINT16_C(0x8000)))
+    return 1;
+
+  if (test__trunctfhf2(3.1415926535L,
+                       UINT16_C(0x4248)))
+    return 1;
+  if (test__trunctfhf2(-3.1415926535L,
+                       UINT16_C(0xc248)))
+    return 1;
+  if (test__trunctfhf2(0x1.987124876876324p+100L,
+                       UINT16_C(0x7c00)))
+    return 1;
+  if (test__trunctfhf2(0x1.987124876876324p+12L,
+                       UINT16_C(0x6e62)))
+    return 1;
+  if (test__trunctfhf2(0x1.0p+0L,
+                       UINT16_C(0x3c00)))
+    return 1;
+  if (test__trunctfhf2(0x1.0p-14L,
+                       UINT16_C(0x0400)))
+    return 1;
+  // denormal
+  if (test__trunctfhf2(0x1.0p-20L,
+                       UINT16_C(0x0010)))
+    return 1;
+  if (test__trunctfhf2(0x1.0p-24L,
+                       UINT16_C(0x0001)))
+    return 1;
+  if (test__trunctfhf2(-0x1.0p-24L,
+                       UINT16_C(0x8001)))
+    return 1;
+  if (test__trunctfhf2(0x1.5p-25L,
+                       UINT16_C(0x0001)))
+    return 1;
+  // and back to zero
+  if (test__trunctfhf2(0x1.0p-25L,
+                       UINT16_C(0x0000)))
+    return 1;
+  if (test__trunctfhf2(-0x1.0p-25L,
+                       UINT16_C(0x8000)))
+    return 1;
+  // max (precise)
+  if (test__trunctfhf2(65504.0L,
+                       UINT16_C(0x7bff)))
+    return 1;
+  // max (rounded)
+  if (test__trunctfhf2(65519.0L,
+                       UINT16_C(0x7bff)))
+    return 1;
+  // max (to +inf)
+  if (test__trunctfhf2(65520.0L,
+                       UINT16_C(0x7c00)))
+    return 1;
+  if (test__trunctfhf2(65536.0L,
+                       UINT16_C(0x7c00)))
+    return 1;
+  if (test__trunctfhf2(-65520.0L,
+                       UINT16_C(0xfc00)))
+    return 1;
+
+  if (test__trunctfhf2(0x1.23a2abb4a2ddee355f36789abcdep+5L,
+                       UINT16_C(0x508f)))
+    return 1;
+  if (test__trunctfhf2(0x1.e3d3c45bd3abfd98b76a54cc321fp-9L,
+                       UINT16_C(0x1b8f)))
+    return 1;
+  if (test__trunctfhf2(0x1.234eebb5faa678f4488693abcdefp+453L,
+                       UINT16_C(0x7c00)))
+    return 1;
+  if (test__trunctfhf2(0x1.edcba9bb8c76a5a43dd21f334634p-43L,
+                       UINT16_C(0x0)))
+    return 1;
+#else
+  printf("skipped\n");
+#endif
+  return 0;
+}