[libc] Add implementations of ldexp[f|l].

[sivachandra]

Summary

The rounding behavior of NormalFloat to float format has been changed
to round to nearest. Also, a bug in NormalFloat to subnormal number
conversion has been fixed.

[lntue]

libc/test/src/math/LdExpTest.h

117

Isn't it going to show (LdExpTest, SpecialNumbers) for all float, double, and long double tests?
Maybe append ##T to LdExpTest to distinguish between different data types?

libc/utils/FPUtil/NormalFloat.h

123

Can you test the case (S, E, M) = (0, 0x1, 0b11....1) and exp = -1? The output should be (0, 0x1, 0b00..0).

237

Can you test with similar example as the above comment?

[sivachandra]

Handle mantissa overflow.

[sivachandra]

libc/test/src/math/LdExpTest.h

117

Because of the space in long double, we cannot just append. Also, since this macro is to be used from different TUs, it does matter if all the classes have the same name. If we ever need different names, we can easily add a suffix argument to the macro.

libc/utils/FPUtil/NormalFloat.h

123

Ah, good catch! Also means I should not be sending out patches at midnight! Fixed it now.

237

Same as above.

[lntue]

libc/utils/FPUtil/NormalFloat.h

131

since output's sign is always be the same as the input's sign, maybe set result.sign = sign earlier, then this branch can simply be return result?

249

Similar as above

[sivachandra]

Address comments.

libc/config/linux/aarch64/entrypoints.txt

