[AArch64] Support conversion between fp16 and fp128

[bryanpkc]

Summary

Add extendhftf2 and trunctfhf2, to support conversion between half-precision
and quad-precision floating-point values. On AArch64, use __fp16 as the half-
precision type so that such values are passed and returned in native FP16
registers. This is consistent with the behavior of the corresponding functions
in libgcc. Also fix some bugs in existing test cases.

[bryanpkc]

Pinging reviewers...

[SjoerdMeijer]

This looks good to me, but it's not really my area of expertise, so would appreciate if someone else can have a look too. Perhaps @olista01 or @efriedma ?

[efriedma]

compiler-rt/lib/builtins/fp_extend.h

43

Can we implement this some other way? _Float16 should have the right calling convention on all targets, I think.

[SjoerdMeijer]

compiler-rt/lib/builtins/fp_extend.h

43

That was exactly the first thing I was thinking of. But then I also got confused about e.g. changing this:

float __aeabi_h2f(uint16_t a)

to:

float __aeabi_h2f(src a)

where src can now be __fp16. First I was wondering if changing the signature would be problematic somehow. Probably not, and probably it is more correct. Looking at the RT ABI for h2f, the descriptions reads:

IEEE 754 binary16 storage format (VFP half precision) to binary32 (float)  conversion

From a first glance, I could image that __fp16 would capture this behaviour, but I would need to check again what the binary16 storage format exactly is, and that's why I wasn't sure about all this.

[bryanpkc]

compiler-rt/lib/builtins/fp_extend.h

43

Thanks for your comments. Many of these FP16 conversion helpers should be unnecessary on AArch64 (when __ARM_FP16_ARGS is defined) since the backend can generate instructions for such conversions. However the implementations of the helpers are intended to be shared by all targets, so that is why I decided to limit the impact of my change with the conditional compilation directive above. Similarly I also concluded that changing the signature of __aeabi_h2f etc. would not be problematic for AArch64 with FP16 support, but to be conservative, we could change src_t back to uint16_t in the standard runtime helpers, and add an explicit cast of a from uint16_t to src_t for the call to __extendhfsf2 etc.

[efriedma]

compiler-rt/lib/builtins/fp_extend.h

43

Yes, the ifdefs limit the impact for now, but I would rather fix the issue everywhere once. Otherwise, we'll be forced to hack up fp_extend.h every time clang adds support for a new target where the calling convention for _Float16 is different from the calling convention for uint16_t.

[shawnl]

The Zig language doesn't really want to have to special-case this conversion, and would like to see this patch be revisited. It seems to me like some of these reviews were almost accepts. https://github.com/ziglang/zig/issues/3282

[efriedma]

It looks like this is still waiting for review comments to be addressed.

compiler-rt/lib/builtins/CMakeLists.txt

