[lldb/Utility] Simplify Scalar handling of float types

[labath]

Summary

Similarly to D85836, collapse all Scalar float types to a single enum
value, and use APFloat semantics to differentiate between. This
simplifies the code, and opens to door to supporting other floating
point semantics (which would be needed for fully supporting
architectures with more interesting float types such as PPC).

[JDevlieghere]

lldb/source/Utility/Scalar.cpp

68

std::array or ArrayRef maybe?

[labath]

lldb/source/Utility/Scalar.cpp

68

With a std::array, I'd have to explicitly specify the size, and I'm _really_ not sure what would happen with an ArrayRef (I think it would end up as a dangling pointer).

Given that it has just one usage, I don't think this is an issue. Even with multiple usages, I think it'd be fine to declare the variable this way, but that have an accessor which would wrap it in an ArrayRef for easier manipulation.

lldb/include/lldb/Utility/Scalar.h

 class Scalar {
 public:
   // FIXME: These are host types which seems to be an odd choice.
   enum Type {
     e_void = 0,
     e_sint,
     e_uint,
     e_float,
-    e_double,
-    e_long_double
   };
 
   // Constructors and Destructors
   Scalar() : m_type(e_void), m_float(0.0f) {}
   Scalar(int v)
       : m_type(e_sint), m_integer(sizeof(v) * 8, uint64_t(v), true),
         m_float(0.0f) {}
   Scalar(unsigned int v)
       : m_type(e_uint), m_integer(sizeof(v) * 8, uint64_t(v), false),
         m_float(0.0f) {}
   Scalar(long v)
       : m_type(e_sint), m_integer(sizeof(v) * 8, uint64_t(v), true),
         m_float(0.0f) {}
   Scalar(unsigned long v)
       : m_type(e_uint), m_integer(sizeof(v) * 8, uint64_t(v), false),
         m_float(0.0f) {}
   Scalar(long long v)
       : m_type(e_sint), m_integer(sizeof(v) * 8, uint64_t(v), true),
         m_float(0.0f) {}
   Scalar(unsigned long long v)
       : m_type(e_uint), m_integer(sizeof(v) * 8, uint64_t(v), false),
         m_float(0.0f) {}
   Scalar(float v) : m_type(e_float), m_float(v) {}
-  Scalar(double v) : m_type(e_double), m_float(v) {}
-  Scalar(long double v) : m_type(e_long_double), m_float(double(v)) {
+  Scalar(double v) : m_type(e_float), m_float(v) {}
+  Scalar(long double v) : m_type(e_float), m_float(double(v)) {
     bool ignore;
     m_float.convert(llvm::APFloat::x87DoubleExtended(),
                     llvm::APFloat::rmNearestTiesToEven, &ignore);
   }
   Scalar(llvm::APInt v)
       : m_type(GetBestTypeForBitSize(v.getBitWidth(), true)),
         m_integer(std::move(v)), m_float(0.0f) {}
 
void Clear() {
     m_type = e_void;
     m_integer.clearAllBits();
   }
 
   const char *GetTypeAsCString() const { return GetValueTypeAsCString(m_type); }
 
   void GetValue(Stream *s, bool show_type) const;
 
-  bool IsValid() const {
-    return (m_type >= e_sint) && (m_type <= e_long_double);
-  }
+  bool IsValid() const { return (m_type >= e_sint) && (m_type <= e_float); }
 
   /// Convert to an integer with \p bits and the given signedness.
   void TruncOrExtendTo(uint16_t bits, bool sign);
 
   bool IntegralPromote(uint16_t bits, bool sign);
-  bool FloatPromote(Scalar::Type type);
+  bool FloatPromote(const llvm::fltSemantics &semantics);
 
   bool MakeSigned();
 
   bool MakeUnsigned();
 
   static const char *GetValueTypeAsCString(Scalar::Type value_type);
 
   static Scalar::Type
   GetValueTypeForSignedIntegerWithByteSize(size_t byte_size);
 
   static Scalar::Type
   GetValueTypeForUnsignedIntegerWithByteSize(size_t byte_size);
 
-  static Scalar::Type GetValueTypeForFloatWithByteSize(size_t byte_size);
-
   // All operators can benefits from the implicit conversions that will happen
   // automagically by the compiler, so no temporary objects will need to be
   // created. As a result, we currently don't need a variety of overloaded set
   // value accessors.
   Scalar &operator+=(Scalar rhs);
   Scalar &operator<<=(const Scalar &rhs); // Shift left
   Scalar &operator>>=(const Scalar &rhs); // Shift right (arithmetic)
   Scalar &operator&=(const Scalar &rhs);
protected:
   Scalar::Type m_type;
   llvm::APInt m_integer;
   llvm::APFloat m_float;
 
   template <typename T> T GetAs(T fail_value) const;
 
   static Type PromoteToMaxType(Scalar &lhs, Scalar &rhs);
 
-  using IntPromotionKey = std::pair<unsigned, bool>;
-  IntPromotionKey GetIntKey() const;
+  enum class Category { Void, Integral, Float };
+  static Category GetCategory(Scalar::Type type);
+
+  using PromotionKey = std::tuple<Category, unsigned, bool>;
+  PromotionKey GetPromoKey() const;
+
+  static PromotionKey GetFloatPromoKey(const llvm::fltSemantics &semantics);
 
 private:
   friend const Scalar operator+(const Scalar &lhs, const Scalar &rhs);
   friend const Scalar operator-(Scalar lhs, Scalar rhs);
   friend const Scalar operator/(Scalar lhs, Scalar rhs);
   friend const Scalar operator*(Scalar lhs, Scalar rhs);
   friend const Scalar operator&(Scalar lhs, Scalar rhs);
   friend const Scalar operator|(Scalar lhs, Scalar rhs);

lldb/source/Utility/Scalar.cpp

 #include <cstdio>
 
 using namespace lldb;
 using namespace lldb_private;
 
 using llvm::APFloat;
 using llvm::APInt;
 
-namespace {
-enum class Category { Void, Integral, Float };
-}
-
-static Category GetCategory(Scalar::Type type) {
+Scalar::Category Scalar::GetCategory(Scalar::Type type) {
   switch (type) {
   case Scalar::e_void:
     return Category::Void;
   case Scalar::e_float:
-  case Scalar::e_double:
-  case Scalar::e_long_double:
     return Category::Float;
   case Scalar::e_sint:
   case Scalar::e_uint:
     return Category::Integral;
   }
   llvm_unreachable("Unhandled type!");
 }
 
 static bool IsSigned(Scalar::Type type) {
   switch (type) {
   case Scalar::e_void:
   case Scalar::e_uint:
     return false;
   case Scalar::e_sint:
   case Scalar::e_float:
-  case Scalar::e_double:
-  case Scalar::e_long_double:
     return true;
   }
   llvm_unreachable("Unhandled type!");
 }
 
-Scalar::IntPromotionKey Scalar::GetIntKey() const {
-  assert(GetCategory(GetType()) == Category::Integral);
-  return {m_integer.getBitWidth(), !IsSigned(m_type)};
+Scalar::PromotionKey Scalar::GetPromoKey() const {
+  Category cat = GetCategory(m_type);
+  switch (cat) {
+  case Category::Void:
+    return {cat, 0, false};
+  case Category::Integral:
+    return {cat, m_integer.getBitWidth(), !IsSigned(m_type)};
+  case Category::Float:
+    return GetFloatPromoKey(m_float.getSemantics());
+  }
+  llvm_unreachable("Unhandled category!");
+}
+
+Scalar::PromotionKey Scalar::GetFloatPromoKey(const llvm::fltSemantics &sem) {
+  static const llvm::fltSemantics *const order[] = {
+      &APFloat::IEEEsingle(), &APFloat::IEEEdouble(),
+      &APFloat::x87DoubleExtended()};
+  for (const auto &entry : llvm::enumerate(order)) {
+    if (entry.value() == &sem)
+      return {Category::Float, entry.index(), false};
+  }
+  llvm_unreachable("Unsupported semantics!");
 }
 
 // Promote to max type currently follows the ANSI C rule for type promotion in
 // expressions.
 Scalar::Type Scalar::PromoteToMaxType(Scalar &lhs, Scalar &rhs) {
   const auto &Promote = [](Scalar &a, const Scalar &b) {
-    if (GetCategory(b.GetType()) == Category::Integral)
+    switch (GetCategory(b.GetType())) {
+    case Category::Void:
+      break;
+    case Category::Integral:
       a.IntegralPromote(b.UInt128(APInt()).getBitWidth(),
                         IsSigned(b.GetType()));
-    else
-      a.FloatPromote(b.GetType());
+      break;
+    case Category::Float:
+      a.FloatPromote(b.m_float.getSemantics());
+    }
   };
 
-  // Extract the types of both the right and left hand side values
-  Scalar::Type lhs_type = lhs.GetType();
-  Scalar::Type rhs_type = rhs.GetType();
-
-  if (GetCategory(lhs_type) == Category::Integral &&
-      GetCategory(rhs_type) == Category::Integral) {
-    IntPromotionKey lhs_key = lhs.GetIntKey();
-    IntPromotionKey rhs_key = rhs.GetIntKey();
-    if (lhs_key > rhs_key)
-      Promote(rhs, lhs);
-    else if (rhs_key > lhs_key)
-      Promote(lhs, rhs);
-  } else if (lhs_type > rhs_type)
-    Promote(rhs, lhs);
-  else if (lhs_type < rhs_type)
-    Promote(lhs, rhs);
+  PromotionKey lhs_key = lhs.GetPromoKey();
+  PromotionKey rhs_key = rhs.GetPromoKey();
+
 
   // Make sure our type promotion worked as expected
-  if (lhs.GetType() == rhs.GetType())
-    return lhs.GetType(); // Return the resulting max type
+  if (lhs.GetPromoKey() == rhs.GetPromoKey())
+    return lhs.GetType(); // Return the resulting type
 
   // Return the void type (zero) if we fail to promote either of the values.
   return Scalar::e_void;
 }
 
 bool Scalar::GetData(DataExtractor &data, size_t limit_byte_size) const {
   size_t byte_size = GetByteSize();
   if (byte_size == 0) {

 size_t Scalar::GetByteSize() const {
   switch (m_type) {
   case e_void:
     break;
   case e_sint:
   case e_uint:
     return (m_integer.getBitWidth() / 8);
   case e_float:
-    return sizeof(float_t);
-  case e_double:
-    return sizeof(double_t);
-  case e_long_double:
-    return sizeof(long_double_t);
+    return m_float.bitcastToAPInt().getBitWidth() / 8;
   }
   return 0;
 }
 
 bool Scalar::IsZero() const {
   switch (GetCategory(m_type)) {
   case Category::Void:
     break;
Scalar::Type Scalar::GetBestTypeForBitSize(size_t bit_size, bool sign) {
   return sign ? e_sint : e_uint;
 }
 
 void Scalar::TruncOrExtendTo(uint16_t bits, bool sign) {
   m_integer = sign ? m_integer.sextOrTrunc(bits) : m_integer.zextOrTrunc(bits);
   m_type = GetBestTypeForBitSize(bits, sign);
 }
 
-static const llvm::fltSemantics &GetFltSemantics(Scalar::Type type) {
-  switch (type) {
-  case Scalar::e_void:
-  case Scalar::e_sint:
-  case Scalar::e_uint:
-    llvm_unreachable("Only floating point types supported!");
-  case Scalar::e_float:
-    return llvm::APFloat::IEEEsingle();
-  case Scalar::e_double:
-    return llvm::APFloat::IEEEdouble();
-  case Scalar::e_long_double:
-    return llvm::APFloat::x87DoubleExtended();
-  }
-  llvm_unreachable("Unhandled type!");
-}
-
 bool Scalar::IntegralPromote(uint16_t bits, bool sign) {
   switch (GetCategory(m_type)) {
   case Category::Void:
   case Category::Float:
     break;
   case Category::Integral:
-    if (GetIntKey() > IntPromotionKey(bits, !sign))
+    if (GetPromoKey() > PromotionKey(Category::Integral, bits, !sign))
       break;
     if (IsSigned(m_type))
       m_integer = m_integer.sextOrTrunc(bits);
     else
       m_integer = m_integer.zextOrTrunc(bits);
     m_type = sign ? e_sint : e_uint;
     return true;
   }
   return false;
 }
 
-bool Scalar::FloatPromote(Scalar::Type type) {
-  assert(GetCategory(type) == Category::Float);
+bool Scalar::FloatPromote(const llvm::fltSemantics &semantics) {
   bool success = false;
   switch (GetCategory(m_type)) {
   case Category::Void:
     break;
   case Category::Integral:
-    m_float = llvm::APFloat(GetFltSemantics(type));
+    m_float = llvm::APFloat(semantics);
     m_float.convertFromAPInt(m_integer, IsSigned(m_type),
                              llvm::APFloat::rmNearestTiesToEven);
     success = true;
     break;
   case Category::Float:
-    if (type < m_type)
+    if (GetFloatPromoKey(semantics) < GetFloatPromoKey(m_float.getSemantics()))
       break;
     bool ignore;
     success = true;
-    m_float.convert(GetFltSemantics(type), llvm::APFloat::rmNearestTiesToEven,
-                    &ignore);
+    m_float.convert(semantics, llvm::APFloat::rmNearestTiesToEven, &ignore);
   }
 
   if (success)
-    m_type = type;
+    m_type = e_float;
   return success;
 }
 
 const char *Scalar::GetValueTypeAsCString(Scalar::Type type) {
   switch (type) {
   case e_void:
     return "void";
   case e_sint:
     return "signed int";
   case e_uint:
     return "unsigned int";
   case e_float:
     return "float";
-  case e_double:
-    return "double";
-  case e_long_double:
-    return "long double";
   }
   return "???";
 }
 
 Scalar::Type
 Scalar::GetValueTypeForSignedIntegerWithByteSize(size_t byte_size) {
   return e_sint;
 }
 
 Scalar::Type
 Scalar::GetValueTypeForUnsignedIntegerWithByteSize(size_t byte_size) {
   return e_uint;
 }
 
-Scalar::Type Scalar::GetValueTypeForFloatWithByteSize(size_t byte_size) {
-  if (byte_size == sizeof(float_t))
-    return e_float;
-  if (byte_size == sizeof(double_t))
-    return e_double;
-  if (byte_size == sizeof(long_double_t))
-    return e_long_double;
-  return e_void;
-}
-
 bool Scalar::MakeSigned() {
   bool success = false;
 
   switch (m_type) {
   case e_void:
     break;
   case e_sint:
     success = true;
     break;
   case e_uint:
     m_type = e_sint;
     success = true;
     break;
   case e_float:
     success = true;
     break;
-  case e_double:
-    success = true;
-    break;
-  case e_long_double:
-    success = true;
-    break;
   }
 
   return success;
 }
 
 bool Scalar::MakeUnsigned() {
   bool success = false;
 
   switch (m_type) {
   case e_void:
     break;
   case e_sint:
     m_type = e_uint;
     success = true;
     break;
   case e_uint:
     success = true;
     break;
   case e_float:
     success = true;
     break;
-  case e_double:
-    success = true;
-    break;
-  case e_long_double:
-    success = true;
-    break;
   }
 
   return success;
 }
 
 static llvm::APInt ToAPInt(const llvm::APFloat &f, unsigned bits,
                            bool is_unsigned) {
   llvm::APSInt result(bits, is_unsigned);
bool Scalar::ShiftRightLogical(const Scalar &rhs) {
   m_type = e_void;
   return false;
 }
 
 Scalar &Scalar::operator>>=(const Scalar &rhs) {
   switch (m_type) {
   case e_void:
   case e_float:
-  case e_double:
-  case e_long_double:
     m_type = e_void;
     break;
 
   case e_sint:
   case e_uint:
     switch (rhs.m_type) {
     case e_void:
     case e_float:
-    case e_double:
-    case e_long_double:
       m_type = e_void;
       break;
     case e_sint:
     case e_uint:
       m_integer = m_integer.ashr(rhs.m_integer);
       break;
     }
     break;
bool Scalar::AbsoluteValue() {
   case e_sint:
     if (m_integer.isNegative())
       m_integer = -m_integer;
     return true;
 
   case e_uint:
     return true;
   case e_float:
-  case e_double:
-  case e_long_double:
     m_float.clearSign();
     return true;
   }
   return false;
 }
 
 bool Scalar::UnaryNegate() {
   switch (GetCategory(m_type)) {
const Scalar lldb_private::operator+(const Scalar &lhs, const Scalar &rhs) {
   Scalar result = lhs;
   result += rhs;
   return result;
 }
 
 const Scalar lldb_private::operator-(Scalar lhs, Scalar rhs) {
   Scalar result;
   if ((result.m_type = Scalar::PromoteToMaxType(lhs, rhs)) != Scalar::e_void) {
-    switch (GetCategory(result.m_type)) {
-    case Category::Void:
+    switch (Scalar::GetCategory(result.m_type)) {
+    case Scalar::Category::Void:
       break;
-    case Category::Integral:
+    case Scalar::Category::Integral:
       result.m_integer = lhs.m_integer - rhs.m_integer;
       break;
-    case Category::Float:
+    case Scalar::Category::Float:
       result.m_float = lhs.m_float - rhs.m_float;
       break;
     }
   }
   return result;
 }
 
 const Scalar lldb_private::operator/(Scalar lhs, Scalar rhs) {
   Scalar result;
   if ((result.m_type = Scalar::PromoteToMaxType(lhs, rhs)) != Scalar::e_void &&
       !rhs.IsZero()) {
-    switch (GetCategory(result.m_type)) {
-    case Category::Void:
+    switch (Scalar::GetCategory(result.m_type)) {
+    case Scalar::Category::Void:
       break;
-    case Category::Integral:
+    case Scalar::Category::Integral:
       if (IsSigned(result.m_type))
         result.m_integer = lhs.m_integer.sdiv(rhs.m_integer);
       else
         result.m_integer = lhs.m_integer.udiv(rhs.m_integer);
       return result;
-    case Category::Float:
+    case Scalar::Category::Float:
       result.m_float = lhs.m_float / rhs.m_float;
       return result;
     }
   }
   // For division only, the only way it should make it here is if a promotion
   // failed, or if we are trying to do a divide by zero.
   result.m_type = Scalar::e_void;
   return result;
 }
 
 const Scalar lldb_private::operator*(Scalar lhs, Scalar rhs) {
   Scalar result;
   if ((result.m_type = Scalar::PromoteToMaxType(lhs, rhs)) != Scalar::e_void) {
-    switch (GetCategory(result.m_type)) {
-    case Category::Void:
+    switch (Scalar::GetCategory(result.m_type)) {
+    case Scalar::Category::Void:
       break;
-    case Category::Integral:
+    case Scalar::Category::Integral:
       result.m_integer = lhs.m_integer * rhs.m_integer;
       break;
-    case Category::Float:
+    case Scalar::Category::Float:
       result.m_float = lhs.m_float * rhs.m_float;
       break;
     }
   }
   return result;
 }
 
 const Scalar lldb_private::operator&(Scalar lhs, Scalar rhs) {
   Scalar result;
   if ((result.m_type = Scalar::PromoteToMaxType(lhs, rhs)) != Scalar::e_void) {
-    if (GetCategory(result.m_type) == Category::Integral)
+    if (Scalar::GetCategory(result.m_type) == Scalar::Category::Integral)
       result.m_integer = lhs.m_integer & rhs.m_integer;
     else
       result.m_type = Scalar::e_void;
   }
   return result;
 }
 
 const Scalar lldb_private::operator|(Scalar lhs, Scalar rhs) {
   Scalar result;
   if ((result.m_type = Scalar::PromoteToMaxType(lhs, rhs)) != Scalar::e_void) {
-    if (GetCategory(result.m_type) == Category::Integral)
+    if (Scalar::GetCategory(result.m_type) == Scalar::Category::Integral)
       result.m_integer = lhs.m_integer | rhs.m_integer;
     else
       result.m_type = Scalar::e_void;
   }
   return result;
 }
 
 const Scalar lldb_private::operator%(Scalar lhs, Scalar rhs) {
   Scalar result;
   if ((result.m_type = Scalar::PromoteToMaxType(lhs, rhs)) != Scalar::e_void) {
-    if (!rhs.IsZero() && GetCategory(result.m_type) == Category::Integral) {
+    if (!rhs.IsZero() &&
+        Scalar::GetCategory(result.m_type) == Scalar::Category::Integral) {
       if (IsSigned(result.m_type))
         result.m_integer = lhs.m_integer.srem(rhs.m_integer);
       else
         result.m_integer = lhs.m_integer.urem(rhs.m_integer);
       return result;
     }
   }
   result.m_type = Scalar::e_void;
   return result;
 }
 
 const Scalar lldb_private::operator^(Scalar lhs, Scalar rhs) {
   Scalar result;
   if ((result.m_type = Scalar::PromoteToMaxType(lhs, rhs)) != Scalar::e_void) {
-    if (GetCategory(result.m_type) == Category::Integral)
+    if (Scalar::GetCategory(result.m_type) == Scalar::Category::Integral)
       result.m_integer = lhs.m_integer ^ rhs.m_integer;
     else
       result.m_type = Scalar::e_void;
   }
   return result;
 }
 
 const Scalar lldb_private::operator<<(const Scalar &lhs, const Scalar &rhs) {
case eEncodingUint: {
     } else {
       m_type = e_uint;
       m_integer = integer.zextOrTrunc(8 * byte_size);
     }
     break;
   }
 
   case eEncodingIEEE754: {
-    Type type = GetValueTypeForFloatWithByteSize(byte_size);
-    if (type == e_void) {
-      error.SetErrorStringWithFormatv("unsupported float byte size: {0}",
-                                      byte_size);
-      break;
-    }
-    APFloat f(GetFltSemantics(type));
+    // FIXME: It's not possible to unambiguously map a byte size to a floating
+    // point type. This function should be refactored to take an explicit
+    // semantics argument.
+    const llvm::fltSemantics &sem =
+        byte_size <= 4 ? APFloat::IEEEsingle()
+                       : byte_size <= 8 ? APFloat::IEEEdouble()
+                                        : APFloat::x87DoubleExtended();
+    APFloat f(sem);
     if (llvm::Expected<APFloat::opStatus> op =
             f.convertFromString(value_str, APFloat::rmNearestTiesToEven)) {
-      m_type = type;
+      m_type = e_float;
       m_float = std::move(f);
     } else
       error = op.takeError();
     break;
   }
 
   case eEncodingVector:
     error.SetErrorString("vector encoding unsupported.");

 
 bool Scalar::SignExtend(uint32_t sign_bit_pos) {
   const uint32_t max_bit_pos = GetByteSize() * 8;
 
   if (sign_bit_pos < max_bit_pos) {
     switch (m_type) {
     case Scalar::e_void:
     case Scalar::e_float:
-    case Scalar::e_double:
-    case Scalar::e_long_double:
       return false;
 
     case Scalar::e_sint:
     case Scalar::e_uint:
       if (max_bit_pos == sign_bit_pos)
         return true;
       else if (sign_bit_pos < (max_bit_pos - 1)) {
         llvm::APInt sign_bit = llvm::APInt::getSignMask(sign_bit_pos + 1);

 
 bool Scalar::ExtractBitfield(uint32_t bit_size, uint32_t bit_offset) {
   if (bit_size == 0)
     return true;
 
   switch (m_type) {
   case Scalar::e_void:
   case Scalar::e_float:
-  case Scalar::e_double:
-  case Scalar::e_long_double:
     break;
 
   case Scalar::e_sint:
     m_integer = m_integer.ashr(bit_offset)
                     .sextOrTrunc(bit_size)
                     .sextOrSelf(8 * GetByteSize());
     return true;
 
bool lldb_private::operator==(Scalar lhs, Scalar rhs) {
   llvm::APFloat::cmpResult result;
   switch (Scalar::PromoteToMaxType(lhs, rhs)) {
   case Scalar::e_void:
     break;
   case Scalar::e_sint:
   case Scalar::e_uint:
     return lhs.m_integer == rhs.m_integer;
   case Scalar::e_float:
-  case Scalar::e_double:
-  case Scalar::e_long_double:
     result = lhs.m_float.compare(rhs.m_float);
     if (result == llvm::APFloat::cmpEqual)
       return true;
   }
   return false;
 }
 
 bool lldb_private::operator!=(const Scalar &lhs, const Scalar &rhs) {
   return !(lhs == rhs);
 }
 
 bool lldb_private::operator<(Scalar lhs, Scalar rhs) {
   if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
     return false;
 
   llvm::APFloat::cmpResult result;
   switch (Scalar::PromoteToMaxType(lhs, rhs)) {
   case Scalar::e_void:
     break;
   case Scalar::e_sint:
     return lhs.m_integer.slt(rhs.m_integer);
   case Scalar::e_uint:
     return lhs.m_integer.ult(rhs.m_integer);
   case Scalar::e_float:
-  case Scalar::e_double:
-  case Scalar::e_long_double:
     result = lhs.m_float.compare(rhs.m_float);
     if (result == llvm::APFloat::cmpLessThan)
       return true;
   }
   return false;
 }
 
 bool lldb_private::operator<=(const Scalar &lhs, const Scalar &rhs) {
bool Scalar::ClearBit(uint32_t bit) {
   switch (m_type) {
   case e_void:
     break;
   case e_sint:
   case e_uint:
     m_integer.clearBit(bit);
     return true;
   case e_float:
-  case e_double:
-  case e_long_double:
     break;
   }
   return false;
 }
 
 bool Scalar::SetBit(uint32_t bit) {
   switch (m_type) {
   case e_void:
     break;
   case e_sint:
   case e_uint:
     m_integer.setBit(bit);
     return true;
   case e_float:
-  case e_double:
-  case e_long_double:
     break;
   }
   return false;
 }
 
 llvm::raw_ostream &lldb_private::operator<<(llvm::raw_ostream &os, const Scalar &scalar) {
   StreamString s;
   scalar.GetValue(&s, /*show_type*/ true);
   return os << s.GetString();
 }

lldb/unittests/Utility/ScalarTest.cpp

 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/Scalar.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.h"
 #include "llvm/Testing/Support/Error.h"
 
 using namespace lldb_private;
+using llvm::APFloat;
 using llvm::APInt;
 using llvm::Failed;
 using llvm::Succeeded;
 
 template <typename T>
 bool checkInequality(T c1, T c2) {
   return (Scalar(c1) != Scalar(c2));
 }
TEST(ScalarTest, Promotion) {
   EXPECT_EQ(Scalar::e_sint, a.GetType());
 
   EXPECT_TRUE(a.IntegralPromote(64, false));
   EXPECT_EQ(Scalar::e_uint, a.GetType());
   EXPECT_EQ(APInt(64, 47), a.UInt128(APInt()));
 
   EXPECT_FALSE(a.IntegralPromote(64, true));
 
-  EXPECT_TRUE(a.FloatPromote(Scalar::e_double));
-  EXPECT_EQ(Scalar::e_double, a.GetType());
+  EXPECT_TRUE(a.FloatPromote(APFloat::IEEEdouble()));
+  EXPECT_EQ(Scalar::e_float, a.GetType());
   EXPECT_EQ(47.0, a.Double());
 
-  EXPECT_FALSE(a.FloatPromote(Scalar::e_float));
-  EXPECT_TRUE(a.FloatPromote(Scalar::e_long_double));
+  EXPECT_FALSE(a.FloatPromote(APFloat::IEEEsingle()));
+  EXPECT_TRUE(a.FloatPromote(APFloat::x87DoubleExtended()));
   EXPECT_EQ(47.0L, a.LongDouble());
 }
 
 TEST(ScalarTest, SetValueFromCString) {
   Scalar a;
 
   EXPECT_THAT_ERROR(
       a.SetValueFromCString("1234567890123", lldb::eEncodingUint, 8).ToError(),