set(TARGET_LIBM_ENTRYPOINTS
     libc.src.math.fminl
     libc.src.math.frexp
     libc.src.math.frexpf
     libc.src.math.frexpl
     libc.src.math.hypotf
     libc.src.math.ilogb
     libc.src.math.ilogbf
     libc.src.math.ilogbl
+    libc.src.math.ldexp
+    libc.src.math.ldexpf
+    libc.src.math.ldexpl
     libc.src.math.logb
     libc.src.math.logbf
     libc.src.math.logbl
     libc.src.math.modf
     libc.src.math.modff
     libc.src.math.modfl
     libc.src.math.round
     libc.src.math.roundf

libc/config/linux/x86_64/entrypoints.txt

set(TARGET_LIBM_ENTRYPOINTS
     libc.src.math.fmaxl
     libc.src.math.frexp
     libc.src.math.frexpf
     libc.src.math.frexpl
     libc.src.math.hypotf
     libc.src.math.ilogb
     libc.src.math.ilogbf
     libc.src.math.ilogbl
+    libc.src.math.ldexp
+    libc.src.math.ldexpf
+    libc.src.math.ldexpl
     libc.src.math.logb
     libc.src.math.logbf
     libc.src.math.logbl
     libc.src.math.modf
     libc.src.math.modff
     libc.src.math.modfl
     libc.src.math.remainderf
     libc.src.math.remainder

libc/spec/stdc.td

HeaderSpec Math = HeaderSpec<
           FunctionSpec<"frexpl", RetValSpec<LongDoubleType>, [ArgSpec<LongDoubleType>, ArgSpec<IntPtr>]>,
 
           FunctionSpec<"hypotf", RetValSpec<FloatType>, [ArgSpec<FloatType>, ArgSpec<FloatType>]>,
 
           FunctionSpec<"ilogb", RetValSpec<IntType>, [ArgSpec<DoubleType>]>,
           FunctionSpec<"ilogbf", RetValSpec<IntType>, [ArgSpec<FloatType>]>,
           FunctionSpec<"ilogbl", RetValSpec<IntType>, [ArgSpec<LongDoubleType>]>,
 
+          FunctionSpec<"ldexp", RetValSpec<DoubleType>, [ArgSpec<DoubleType>, ArgSpec<IntType>]>,
+          FunctionSpec<"ldexpf", RetValSpec<FloatType>, [ArgSpec<FloatType>, ArgSpec<IntType>]>,
+          FunctionSpec<"ldexpl", RetValSpec<LongDoubleType>, [ArgSpec<LongDoubleType>, ArgSpec<IntType>]>,
+
           FunctionSpec<"logb", RetValSpec<DoubleType>, [ArgSpec<DoubleType>]>,
           FunctionSpec<"logbf", RetValSpec<FloatType>, [ArgSpec<FloatType>]>,
           FunctionSpec<"logbl", RetValSpec<LongDoubleType>, [ArgSpec<LongDoubleType>]>,
 
           FunctionSpec<"modf", RetValSpec<DoubleType>, [ArgSpec<DoubleType>, ArgSpec<DoublePtr>]>,
           FunctionSpec<"modff", RetValSpec<FloatType>, [ArgSpec<FloatType>, ArgSpec<FloatPtr>]>,
           FunctionSpec<"modfl", RetValSpec<LongDoubleType>, [ArgSpec<LongDoubleType>, ArgSpec<LongDoublePtr>]>,
 

libc/src/math/CMakeLists.txt

HDRS
     ilogbl.h
   DEPENDS
     libc.utils.FPUtil.fputil
   COMPILE_OPTIONS
     -O2
 )
 
 add_entrypoint_object(
+  ldexp
+  SRCS
+    ldexp.cpp
+  HDRS
+    ldexp.h
+  DEPENDS
+    libc.utils.FPUtil.fputil
+  COMPILE_OPTIONS
+    -O2
+)
+
+add_entrypoint_object(
+  ldexpf
+  SRCS
+    ldexpf.cpp
+  HDRS
+    ldexpf.h
+  DEPENDS
+    libc.utils.FPUtil.fputil
+  COMPILE_OPTIONS
+    -O2
+)
+
+add_entrypoint_object(
+  ldexpl
+  SRCS
+    ldexpl.cpp
+  HDRS
+    ldexpl.h
+  DEPENDS
+    libc.utils.FPUtil.fputil
+  COMPILE_OPTIONS
+    -O2
+)
+
+add_entrypoint_object(
   logb
   SRCS
     logb.cpp
   HDRS
     logb.h
   DEPENDS
     libc.utils.FPUtil.fputil
   COMPILE_OPTIONS

libc/src/math/ldexp.h

+//===-- Implementation header for ldexp -------------------------*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIBC_SRC_MATH_LDEXP_H
+#define LLVM_LIBC_SRC_MATH_LDEXP_H
+
+namespace __llvm_libc {
+
+double ldexp(double x, int exp);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_MATH_LDEXP_H

libc/src/math/ldexp.cpp

+//===-- Implementation of ldexp function ----------------------------------===//
+//
+// 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 "src/__support/common.h"
+#include "utils/FPUtil/ManipulationFunctions.h"
+
+namespace __llvm_libc {
+
+double LLVM_LIBC_ENTRYPOINT(ldexp)(double x, int exp) {
+  return fputil::ldexp(x, exp);
+}
+
+} // namespace __llvm_libc

libc/src/math/ldexpf.h

+//===-- Implementation header for ldexpf ------------------------*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIBC_SRC_MATH_LDEXPF_H
+#define LLVM_LIBC_SRC_MATH_LDEXPF_H
+
+namespace __llvm_libc {
+
+float ldexpf(float x, int exp);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_MATH_LDEXPF_H

libc/src/math/ldexpf.cpp

+//===-- Implementation of ldexpf function ---------------------------------===//
+//
+// 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 "src/__support/common.h"
+#include "utils/FPUtil/ManipulationFunctions.h"
+
+namespace __llvm_libc {
+
+float LLVM_LIBC_ENTRYPOINT(ldexpf)(float x, int exp) {
+  return fputil::ldexp(x, exp);
+}
+
+} // namespace __llvm_libc

libc/src/math/ldexpl.h

+//===-- Implementation header for ldexpl ------------------------*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIBC_SRC_MATH_ldexpl_H
+#define LLVM_LIBC_SRC_MATH_ldexpl_H
+
+namespace __llvm_libc {
+
+long double ldexpl(long double x, int exp);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_MATH_ldexpl_H

libc/src/math/ldexpl.cpp

+//===-- Implementation of ldexpl function ---------------------------------===//
+//
+// 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 "src/__support/common.h"
+#include "utils/FPUtil/ManipulationFunctions.h"
+
+namespace __llvm_libc {
+
+long double LLVM_LIBC_ENTRYPOINT(ldexpl)(long double x, int exp) {
+  return fputil::ldexp(x, exp);
+}
+
+} // namespace __llvm_libc

libc/test/src/math/CMakeLists.txt

HDRS
     ILogbTest.h
   DEPENDS
     libc.include.math
     libc.src.math.ilogbl
     libc.utils.FPUtil.fputil
 )
 
 add_fp_unittest(
+  ldexp_test
+  SUITE
+    libc_math_unittests
+  SRCS
+    ldexp_test.cpp
+  HDRS
+    LdExpTest.h
+  DEPENDS
+    libc.include.math
+    libc.src.math.ldexp
+    libc.utils.FPUtil.fputil
+)
+
+add_fp_unittest(
+  ldexpf_test
+  SUITE
+    libc_math_unittests
+  SRCS
+    ldexpf_test.cpp
+  HDRS
+    LdExpTest.h
+  DEPENDS
+    libc.include.math
+    libc.src.math.ldexpf
+    libc.utils.FPUtil.fputil
+)
+
+add_fp_unittest(
+  ldexpl_test
+  SUITE
+    libc_math_unittests
+  SRCS
+    ldexpl_test.cpp
+  HDRS
+    LdExpTest.h
+  DEPENDS
+    libc.include.math
+    libc.src.math.ldexpl
+    libc.utils.FPUtil.fputil
+)
+
+add_fp_unittest(
   logb_test
   SUITE
     libc_math_unittests
   SRCS
     logb_test.cpp
   DEPENDS
     libc.include.math
     libc.src.math.logb

libc/test/src/math/LdExpTest.h

+//===-- Utility class to test different flavors of ldexp --------*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIBC_TEST_SRC_MATH_LDEXPTEST_H
+#define LLVM_LIBC_TEST_SRC_MATH_LDEXPTEST_H
+
+#include "utils/FPUtil/FPBits.h"
+#include "utils/FPUtil/NormalFloat.h"
+#include "utils/FPUtil/TestHelpers.h"
+#include "utils/UnitTest/Test.h"
+
+#include <limits.h>
+#include <math.h>
+#include <stdint.h>
+
+template <typename T>
+class LdExpTestTemplate : public __llvm_libc::testing::Test {
+  using FPBits = __llvm_libc::fputil::FPBits<T>;
+  using NormalFloat = __llvm_libc::fputil::NormalFloat<T>;
+  using UIntType = typename FPBits::UIntType;
+  static constexpr UIntType mantissaWidth =
+      __llvm_libc::fputil::MantissaWidth<T>::value;
+  // A normalized mantissa to be used with tests.
+  static constexpr UIntType mantissa = NormalFloat::one + 0x1234;
+
+  const T zero = __llvm_libc::fputil::FPBits<T>::zero();
+  const T negZero = __llvm_libc::fputil::FPBits<T>::negZero();
+  const T inf = __llvm_libc::fputil::FPBits<T>::inf();
+  const T negInf = __llvm_libc::fputil::FPBits<T>::negInf();
+  const T nan = __llvm_libc::fputil::FPBits<T>::buildNaN(1);
+
+public:
+  typedef T (*LdExpFunc)(T, int);
+
+  void testSpecialNumbers(LdExpFunc func) {
+    int expArray[5] = {-INT_MAX - 1, -10, 0, 10, INT_MAX};
+    for (int exp : expArray) {
+      ASSERT_FP_EQ(zero, func(zero, exp));
+      ASSERT_FP_EQ(negZero, func(negZero, exp));
+      ASSERT_FP_EQ(inf, func(inf, exp));
+      ASSERT_FP_EQ(negInf, func(negInf, exp));
+      ASSERT_NE(isnan(func(nan, exp)), 0);
+    }
+  }
+
+  void testPowersOfTwo(LdExpFunc func) {
+    int32_t expArray[5] = {1, 2, 3, 4, 5};
+    int32_t valArray[6] = {1, 2, 4, 8, 16, 32};
+    for (int32_t exp : expArray) {
+      for (int32_t val : valArray) {
+        ASSERT_FP_EQ(T(val << exp), func(T(val), exp));
+        ASSERT_FP_EQ(T(-1 * (val << exp)), func(T(-val), exp));
+      }
+    }
+  }
+
+  void testOverflow(LdExpFunc func) {
+    NormalFloat x(FPBits::maxExponent - 10, NormalFloat::one + 0xF00BA, 0);
+    for (int32_t exp = 10; exp < 100; ++exp) {
+      ASSERT_FP_EQ(inf, func(T(x), exp));
+      ASSERT_FP_EQ(negInf, func(-T(x), exp));
+    }
+  }
+
+  void testUnderflowToZeroOnNormal(LdExpFunc func) {
+    // In this test, we pass a normal nubmer to func and expect zero
+    // to be returned due to underflow.
+    int32_t baseExponent = FPBits::exponentBias + mantissaWidth;
+    int32_t expArray[] = {baseExponent + 5, baseExponent + 4, baseExponent + 3,
+                          baseExponent + 2, baseExponent + 1};
+    T x = NormalFloat(0, mantissa, 0);
+    for (int32_t exp : expArray) {
+      ASSERT_FP_EQ(func(x, -exp), x > 0 ? zero : negZero);
+    }
+  }
+
+  void testUnderflowToZeroOnSubnormal(LdExpFunc func) {
+    // In this test, we pass a normal nubmer to func and expect zero
+    // to be returned due to underflow.
+    int32_t baseExponent = FPBits::exponentBias + mantissaWidth;
+    int32_t expArray[] = {baseExponent + 5, baseExponent + 4, baseExponent + 3,
+                          baseExponent + 2, baseExponent + 1};
+    T x = NormalFloat(-FPBits::exponentBias, mantissa, 0);
+    for (int32_t exp : expArray) {
+      ASSERT_FP_EQ(func(x, -exp), x > 0 ? zero : negZero);
+    }
+  }
+
+  void testNormalOperation(LdExpFunc func) {
+    T valArray[] = {
+        // Normal numbers
+        NormalFloat(100, mantissa, 0), NormalFloat(-100, mantissa, 0),
+        NormalFloat(100, mantissa, 1), NormalFloat(-100, mantissa, 1),
+        // Subnormal numbers
+        NormalFloat(-FPBits::exponentBias, mantissa, 0),
+        NormalFloat(-FPBits::exponentBias, mantissa, 1)};
+    for (int32_t exp = 0; exp <= static_cast<int32_t>(mantissaWidth); ++exp) {
+      for (T x : valArray) {
+        // We compare the result of ldexp with the result
+        // of the native multiplication/division instruction.
+        ASSERT_FP_EQ(func(x, exp), x * (UIntType(1) << exp));
+        ASSERT_FP_EQ(func(x, -exp), x / (UIntType(1) << exp));
+      }
+    }
+
+    // Normal which trigger mantissa overflow.
+    T x = NormalFloat(-FPBits::exponentBias + 1, 2 * NormalFloat::one - 1, 0);
+    ASSERT_FP_EQ(func(x, -1), x / 2);
+    ASSERT_FP_EQ(func(-x, -1), -x / 2);
+  }
+};
+
+#define LIST_LDEXP_TESTS(T, func)                                              \
+  using LdExpTest = LdExpTestTemplate<T>;                                      \
+  TEST_F(LdExpTest, SpecialNumbers) { testSpecialNumbers(&func); }             \
+  TEST_F(LdExpTest, PowersOfTwo) { testPowersOfTwo(&func); }                   \
+  TEST_F(LdExpTest, OverFlow) { testOverflow(&func); }                         \
+  TEST_F(LdExpTest, UnderflowToZeroOnNormal) {                                 \
+    testUnderflowToZeroOnNormal(&func);                                        \
+  }                                                                            \
+  TEST_F(LdExpTest, UnderflowToZeroOnSubnormal) {                              \
+    testUnderflowToZeroOnSubnormal(&func);                                     \
+  }                                                                            \
+  TEST_F(LdExpTest, NormalOperation) { testNormalOperation(&func); }
+
+#endif // LLVM_LIBC_TEST_SRC_MATH_LDEXPTEST_H

libc/test/src/math/ldexp_test.cpp

+//===-- Unittests for ldexp -----------------------------------------------===//
+//
+// 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 "LdExpTest.h"
+
+#include "include/math.h"
+#include "src/math/ldexp.h"
+#include "utils/CPP/Functional.h"
+#include "utils/FPUtil/FPBits.h"
+#include "utils/FPUtil/ManipulationFunctions.h"
+#include "utils/FPUtil/TestHelpers.h"
+#include "utils/UnitTest/Test.h"
+
+#include <limits.h>
+
+LIST_LDEXP_TESTS(double, __llvm_libc::ldexp)

libc/test/src/math/ldexpf_test.cpp

+//===-- Unittests for ldexpf ----------------------------------------------===//
+//
+// 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 "LdExpTest.h"
+
+#include "include/math.h"
+#include "src/math/ldexpf.h"
+#include "utils/CPP/Functional.h"
+#include "utils/FPUtil/FPBits.h"
+#include "utils/FPUtil/ManipulationFunctions.h"
+#include "utils/FPUtil/TestHelpers.h"
+#include "utils/UnitTest/Test.h"
+
+#include <limits.h>
+
+LIST_LDEXP_TESTS(float, __llvm_libc::ldexpf)

libc/test/src/math/ldexpl_test.cpp

+//===-- Unittests for ldexpl ----------------------------------------------===//
+//
+// 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 "LdExpTest.h"
+
+#include "include/math.h"
+#include "src/math/ldexpl.h"
+#include "utils/CPP/Functional.h"
+#include "utils/FPUtil/FPBits.h"
+#include "utils/FPUtil/ManipulationFunctions.h"
+#include "utils/FPUtil/TestHelpers.h"
+#include "utils/UnitTest/Test.h"
+
+#include <limits.h>
+
+LIST_LDEXP_TESTS(long double, __llvm_libc::ldexpl)

libc/utils/FPUtil/ManipulationFunctions.h

 //===-- Floating-point manipulation functions -------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_UTILS_FPUTIL_MANIPULATION_FUNCTIONS_H
 #define LLVM_LIBC_UTILS_FPUTIL_MANIPULATION_FUNCTIONS_H
 
 #include "FPBits.h"
 #include "NearestIntegerOperations.h"
 #include "NormalFloat.h"
 
 #include "include/math.h"
 #include "utils/CPP/TypeTraits.h"
 
 #include <limits.h>
 
 namespace __llvm_libc {
 namespace fputil {
 
 template <typename T,
if (bits.isZero()) {
     // Return positive infinity.
     return FPBits<T>::inf();
   }
 
   NormalFloat<T> normal(bits);
   return normal.exponent;
 }
 
+template <typename T,
+          cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
+static inline T ldexp(T x, int exp) {
+  FPBits<T> bits(x);
+  if (bits.isZero() || bits.isInfOrNaN() || exp == 0)
+    return x;
+
+  // NormalFloat uses int32_t to store the true exponent value. We should ensure
+  // that adding |exp| to it does not lead to integer rollover. But, we |exp|
+  // value is larger the exponent range for type T, then we can return infinity
+  // early.
+  if (exp > FPBits<T>::maxExponent)
+    return bits.sign ? FPBits<T>::negInf() : FPBits<T>::inf();
+
+  // Similarly on the negative side.
+  if (exp < -FPBits<T>::maxExponent)
+    return bits.sign ? FPBits<T>::negZero() : FPBits<T>::zero();
+
+  // For all other values, NormalFloat to T conversion handles it the right way.
+  NormalFloat<T> normal(bits);
+  normal.exponent += exp;
+  return normal;
+}
+
 } // namespace fputil
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_UTILS_FPUTIL_MANIPULATION_FUNCTIONS_H

libc/utils/FPUtil/NormalFloat.h

NormalFloat<T> mul2(int e) const {
     return result;
   }
 
   operator T() const {
     int biasedExponent = exponent + FPBits<T>::exponentBias;
     // Max exponent is of the form 0xFF...E. That is why -2 and not -1.
     constexpr int maxExponentValue = (1 << ExponentWidth<T>::value) - 2;
     if (biasedExponent > maxExponentValue) {
-      // TODO: Should infinity with the correct sign be returned?
-      return FPBits<T>::buildNaN(1);
+      return sign ? FPBits<T>::negInf() : FPBits<T>::inf();
     }
 
     FPBits<T> result(T(0.0));
+    result.sign = sign;
 
     constexpr int subnormalExponent = -FPBits<T>::exponentBias + 1;
     if (exponent < subnormalExponent) {
       unsigned shift = subnormalExponent - exponent;
-      if (shift <= MantissaWidth<T>::value) {
+      // Since exponent > subnormalExponent, shift is strictly greater than
+      // zero.
+      if (shift <= MantissaWidth<T>::value + 1) {
         // Generate a subnormal number. Might lead to loss of precision.
+        // We round to nearest and round halfway cases to even.
+        const UIntType shiftOutMask = (UIntType(1) << shift) - 1;
+        const UIntType shiftOutValue = mantissa & shiftOutMask;
+        const UIntType halfwayValue = UIntType(1) << (shift - 1);
         result.exponent = 0;
         result.mantissa = mantissa >> shift;
-        result.sign = sign;
+        UIntType newMantissa = result.mantissa;
+        if (shiftOutValue > halfwayValue) {
+          newMantissa += 1;
+        } else if (shiftOutValue == halfwayValue) {
+          // Round to even.
+          if (result.mantissa & 0x1)
+            newMantissa += 1;
+        }
+        result.mantissa = newMantissa;
+        // Adding 1 to mantissa can lead to overflow. This can only happen if
+        // mantissa was all ones (0b111..11). For such a case, we will carry
+        // the overflow into the exponent.
+        if (newMantissa == one)
+          result.exponent = 1;
         return result;
       } else {
-        // TODO: Should zero with the correct sign be returned?
-        return FPBits<T>::buildNaN(1);
+        return result;
       }
     }
 
     result.exponent = exponent + FPBits<T>::exponentBias;
     result.mantissa = mantissa;
-    result.sign = sign;
     return result;
   }
 
 private:
   void initFromBits(FPBits<T> bits) {
     sign = bits.sign;
 
     if (bits.isInfOrNaN() || bits.isZero()) {
inline void NormalFloat<long double>::initFromBits(FPBits<long double> bits) {
   }
 }
 
 template <> inline NormalFloat<long double>::operator long double() const {
   int biasedExponent = exponent + FPBits<long double>::exponentBias;
   // Max exponent is of the form 0xFF...E. That is why -2 and not -1.
   constexpr int maxExponentValue = (1 << ExponentWidth<long double>::value) - 2;
   if (biasedExponent > maxExponentValue) {
-    // TODO: Should infinity with the correct sign be returned?
-    return FPBits<long double>::buildNaN(1);
+    return sign ? FPBits<long double>::negInf() : FPBits<long double>::inf();
   }
 
   FPBits<long double> result(0.0l);
+  result.sign = sign;
 
   constexpr int subnormalExponent = -FPBits<long double>::exponentBias + 1;
   if (exponent < subnormalExponent) {
     unsigned shift = subnormalExponent - exponent;
-    if (shift <= MantissaWidth<long double>::value) {
+    if (shift <= MantissaWidth<long double>::value + 1) {
       // Generate a subnormal number. Might lead to loss of precision.
+      // We round to nearest and round halfway cases to even.
+      const UIntType shiftOutMask = (UIntType(1) << shift) - 1;
+      const UIntType shiftOutValue = mantissa & shiftOutMask;
+      const UIntType halfwayValue = UIntType(1) << (shift - 1);
       result.exponent = 0;
       result.mantissa = mantissa >> shift;
+      UIntType newMantissa = result.mantissa;
+      if (shiftOutValue > halfwayValue) {
+        newMantissa += 1;
+      } else if (shiftOutValue == halfwayValue) {
+        // Round to even.
+        if (result.mantissa & 0x1)
+          newMantissa += 1;
+      }
+      result.mantissa = newMantissa;
+      // Adding 1 to mantissa can lead to overflow. This can only happen if
+      // mantissa was all ones (0b111..11). For such a case, we will carry
+      // the overflow into the exponent and set the implicit bit to 1.
+      if (newMantissa == one) {
+        result.exponent = 1;
+        result.implicitBit = 1;
+      } else {
         result.implicitBit = 0;
-      result.sign = sign;
+      }
       return result;
     } else {
-      // TODO: Should zero with the correct sign be returned?
-      return FPBits<long double>::buildNaN(1);
+      return result;
     }
   }
 
   result.exponent = biasedExponent;
   result.mantissa = mantissa;
   result.implicitBit = 1;
-  result.sign = sign;
   return result;
 }
 #endif
 
 } // namespace fputil
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_UTILS_FPUTIL_NORMAL_FLOAT_H