set(GENERIC_SOURCES
   divsc3.c
   divsf3.c
   divsi3.c
   divtc3.c
   divti3.c
   divtf3.c
   extendsfdf2.c
   extendhfsf2.c
+  extendhftf2.c
   ffsdi2.c
   ffssi2.c
   ffsti2.c
   fixdfdi.c
   fixdfsi.c
   fixdfti.c
   fixsfdi.c
   fixsfsi.c
set(GENERIC_TF_SOURCES
   floatditf.c
   floatsitf.c
   floattitf.c
   floatunditf.c
   floatunsitf.c
   floatuntitf.c
   multc3.c
   trunctfdf2.c
-  trunctfsf2.c)
+  trunctfsf2.c
+  trunctfhf2.c)
 
 option(COMPILER_RT_EXCLUDE_ATOMIC_BUILTIN
   "Skip the atomic builtin (these should normally be provided by a shared library)"
   On)
 
 if(NOT FUCHSIA AND NOT COMPILER_RT_BAREMETAL_BUILD)
   set(GENERIC_SOURCES
     ${GENERIC_SOURCES}

compiler-rt/lib/builtins/extendhfsf2.c

 //===-- lib/extendhfsf2.c - half -> single 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 SRC_HALF
 #define DST_SINGLE
 #include "fp_extend_impl.inc"
 
 // Use a forwarding definition and noinline to implement a poor man's alias,
 // as there isn't a good cross-platform way of defining one.
-COMPILER_RT_ABI NOINLINE float __extendhfsf2(uint16_t a) {
+COMPILER_RT_ABI NOINLINE float __extendhfsf2(src_t a) {
     return __extendXfYf2__(a);
 }
 
-COMPILER_RT_ABI float __gnu_h2f_ieee(uint16_t a) {
+COMPILER_RT_ABI float __gnu_h2f_ieee(src_t a) {
     return __extendhfsf2(a);
 }
 
 #if defined(__ARM_EABI__)
 #if defined(COMPILER_RT_ARMHF_TARGET)
-AEABI_RTABI float __aeabi_h2f(uint16_t a) {
+AEABI_RTABI float __aeabi_h2f(src_t a) {
   return __extendhfsf2(a);
 }
 #else
-AEABI_RTABI float __aeabi_h2f(uint16_t a) COMPILER_RT_ALIAS(__extendhfsf2);
+AEABI_RTABI float __aeabi_h2f(src_t a) COMPILER_RT_ALIAS(__extendhfsf2);
 #endif
 #endif

compiler-rt/lib/builtins/extendhftf2.c

+//===-- lib/extendhfsf2.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)
+#define SRC_HALF
+#define DST_QUAD
+#include "fp_extend_impl.inc"
+
+COMPILER_RT_ABI long double __extendhftf2(src_t a) {
+    return __extendXfYf2__(a);
+}
+
+#endif

compiler-rt/lib/builtins/fp_extend.h

#else
     if (a & REP_C(0xffffffff00000000))
         return __builtin_clz(a >> 32);
     else
         return 32 + __builtin_clz(a & REP_C(0xffffffff));
 #endif
 }
 
 #elif defined SRC_HALF
+#if defined __aarch64__ && defined __ARM_FP16_ARGS
+// Use __fp16 if available.
+typedef __fp16 src_t;
+#else
 typedef uint16_t src_t;
+#endif
 typedef uint16_t src_rep_t;
 #define SRC_REP_C UINT16_C
 static const int srcSigBits = 10;
 #define src_rep_t_clz __builtin_clz
 
 #else
 #error Source should be half, single, or double precision!
 #endif //end source precision

compiler-rt/lib/builtins/fp_trunc.h

 
 #elif defined DST_SINGLE
 typedef float dst_t;
 typedef uint32_t dst_rep_t;
 #define DST_REP_C UINT32_C
 static const int dstSigBits = 23;
 
 #elif defined DST_HALF
+#if defined __aarch64__ && defined __ARM_FP16_ARGS
+// Use __fp16 if available.
+typedef __fp16 dst_t;
+#else
 typedef uint16_t dst_t;
+#endif
 typedef uint16_t dst_rep_t;
 #define DST_REP_C UINT16_C
 static const int dstSigBits = 10;
 
 #else
 #error Destination should be single precision or double precision!
 #endif //end destination precision
 

compiler-rt/lib/builtins/truncdfhf2.c

 //===-- lib/truncdfhf2.c - double -> 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 SRC_DOUBLE
 #define DST_HALF
 #include "fp_trunc_impl.inc"
 
-COMPILER_RT_ABI uint16_t __truncdfhf2(double a) {
+COMPILER_RT_ABI dst_t __truncdfhf2(double a) {
     return __truncXfYf2__(a);
 }
 
 #if defined(__ARM_EABI__)
 #if defined(COMPILER_RT_ARMHF_TARGET)
-AEABI_RTABI uint16_t __aeabi_d2h(double a) {
+AEABI_RTABI dst_t __aeabi_d2h(double a) {
   return __truncdfhf2(a);
 }
 #else
-AEABI_RTABI uint16_t __aeabi_d2h(double a) COMPILER_RT_ALIAS(__truncdfhf2);
+AEABI_RTABI dst_t __aeabi_d2h(double a) COMPILER_RT_ALIAS(__truncdfhf2);
 #endif
 #endif

compiler-rt/lib/builtins/truncsfhf2.c

 //===-- lib/truncsfhf2.c - single -> 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 SRC_SINGLE
 #define DST_HALF
 #include "fp_trunc_impl.inc"
 
 // Use a forwarding definition and noinline to implement a poor man's alias,
 // as there isn't a good cross-platform way of defining one.
-COMPILER_RT_ABI NOINLINE uint16_t __truncsfhf2(float a) {
+COMPILER_RT_ABI NOINLINE dst_t __truncsfhf2(float a) {
     return __truncXfYf2__(a);
 }
 
-COMPILER_RT_ABI uint16_t __gnu_f2h_ieee(float a) {
+COMPILER_RT_ABI dst_t __gnu_f2h_ieee(float a) {
     return __truncsfhf2(a);
 }
 
 #if defined(__ARM_EABI__)
 #if defined(COMPILER_RT_ARMHF_TARGET)
-AEABI_RTABI uint16_t __aeabi_f2h(float a) {
+AEABI_RTABI dst_t __aeabi_f2h(float a) {
   return __truncsfhf2(a);
 }
 #else
-AEABI_RTABI uint16_t __aeabi_f2h(float a) COMPILER_RT_ALIAS(__truncsfhf2);
+AEABI_RTABI dst_t __aeabi_f2h(float a) COMPILER_RT_ALIAS(__truncsfhf2);
 #endif
 #endif

compiler-rt/lib/builtins/trunctfhf2.c

+//===-- 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)
+#define SRC_QUAD
+#define DST_HALF
+#include "fp_trunc_impl.inc"
+
+COMPILER_RT_ABI dst_t __trunctfhf2(long double a) {
+  return __truncXfYf2__(a);
+}
+
+#endif

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

if (test__extenddftf2(makeNaN64(UINT64_C(0x7100000000000)),
                           UINT64_C(0x7fff710000000000),
                           UINT64_C(0x0)))
         return 1;
     // inf
     if (test__extenddftf2(makeInf64(),
                           UINT64_C(0x7fff000000000000),
                           UINT64_C(0x0)))
         return 1;
+    if (test__extenddftf2(-makeInf64(),
+                          UINT64_C(0xffff000000000000),
+                          UINT64_C(0x0)))
+        return 1;
     // zero
-    if (test__extenddftf2(0.0, UINT64_C(0x0), UINT64_C(0x0)))
+    if (test__extenddftf2(0.0,
+                          UINT64_C(0x0), UINT64_C(0x0)))
+        return 1;
+    if (test__extenddftf2(-0.0,
+                          UINT64_C(0x8000000000000000),
+                          UINT64_C(0x0)))
         return 1;
 
     if (test__extenddftf2(0x1.23456789abcdefp+5,
                           UINT64_C(0x400423456789abcd),
                           UINT64_C(0xf000000000000000)))
         return 1;
     if (test__extenddftf2(0x1.edcba987654321fp-9,
                           UINT64_C(0x3ff6edcba9876543),

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

 // This file tests __extendhfsf2 for the compiler_rt library.
 //
 //===----------------------------------------------------------------------===//
 
 #include <stdio.h>
 
 #include "fp_test.h"
 
-float __extendhfsf2(uint16_t a);
+float __extendhfsf2(TYPE_FP16 a);
 
 int test__extendhfsf2(uint16_t a, float expected)
 {
-    float x = __extendhfsf2(a);
-    int ret = compareResultH(x, expected);
+    TYPE_FP16 a2 = fromRep16(a);
+    float x = __extendhfsf2(a2);
+    int ret = compareResultF(x, toRep32(expected));
 
     if (ret){
         printf("error in test__extendhfsf2(%#.4x) = %f, "
                "expected %f\n", a, x, expected);
     }
     return ret;
 }
 
 char assumption_1[sizeof(__fp16) * CHAR_BIT == 16] = {0};
 
 int main()
 {
     // qNaN
     if (test__extendhfsf2(UINT16_C(0x7e00),
                           makeQNaN32()))
         return 1;
     // NaN
-    if (test__extendhfsf2(UINT16_C(0x7e00),
-                          makeNaN32(UINT32_C(0x8000))))
+    if (test__extendhfsf2(UINT16_C(0x7d00),
+                          makeQNaN32()))
         return 1;
     // inf
     if (test__extendhfsf2(UINT16_C(0x7c00),
                           makeInf32()))
         return 1;
     if (test__extendhfsf2(UINT16_C(0xfc00),
                           -makeInf32()))
         return 1;
     // zero
     if (test__extendhfsf2(UINT16_C(0x0),
                           0.0f))
         return 1;
     if (test__extendhfsf2(UINT16_C(0x8000),
                           -0.0f))
         return 1;
-
-    if (test__extendhfsf2(UINT16_C(0x4248),
-                          3.1415926535f))
-        return 1;
-    if (test__extendhfsf2(UINT16_C(0xc248),
-                          -3.1415926535f))
-        return 1;
-    if (test__extendhfsf2(UINT16_C(0x7c00),
-                          0x1.987124876876324p+100f))
-        return 1;
+    // miscellaneous
     if (test__extendhfsf2(UINT16_C(0x6e62),
                           0x1.988p+12f))
         return 1;
     if (test__extendhfsf2(UINT16_C(0x3c00),
                           0x1.0p+0f))
         return 1;
     if (test__extendhfsf2(UINT16_C(0x0400),
                           0x1.0p-14f))
         return 1;
     // denormal
     if (test__extendhfsf2(UINT16_C(0x0010),
                           0x1.0p-20f))
         return 1;
     if (test__extendhfsf2(UINT16_C(0x0001),
                           0x1.0p-24f))
         return 1;
     if (test__extendhfsf2(UINT16_C(0x8001),
                           -0x1.0p-24f))
         return 1;
-    if (test__extendhfsf2(UINT16_C(0x0001),
-                          0x1.5p-25f))
-        return 1;
-    // and back to zero
-    if (test__extendhfsf2(UINT16_C(0x0000),
-                          0x1.0p-25f))
-        return 1;
-    if (test__extendhfsf2(UINT16_C(0x8000),
-                          -0x1.0p-25f))
-        return 1;
-    // max (precise)
+    // max
     if (test__extendhfsf2(UINT16_C(0x7bff),
                           65504.0f))
         return 1;
-    // max (rounded)
-    if (test__extendhfsf2(UINT16_C(0x7bff),
-                          65504.0f))
-        return 1;
-    // max (to +inf)
-    if (test__extendhfsf2(UINT16_C(0x7c00),
-                          makeInf32()))
-        return 1;
-    if (test__extendhfsf2(UINT16_C(0xfc00),
-                          -makeInf32()))
-        return 1;
     return 0;
 }

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

+// RUN: %clang_builtins %s %librt -o %t && %run %t
+//===--------------- extendhftf2_test.c - Test __extendhftf2 --------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __extendhftf2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+#if __LDBL_MANT_DIG__ == 113
+
+#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(" FMTSTR_FP16 ") = %.20Lf, "
+               "expected %.20Lf\n", a, x, fromRep128(expectedHi, expectedLo));
+    }
+    return ret;
+}
+
+char assumption_1[sizeof(__fp16) * CHAR_BIT == 16] = {0};
+
+#endif
+
+int main()
+{
+#if __LDBL_MANT_DIG__ == 113
+    // 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

 //
 //===----------------------------------------------------------------------===//
 
 #include <stdlib.h>
 #include <limits.h>
 #include <string.h>
 #include <stdint.h>
 
+// Use __fp16 if available.
+#if defined __aarch64__ && defined __ARM_FP16_ARGS
+#define TYPE_FP16   __fp16
+#define FMTSTR_FP16 "%f"
+#else
+#define TYPE_FP16   uint16_t
+#define FMTSTR_FP16 "%#.4x"
+#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)
 {
-    return x;
+    TYPE_FP16 ret;
+    memcpy(&ret, &x, 2);
+    return ret;
 }
 
 static inline float fromRep32(uint32_t x)
 {
     float ret;
     memcpy(&ret, &x, 4);
     return ret;
 }

 {
     __uint128_t x = ((__uint128_t)hi << 64) + lo;
     long double ret;
     memcpy(&ret, &x, 16);
     return ret;
 }
 #endif
 
-static inline uint16_t toRep16(uint16_t x)
+static inline uint16_t toRep16(TYPE_FP16 x)
 {
-    return x;
+    uint16_t ret;
+    memcpy(&ret, &x, 2);
+    return ret;
 }
 
 static inline uint32_t toRep32(float x)
 {
     uint32_t ret;
     memcpy(&ret, &x, 4);
     return ret;
 }

 static inline __uint128_t toRep128(long double x)
 {
     __uint128_t ret;
     memcpy(&ret, &x, 16);
     return ret;
 }
 #endif
 
-static inline int compareResultH(uint16_t result,
+static inline int compareResultH(TYPE_FP16 result,
                                  uint16_t expected)
 {
     uint16_t rep = toRep16(result);
 
     if (rep == expected){
         return 0;
     }
     // test other possible NaN representation(signal NaN)
switch(expected){
         case GREATER_0:
             return ">0";
         default:
             return "";
     }
     return "";
 }
 
-static inline uint16_t makeQNaN16()
+static inline TYPE_FP16 makeQNaN16()
 {
     return fromRep16(0x7e00U);
 }
 
 static inline float makeQNaN32()
 {
     return fromRep32(0x7fc00000U);
 }
 
 static inline double makeQNaN64()
 {
     return fromRep64(0x7ff8000000000000UL);
 }
 
 #if __LDBL_MANT_DIG__ == 113
 static inline long double makeQNaN128()
 {
     return fromRep128(0x7fff800000000000UL, 0x0UL);
 }
 #endif
 
-static inline uint16_t makeNaN16(uint16_t rand)
+static inline TYPE_FP16 makeNaN16(uint16_t rand)
 {
     return fromRep16(0x7c00U | (rand & 0x7fffU));
 }
 
 static inline float makeNaN32(uint32_t rand)
 {
     return fromRep32(0x7f800000U | (rand & 0x7fffffU));
 }
 
 static inline double makeNaN64(uint64_t rand)
 {
     return fromRep64(0x7ff0000000000000UL | (rand & 0xfffffffffffffUL));
 }
 
 #if __LDBL_MANT_DIG__ == 113
 static inline long double makeNaN128(uint64_t rand)
 {
     return fromRep128(0x7fff000000000000UL | (rand & 0xffffffffffffUL), 0x0UL);
 }
 #endif
 
-static inline uint16_t makeInf16()
+static inline TYPE_FP16 makeInf16()
 {
     return fromRep16(0x7c00U);
 }
 
 static inline float makeInf32()
 {
     return fromRep32(0x7f800000U);
 }

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

 // This file tests __truncdfhf2 for the compiler_rt library.
 //
 //===----------------------------------------------------------------------===//
 
 #include <stdio.h>
 
 #include "fp_test.h"
 
-uint16_t __truncdfhf2(double a);
+TYPE_FP16 __truncdfhf2(double a);
 
 int test__truncdfhf2(double a, uint16_t expected)
 {
-    uint16_t x = __truncdfhf2(a);
+    TYPE_FP16 x = __truncdfhf2(a);
     int ret = compareResultH(x, expected);
 
     if (ret){
-        printf("error in test__truncdfhf2(%f) = %#.4x, "
-               "expected %#.4x\n", a, x, fromRep16(expected));
+        printf("error in test__truncdfhf2(%f) = " FMTSTR_FP16 ", "
+               "expected %#.4x\n", a, x, expected);
     }
     return ret;
 }
 
 char assumption_1[sizeof(__fp16) * CHAR_BIT == 16] = {0};
 
 int main()
 {

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

 // This file tests __truncsfhf2 for the compiler_rt library.
 //
 //===----------------------------------------------------------------------===//
 
 #include <stdio.h>
 
 #include "fp_test.h"
 
-uint16_t __truncsfhf2(float a);
+TYPE_FP16 __truncsfhf2(float a);
 
 int test__truncsfhf2(float a, uint16_t expected)
 {
-    uint16_t x = __truncsfhf2(a);
+    TYPE_FP16 x = __truncsfhf2(a);
     int ret = compareResultH(x, expected);
 
     if (ret){
-        printf("error in test__truncsfhf2(%f) = %#.4x, "
-               "expected %#.4x\n", a, x, fromRep16(expected));
+        printf("error in test__truncsfhf2(%f) = " FMTSTR_FP16 ", "
+               "expected %#.4x\n", a, x, expected);
     }
     return ret;
 }
 
 char assumption_1[sizeof(__fp16) * CHAR_BIT == 16] = {0};
 
 int main()
 {
     // qNaN
     if (test__truncsfhf2(makeQNaN32(),
                          UINT16_C(0x7e00)))
         return 1;
     // NaN
-    if (test__truncsfhf2(makeNaN32(UINT32_C(0x8000)),
-                         UINT16_C(0x7e00)))
+    if (test__truncsfhf2(makeNaN32(UINT32_C(0x00200000)),
+                         UINT16_C(0x7f00)))
         return 1;
     // inf
     if (test__truncsfhf2(makeInf32(),
                          UINT16_C(0x7c00)))
         return 1;
     if (test__truncsfhf2(-makeInf32(),
                          UINT16_C(0xfc00)))
         return 1;

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

 // RUN: %clang_builtins %s %librt -o %t && %run %t
-
-//===--------------- truncsfhf2_test.c - Test __truncsfhf2 ----------------===//
+//===--------------- trunctfhf2_test.c - Test __trunctfhf2 ----------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 //
-// This file tests __truncsfhf2 for the compiler_rt library.
+// This file tests __trunctfhf2 for the compiler_rt library.
 //
 //===----------------------------------------------------------------------===//
 
+#include "int_lib.h"
 #include <stdio.h>
 
+#if __LDBL_MANT_DIG__ == 113
+
 #include "fp_test.h"
 
-uint16_t __truncsfhf2(float a);
+TYPE_FP16 __trunctfhf2(long double a);
 
-int test__truncsfhf2(float a, uint16_t expected)
+int test__trunctfhf2(long double a, uint16_t expected)
 {
-    uint16_t x = __truncsfhf2(a);
+    TYPE_FP16 x = __trunctfhf2(a);
     int ret = compareResultH(x, expected);
 
-    if (ret){
-        printf("error in test__truncsfhf2(%f) = %#.4x, "
-               "expected %#.4x\n", a, x, fromRep16(expected));
+    if (ret)
+    {
+        printf("error in test__trunctfhf2(%.20Lf) = " FMTSTR_FP16 ", "
+               "expected %#.4x\n", a, x, expected);
     }
     return ret;
 }
 
 char assumption_1[sizeof(__fp16) * CHAR_BIT == 16] = {0};
 
+#endif
+
 int main()
 {
+#if __LDBL_MANT_DIG__ == 113
     // qNaN
-    if (test__truncsfhf2(makeQNaN32(),
+    if (test__trunctfhf2(makeQNaN128(),
                          UINT16_C(0x7e00)))
         return 1;
     // NaN
-    if (test__truncsfhf2(makeNaN32(UINT32_C(0x8000)),
+    if (test__trunctfhf2(makeNaN128(UINT64_C(0x810000000000)),
                          UINT16_C(0x7e00)))
         return 1;
     // inf
-    if (test__truncsfhf2(makeInf32(),
+    if (test__trunctfhf2(makeInf128(),
                          UINT16_C(0x7c00)))
         return 1;
-    if (test__truncsfhf2(-makeInf32(),
+    if (test__trunctfhf2(-makeInf128(),
                          UINT16_C(0xfc00)))
         return 1;
     // zero
-    if (test__truncsfhf2(0.0f, UINT16_C(0x0)))
+    if (test__trunctfhf2(0.0L, UINT16_C(0x0)))
         return 1;
-    if (test__truncsfhf2(-0.0f, UINT16_C(0x8000)))
+    if (test__trunctfhf2(-0.0L, UINT16_C(0x8000)))
         return 1;
 
-    if (test__truncsfhf2(3.1415926535f,
+    if (test__trunctfhf2(3.1415926535L,
                          UINT16_C(0x4248)))
         return 1;
-    if (test__truncsfhf2(-3.1415926535f,
+    if (test__trunctfhf2(-3.1415926535L,
                          UINT16_C(0xc248)))
         return 1;
-    if (test__truncsfhf2(0x1.987124876876324p+100f,
+    if (test__trunctfhf2(0x1.987124876876324p+100L,
                          UINT16_C(0x7c00)))
         return 1;
-    if (test__truncsfhf2(0x1.987124876876324p+12f,
+    if (test__trunctfhf2(0x1.987124876876324p+12L,
                          UINT16_C(0x6e62)))
         return 1;
-    if (test__truncsfhf2(0x1.0p+0f,
+    if (test__trunctfhf2(0x1.0p+0L,
                          UINT16_C(0x3c00)))
         return 1;
-    if (test__truncsfhf2(0x1.0p-14f,
+    if (test__trunctfhf2(0x1.0p-14L,
                          UINT16_C(0x0400)))
         return 1;
     // denormal
-    if (test__truncsfhf2(0x1.0p-20f,
+    if (test__trunctfhf2(0x1.0p-20L,
                          UINT16_C(0x0010)))
         return 1;
-    if (test__truncsfhf2(0x1.0p-24f,
+    if (test__trunctfhf2(0x1.0p-24L,
                          UINT16_C(0x0001)))
         return 1;
-    if (test__truncsfhf2(-0x1.0p-24f,
+    if (test__trunctfhf2(-0x1.0p-24L,
                          UINT16_C(0x8001)))
         return 1;
-    if (test__truncsfhf2(0x1.5p-25f,
+    if (test__trunctfhf2(0x1.5p-25L,
                          UINT16_C(0x0001)))
         return 1;
     // and back to zero
-    if (test__truncsfhf2(0x1.0p-25f,
+    if (test__trunctfhf2(0x1.0p-25L,
                          UINT16_C(0x0000)))
         return 1;
-    if (test__truncsfhf2(-0x1.0p-25f,
+    if (test__trunctfhf2(-0x1.0p-25L,
                          UINT16_C(0x8000)))
         return 1;
     // max (precise)
-    if (test__truncsfhf2(65504.0f,
+    if (test__trunctfhf2(65504.0L,
                          UINT16_C(0x7bff)))
         return 1;
     // max (rounded)
-    if (test__truncsfhf2(65519.0f,
+    if (test__trunctfhf2(65519.0L,
                          UINT16_C(0x7bff)))
         return 1;
     // max (to +inf)
-    if (test__truncsfhf2(65520.0f,
+    if (test__trunctfhf2(65520.0L,
                          UINT16_C(0x7c00)))
         return 1;
-    if (test__truncsfhf2(65536.0f,
+    if (test__trunctfhf2(65536.0L,
                          UINT16_C(0x7c00)))
         return 1;
-    if (test__truncsfhf2(-65520.0f,
+    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;
 }

llvm/include/llvm/IR/RuntimeLibcalls.def

 HANDLE_LIBCALL(FMAX_PPCF128, "fmaxl")
 
 // Conversion
 HANDLE_LIBCALL(FPEXT_F32_PPCF128, "__gcc_stoq")
 HANDLE_LIBCALL(FPEXT_F64_PPCF128, "__gcc_dtoq")
 HANDLE_LIBCALL(FPEXT_F80_F128, "__extendxftf2")
 HANDLE_LIBCALL(FPEXT_F64_F128, "__extenddftf2")
 HANDLE_LIBCALL(FPEXT_F32_F128, "__extendsftf2")
+HANDLE_LIBCALL(FPEXT_F16_F128, "__extendhftf2")
 HANDLE_LIBCALL(FPEXT_F32_F64, "__extendsfdf2")
 HANDLE_LIBCALL(FPEXT_F16_F32, "__gnu_h2f_ieee")
 HANDLE_LIBCALL(FPROUND_F32_F16, "__gnu_f2h_ieee")
 HANDLE_LIBCALL(FPROUND_F64_F16, "__truncdfhf2")
 HANDLE_LIBCALL(FPROUND_F80_F16, "__truncxfhf2")
 HANDLE_LIBCALL(FPROUND_F128_F16, "__trunctfhf2")
 HANDLE_LIBCALL(FPROUND_PPCF128_F16, "__trunctfhf2")
 HANDLE_LIBCALL(FPROUND_F64_F32, "__truncdfsf2")

llvm/lib/CodeGen/TargetLoweringBase.cpp

 }
 
 /// getFPEXT - Return the FPEXT_*_* value for the given types, or
 /// UNKNOWN_LIBCALL if there is none.
 RTLIB::Libcall RTLIB::getFPEXT(EVT OpVT, EVT RetVT) {
   if (OpVT == MVT::f16) {
     if (RetVT == MVT::f32)
       return FPEXT_F16_F32;
+    if (RetVT == MVT::f128)
+      return FPEXT_F16_F128;
   } else if (OpVT == MVT::f32) {
     if (RetVT == MVT::f64)
       return FPEXT_F32_F64;
     if (RetVT == MVT::f128)
       return FPEXT_F32_F128;
     if (RetVT == MVT::ppcf128)
       return FPEXT_F32_PPCF128;
   } else if (OpVT == MVT::f64) {

llvm/lib/Target/AArch64/AArch64ISelLowering.cpp

AArch64TargetLowering::AArch64TargetLowering(const TargetMachine &TM,
   setOperationAction(ISD::FP_TO_UINT, MVT::i64, Custom);
   setOperationAction(ISD::FP_TO_UINT, MVT::i128, Custom);
   setOperationAction(ISD::SINT_TO_FP, MVT::i32, Custom);
   setOperationAction(ISD::SINT_TO_FP, MVT::i64, Custom);
   setOperationAction(ISD::SINT_TO_FP, MVT::i128, Custom);
   setOperationAction(ISD::UINT_TO_FP, MVT::i32, Custom);
   setOperationAction(ISD::UINT_TO_FP, MVT::i64, Custom);
   setOperationAction(ISD::UINT_TO_FP, MVT::i128, Custom);
+  setOperationAction(ISD::FP_ROUND, MVT::f16, Custom);
   setOperationAction(ISD::FP_ROUND, MVT::f32, Custom);
   setOperationAction(ISD::FP_ROUND, MVT::f64, Custom);
 
   // Variable arguments.
   setOperationAction(ISD::VASTART, MVT::Other, Custom);
   setOperationAction(ISD::VAARG, MVT::Other, Custom);
   setOperationAction(ISD::VACOPY, MVT::Other, Custom);
   setOperationAction(ISD::VAEND, MVT::Other, Expand);

llvm/test/CodeGen/AArch64/arm64-fp128.ll

 ; CHECK-NEXT: %bb.
 ; CHECK-NEXT: mov v[[VAL:[0-9]+]].16b, v0.16b
 ; CHECK-NEXT: [[IFFALSE]]:
 ; CHECK: str q[[VAL]], [{{x[0-9]+}}, :lo12:lhs]
   ret void
 ; CHECK: ret
 }
 
+@varhalf = global half 0.0, align 2
 @varfloat = global float 0.0, align 4
 @vardouble = global double 0.0, align 8
 
 define void @test_round() {
 ; CHECK-LABEL: test_round:
 
   %val = load fp128, fp128* @lhs, align 16
 
+  %half = fptrunc fp128 %val to half
+  store half %half, half* @varhalf, align 2
+; CHECK: ldr q0, [{{x[0-9]+}}, :lo12:lhs]
+; CHECK: bl __trunctfhf2
+; CHECK: str h0, [{{x[0-9]+}}, :lo12:varhalf]
+
   %float = fptrunc fp128 %val to float
   store float %float, float* @varfloat, align 4
 ; CHECK: bl __trunctfsf2
 ; CHECK: str s0, [{{x[0-9]+}}, :lo12:varfloat]
 
   %double = fptrunc fp128 %val to double
   store double %double, double* @vardouble, align 8
 ; CHECK: bl __trunctfdf2
 ; CHECK: str d0, [{{x[0-9]+}}, :lo12:vardouble]
 
   ret void
 }
 
 define void @test_extend() {
 ; CHECK-LABEL: test_extend:
 
   %val = load fp128, fp128* @lhs, align 16
 
+  %half = load half, half* @varhalf
+  %fromhalf = fpext half %half to fp128
+  store volatile fp128 %fromhalf, fp128* @lhs, align 16
+; CHECK: ldr h0, [{{x[0-9]+}}, :lo12:varhalf]
+; CHECK: bl __extendhftf2
+; CHECK: str q0, [{{x[0-9]+}}, :lo12:lhs]
+
   %float = load float, float* @varfloat
   %fromfloat = fpext float %float to fp128
   store volatile fp128 %fromfloat, fp128* @lhs, align 16
 ; CHECK: bl __extendsftf2
 ; CHECK: str q0, [{{x[0-9]+}}, :lo12:lhs]
 
   %double = load double, double* @vardouble
   %fromdouble = fpext double %double to fp128