[Builtins] Implement half-precision conversions.

[ab]

Summary

Mostly uninteresting, except:

• in __extendXfYf2, when checking if the number is normal, the current code relies on the unsignedness of src_rep_t, which is fine. Except that when sizeof(src_rep_t) < sizeof(int), the result gets promoted to int, the signedness of which breaks the comparison. I added an explicit cast to avoid that; it shouldn't affect other types.

• we can't just pass __fp16 around (you even get a clang error), so I made uint16_t explicit.

• is there a good way to define aliases (for the gnu_*_ieee names) ? Using the attribute, on darwin, clang complains about only weak aliases being supported, so I went with the simple def.

I also need to finish writing unit tests in compiler-rt proper (I paused when I realized lit+cmake isn't supported). In the meantime, opinions welcome.

[scanon]

Looks reasonable to me. Someone else will need to answer your question about gnu_*_ieee aliases.

– Steve

[ab]

After some investigation into aliases, I don't think there's a better alternative to duplicated bodies, so I went ahead with that.

Thanks!
-Ahmed

lib/builtins/CMakeLists.txt

set(GENERIC_SOURCES
   divsf3.c
   divsi3.c
   divti3.c
   divtf3.c
   divxc3.c
   enable_execute_stack.c
   eprintf.c
   extendsfdf2.c
+  extendhfsf2.c
   ffsdi2.c
   ffsti2.c
   fixdfdi.c
   fixdfsi.c
   fixdfti.c
   fixsfdi.c
   fixsfsi.c
   fixsfti.c
set(GENERIC_SOURCES
   powixf2.c
   subdf3.c
   subsf3.c
   subvdi3.c
   subvsi3.c
   subvti3.c
   subtf3.c
   trampoline_setup.c
+  truncdfhf2.c
   truncdfsf2.c
+  truncsfhf2.c
   ucmpdi2.c
   ucmpti2.c
   udivdi3.c
   udivmoddi4.c
   udivmodsi4.c
   udivmodti4.c
   udivsi3.c
   udivti3.c

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"
+
+COMPILER_RT_ABI float __extendhfsf2(uint16_t a) {
+    return __extendXfYf2__(a);
+}
+
+COMPILER_RT_ABI float __gnu_h2f_ieee(uint16_t a) {
+    return __extendhfsf2(a);
+}

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
+typedef uint16_t src_t;
+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 single precision or double precision!
+#error Source should be half, single, or double precision!
 #endif //end source precision
 
-#if defined DST_DOUBLE
+#if 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_DOUBLE
 typedef double dst_t;
 typedef uint64_t dst_rep_t;
 #define DST_REP_C UINT64_C
 static const int dstSigBits = 52;
 
 #elif defined DST_QUAD
 typedef long double dst_t;
 typedef __uint128_t dst_rep_t;
 #define DST_REP_C (__uint128_t)
 static const int dstSigBits = 112;
 
 #else
-#error Destination should be double precision or quad precision!
+#error Destination should be single, double, or quad precision!
 #endif //end destination precision
 
 // End of specialization parameters.  Two helper routines for conversion to and
 // from the representation of floating-point data as integer values follow.
 
 static inline src_rep_t srcToRep(src_t x) {
     const union { src_t f; src_rep_t i; } rep = {.f = x};
     return rep.i;

lib/builtins/fp_extend_impl.inc

static inline dst_t __extendXfYf2__(src_t a) {
     const dst_rep_t dstMinNormal = DST_REP_C(1) << dstSigBits;
 
     // Break a into a sign and representation of the absolute value
     const src_rep_t aRep = srcToRep(a);
     const src_rep_t aAbs = aRep & srcAbsMask;
     const src_rep_t sign = aRep & srcSignMask;
     dst_rep_t absResult;
 
-    if (aAbs - srcMinNormal < srcInfinity - srcMinNormal) {
+    if ((src_rep_t)(aAbs - srcMinNormal) < srcInfinity - srcMinNormal) {
         // a is a normal number.
         // Extend to the destination type by shifting the significand and
         // exponent into the proper position and rebiasing the exponent.
         absResult = (dst_rep_t)aAbs << (dstSigBits - srcSigBits);
         absResult += (dst_rep_t)(dstExpBias - srcExpBias) << dstSigBits;
     }
 
     else if (aAbs >= srcInfinity) {

lib/builtins/fp_trunc.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef FP_TRUNC_HEADER
 #define FP_TRUNC_HEADER
 
 #include "int_lib.h"
 
-#if defined SRC_DOUBLE
+#if defined SRC_SINGLE
+typedef float src_t;
+typedef uint32_t src_rep_t;
+#define SRC_REP_C UINT32_C
+static const int srcSigBits = 23;
+
+#elif defined SRC_DOUBLE
 typedef double src_t;
 typedef uint64_t src_rep_t;
 #define SRC_REP_C UINT64_C
 static const int srcSigBits = 52;
 
 #elif defined SRC_QUAD
 typedef long double src_t;
 typedef __uint128_t src_rep_t;

 static const int dstSigBits = 52;
 
 #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
+typedef uint16_t dst_t;
+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
 
 // End of specialization parameters.  Two helper routines for conversion to and
 // from the representation of floating-point data as integer values follow.
 
 static inline src_rep_t srcToRep(src_t x) {

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) {
+    return __truncXfYf2__(a);
+}

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"
+
+COMPILER_RT_ABI uint16_t __truncsfhf2(float a) {
+    return __truncXfYf2__(a);
+}
+
+COMPILER_RT_ABI uint16_t __gnu_f2h_ieee(float a) {
+    return __truncsfhf2(a);
+}