Fix incorrect truncation at the overflow boundary

[pirama]

Summary

This patch fixes incorrect truncation when the input wider value is
exactly 2^dstBits. For that value, the overflow to infinity is not
correctly handled. The fix is to replace a strict '>' with '>='.

Currently,
truncdfsf2(340282366900000000000000000000000000000.0) returns infinity
truncdfsf2(340282366920938463463374607431768211456.0) returns 0
__truncdfsf2(400000000000000000000000000000000000000.0) returns infinity

Likewise, truncdfhf2 and truncsfhf2 (and consequently gnu_f2h_ieee)
are discontinuous at 65536.0.

This patch adds tests for all three cases, along with adding a missing
header include to fp_test.h.

[ab]

Nice catch! LGTM; Steve?

-Ahmed

[scanon]

LGTM.

compiler-rt/trunk/lib/builtins/fp_trunc_impl.inc

static inline dst_t __truncXfYf2__(src_t a) {
     else if (aAbs > srcInfinity) {
         // a is NaN.
         // Conjure the result by beginning with infinity, setting the qNaN
         // bit and inserting the (truncated) trailing NaN field.
         absResult = (dst_rep_t)dstInfExp << dstSigBits;
         absResult |= dstQNaN;
         absResult |= ((aAbs & srcNaNCode) >> (srcSigBits - dstSigBits)) & dstNaNCode;
     }
-    else if (aAbs > overflow) {
+    else if (aAbs >= overflow) {
         // a overflows to infinity.
         absResult = (dst_rep_t)dstInfExp << dstSigBits;
     }
     else {
         // a underflows on conversion to the destination type or is an exact
         // zero.  The result may be a denormal or zero.  Extract the exponent
         // to get the shift amount for the denormalization.
         const int aExp = aAbs >> srcSigBits;

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

 //===--------------------------- fp_test.h - ------------------------------===//
 //
 //                     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 defines shared functions for the test.
 //
 //===----------------------------------------------------------------------===//
 
 #include <stdlib.h>
 #include <limits.h>
 #include <string.h>
+#include <stdint.h>
 
 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)
 {
     return x;

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

if (test__truncdfhf2(65519.0,
         return 1;
     // max (to +inf)
     if (test__truncdfhf2(65520.0,
                          UINT16_C(0x7c00)))
         return 1;
     if (test__truncdfhf2(-65520.0,
                          UINT16_C(0xfc00)))
         return 1;
+    if (test__truncdfhf2(65536.0,
+                         UINT16_C(0x7c00)))
+        return 1;
     return 0;
 }

compiler-rt/trunk/test/builtins/Unit/truncdfsf2_test.c

+//===--------------- truncdfsf2_test.c - Test __truncdfsf2 ----------------===//
+//
+//                     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 __truncdfsf2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+
+#include "fp_test.h"
+
+float __truncdfsf2(double a);
+
+int test__truncdfsf2(double a)
+{
+    float actual = __truncdfsf2(a);
+    float expected = a;
+
+    if (actual != expected) {
+        printf("error in test__truncdfsf2(%lf) = %f, "
+               "expected %f\n", a, actual, expected);
+        return 1;
+    }
+    return 0;
+}
+
+int main()
+{
+    if (test__truncdfsf2(340282366920938463463374607431768211456.0))
+        return 1;
+    return 0;
+}

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

int main()
     // max (rounded)
     if (test__truncsfhf2(65519.0f,
                          UINT16_C(0x7bff)))
         return 1;
     // max (to +inf)
     if (test__truncsfhf2(65520.0f,
                          UINT16_C(0x7c00)))
         return 1;
+    if (test__truncsfhf2(65536.0f,
+                         UINT16_C(0x7c00)))
+        return 1;
     if (test__truncsfhf2(-65520.0f,
                          UINT16_C(0xfc00)))
         return 1;
     return 0;
 }