[lldb] Reimplement half2float

[teemperor]

Summary

I had to debug LLDB's implementation of extend-half-to-float and while it's quite efficient
it also suffered from some UB (see rG4b074b49be206306330076b9fa40632ef1960823 )
and figuring out why we multiply with all those undocumented numbers isn't very fun.

This is a rewrite that is (hopefully) more readable and explains where all the numbers actually
come from. It's also less efficient, but as this is only used for dumping floating point numbers
from a target to a stringstream I don't think the few additional instructions do a lot of harm.

[teemperor]

FWIW, compiler-rt has a generic version of this function that I wish we could use instead. But I don't think we have any way to reuse compiler-rt functionality from within LLDB?

lldb/source/Core/DumpDataExtractor.cpp

 //===-- DumpDataExtractor.cpp ---------------------------------------------===//
 //
 // 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 "lldb/Core/DumpDataExtractor.h"
 
 #include "lldb/lldb-defines.h"
 #include "lldb/lldb-forward.h"
 
 #include "lldb/Core/Address.h"
 #include "lldb/Core/Disassembler.h"
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Target/ABI.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/ExecutionContextScope.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Stream.h"
 
 #include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/APInt.h"
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/bit.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallVector.h"
 
 #include <limits>
 #include <memory>
 #include <string>
 
 #include <assert.h>
 #include <ctype.h>
 #include <inttypes.h>
 #include <math.h>
 
 #include <bitset>
 #include <sstream>
 
 using namespace lldb_private;
 using namespace lldb;
 
 #define NON_PRINTABLE_CHAR '.'
 
-static float half2float(uint16_t half) {
-  union {
-    float f;
-    uint32_t u;
-  } u;
-  int32_t v = (int16_t)half;
-
-  if (0 == (v & 0x7c00)) {
-    u.u = v & 0x80007FFFU;
-    return u.f * ldexpf(1, 125);
-  }
-
-  v <<= 13;
-  u.u = v | 0x70000000U;
-  return u.f * ldexpf(1, -112);
+/// Takes two bytes of data, interprets it to a half precision float and then
+/// returns that value extend to a single precision float.
+static float half2float(uint16_t data) {
+  constexpr unsigned HalfBitsSignificant = 10;
+  // The exponent bias of half precision floats.
+  constexpr int HalfExpBias = 15;
+  struct IEEE754Half {
+    unsigned short significant : HalfBitsSignificant;
+    unsigned short exponent : 5;
+    unsigned short sign : 1;
+    bool IsSubnormal() const { return exponent == 0; }
+    bool isInfOrNaN() const { return exponent == 0b11111; }
+  };
+  const IEEE754Half half = llvm::bit_cast<IEEE754Half>(data);
+
+  constexpr unsigned SingleBitsSignificant = 23;
+  // The exponent bias of single precision floats.
+  constexpr int SingleExpBias = 127;
+  struct IEEE754Single {
+    unsigned significant : SingleBitsSignificant;
+    unsigned exponent : 8;
+    unsigned sign : 1;
+    float AsFloat() const { return llvm::bit_cast<float>(*this); }
+  };
+  IEEE754Single single;
+  single.significant = half.significant;
+  single.exponent = half.exponent;
+  single.sign = half.sign;
+
+  // Right align significant/NaN payload.
+  constexpr int SignificantBitDiff =
+      SingleBitsSignificant - HalfBitsSignificant;
+  single.significant <<= SignificantBitDiff;
+
+  // For subnormal numbers we have a fixed exponent and we already shifted the
+  // significant to the right position. Take the different to the new
+  // exponent and multiply with that to get the single precision value.
+  if (half.IsSubnormal())
+    return single.AsFloat() * ldexpf(1, SingleExpBias - HalfExpBias);
+
+  // If the input was Inf/Nan, there is nothing left to do than marking the
+  // output as Inf/Nan. Sign bit and payload are already correct.
+  if (half.isInfOrNaN()) {
+    // Fill the exponent with ones to mark it as NaN/Inf.
+    single.exponent = 0xFF;
+    return single.AsFloat();
+  }
+
+  // For normal numbers, only adjust the exponent. Significant was already
+  // shifted to the right position.
+  single.exponent += SingleExpBias - HalfExpBias;
+  return single.AsFloat();
 }
 
 static llvm::Optional<llvm::APInt> GetAPInt(const DataExtractor &data,
                                             lldb::offset_t *offset_ptr,
                                             lldb::offset_t byte_size) {
   if (byte_size == 0)
     return llvm::None;