[lldb/Utility] Simplify and generalize Scalar class

[labath]

Summary

The class contains an enum listing all host integer types as well as
some non-host types. This setup is a remnant of a time when this class
was actually implemented in terms of host integer types. Now that we are
using llvm::APInt, they are mostly useless and mean that each function
needs to enumerate all of these cases even though it treats most of them
identically.

I only leave e_sint and e_uint to denote the integer signedness, but I
want to remove that in a follow-up as well.

Removing these cases simplifies most of these functions, with the only
exception being PromoteToMaxType, which can no longer rely on a simple
enum comparison to determine what needs to be promoted.

This also makes the class ready to work with arbitrary integer sizes, so
it does not need to be modified when someone needs to add a larger
integer size.

[JDevlieghere]

lldb/include/lldb/Utility/Scalar.h

258

I really hate this signature. How do you feel about having this return a struct with the Type, the temp Scalar and the two references? That doesn't have to be part of this patch though.

[labath]

lldb/include/lldb/Utility/Scalar.h

258

Yeah, that has been bothering me too, but I haven't gotten around to it yet. If I understand what you mean, then the struct solution will not work correctly (without some extra goo) because the address of the temp Scalar will change while it is being returned, invalidating the pointers.

How about something like D85906, which just deals away with all the pointer business?

[JDevlieghere]

I guess you'll have to rebase this, but LGTM

lldb/include/lldb/Utility/Scalar.h

258

I think with guaranteed copy elision in C++14 it should've been fine, but I agree that it's a bit fragile. I like D85906!

lldb/include/lldb/Utility/Scalar.h

 //===-- Scalar.h ------------------------------------------------*- 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 LLDB_UTILITY_SCALAR_H
 #define LLDB_UTILITY_SCALAR_H
 
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/lldb-enumerations.h"
 #include "lldb/lldb-private-types.h"
 #include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/APInt.h"
 #include <cstddef>
 #include <cstdint>
 #include <utility>

 // follows the ANSI C type promotion rules.
 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_slong,
-    e_ulong,
-    e_slonglong,
-    e_ulonglong,
-    e_sint128,
-    e_uint128,
-    e_sint256,
-    e_uint256,
-    e_sint512,
-    e_uint512,
     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_slong), m_integer(sizeof(v) * 8, uint64_t(v), true),
+      : m_type(e_sint), m_integer(sizeof(v) * 8, uint64_t(v), true),
         m_float(0.0f) {}
   Scalar(unsigned long v)
-      : m_type(e_ulong), m_integer(sizeof(v) * 8, uint64_t(v), false),
+      : m_type(e_uint), m_integer(sizeof(v) * 8, uint64_t(v), false),
         m_float(0.0f) {}
   Scalar(long long v)
-      : m_type(e_slonglong), m_integer(sizeof(v) * 8, uint64_t(v), true),
+      : 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_ulonglong), m_integer(sizeof(v) * 8, uint64_t(v), false),
+      : 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)) {
     bool ignore;
     m_float.convert(llvm::APFloat::x87DoubleExtended(),
                     llvm::APFloat::rmNearestTiesToEven, &ignore);
   }
public:
 
   bool IsValid() const {
     return (m_type >= e_sint) && (m_type <= e_long_double);
   }
 
   /// Convert to an integer with \p bits and the given signedness.
   void TruncOrExtendTo(uint16_t bits, bool sign);
 
-  bool Promote(Scalar::Type type);
+  bool IntegralPromote(uint16_t bits, bool sign);
+  bool FloatPromote(Scalar::Type type);
 
   bool MakeSigned();
 
   bool MakeUnsigned();
 
   static const char *GetValueTypeAsCString(Scalar::Type value_type);
 
   static Scalar::Type
protected:
 
   // Classes that inherit from Scalar can see and modify these
   Scalar::Type m_type;
   llvm::APInt m_integer;
   llvm::APFloat m_float;
 
   template <typename T> T GetAs(T fail_value) const;
 
+  static Type PromoteToMaxType(const Scalar &lhs, const Scalar &rhs,
+                               Scalar &temp_value,
+                               const Scalar *&promoted_lhs_ptr,
+                               const Scalar *&promoted_rhs_ptr);
+
+  using IntPromotionKey = std::pair<unsigned, bool>;
+  IntPromotionKey GetIntKey() const;
+
 private:
   friend const Scalar operator+(const Scalar &lhs, const Scalar &rhs);
   friend const Scalar operator-(const Scalar &lhs, const Scalar &rhs);
   friend const Scalar operator/(const Scalar &lhs, const Scalar &rhs);
   friend const Scalar operator*(const Scalar &lhs, const Scalar &rhs);
   friend const Scalar operator&(const Scalar &lhs, const Scalar &rhs);
   friend const Scalar operator|(const Scalar &lhs, const Scalar &rhs);
   friend const Scalar operator%(const Scalar &lhs, const Scalar &rhs);

lldb/source/Utility/Scalar.cpp

 //===-- Scalar.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/Utility/Scalar.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/lldb-types.h"
 #include "llvm/ADT/APSInt.h"
static Category 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_slong:
-  case Scalar::e_slonglong:
-  case Scalar::e_sint128:
-  case Scalar::e_sint256:
-  case Scalar::e_sint512:
   case Scalar::e_uint:
-  case Scalar::e_ulong:
-  case Scalar::e_ulonglong:
-  case Scalar::e_uint128:
-  case Scalar::e_uint256:
-  case Scalar::e_uint512:
     return Category::Integral;
   }
   llvm_unreachable("Unhandled type!");
 }
 
 static bool IsSigned(Scalar::Type type) {
   switch (type) {
   case Scalar::e_void:
   case Scalar::e_uint:
-  case Scalar::e_ulong:
-  case Scalar::e_ulonglong:
-  case Scalar::e_uint128:
-  case Scalar::e_uint256:
-  case Scalar::e_uint512:
     return false;
   case Scalar::e_sint:
-  case Scalar::e_slong:
-  case Scalar::e_slonglong:
-  case Scalar::e_sint128:
-  case Scalar::e_sint256:
-  case Scalar::e_sint512:
   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)};
+}
 
 // Promote to max type currently follows the ANSI C rule for type promotion in
 // expressions.
-static Scalar::Type PromoteToMaxType(
+Scalar::Type Scalar::PromoteToMaxType(
     const Scalar &lhs,  // The const left hand side object
     const Scalar &rhs,  // The const right hand side object
     Scalar &temp_value, // A modifiable temp value than can be used to hold
                         // either the promoted lhs or rhs object
     const Scalar *&promoted_lhs_ptr, // Pointer to the resulting possibly
                                      // promoted value of lhs (at most one of
                                      // lhs/rhs will get promoted)
     const Scalar *&promoted_rhs_ptr  // Pointer to the resulting possibly
                                      // promoted value of rhs (at most one of
                                      // lhs/rhs will get promoted)
 ) {
+  const auto &Promote = [&temp_value](const Scalar &a, const Scalar &b,
+                                      const Scalar *&ptr) {
+    temp_value = a;
+    bool result =
+        GetCategory(b.GetType()) == Category::Integral
+            ? temp_value.IntegralPromote(b.UInt128(APInt()).getBitWidth(),
+                                         IsSigned(b.GetType()))
+            : temp_value.FloatPromote(b.GetType());
+    if (result)
+      ptr = &temp_value;
+  };
   Scalar result;
   // Initialize the promoted values for both the right and left hand side
   // values to be the objects themselves. If no promotion is needed (both right
   // and left have the same type), then the temp_value will not get used.
   promoted_lhs_ptr = &lhs;
   promoted_rhs_ptr = &rhs;
   // 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 (lhs_type > rhs_type) {
-    // Right hand side need to be promoted
-    temp_value = rhs; // Copy right hand side into the temp value
-    if (temp_value.Promote(lhs_type)) // Promote it
-      promoted_rhs_ptr =
-          &temp_value; // Update the pointer for the promoted right hand side
-  } else if (lhs_type < rhs_type) {
-    // Left hand side need to be promoted
-    temp_value = lhs; // Copy left hand side value into the temp value
-    if (temp_value.Promote(rhs_type)) // Promote it
-      promoted_lhs_ptr =
-          &temp_value; // Update the pointer for the promoted left hand side
-  }
+  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, promoted_rhs_ptr);
+    else if (rhs_key > lhs_key)
+      Promote(lhs, rhs, promoted_lhs_ptr);
+  } else if (lhs_type > rhs_type)
+    Promote(rhs, lhs, promoted_rhs_ptr);
+  else if (lhs_type < rhs_type)
+    Promote(lhs, rhs, promoted_lhs_ptr);
 
   // Make sure our type promotion worked as expected
   if (promoted_lhs_ptr->GetType() == promoted_rhs_ptr->GetType())
     return promoted_lhs_ptr->GetType(); // Return the resulting max type
 
   // Return the void type (zero) if we fail to promote either of the values.
   return Scalar::e_void;
 }

 }
 
 size_t Scalar::GetByteSize() const {
   switch (m_type) {
   case e_void:
     break;
   case e_sint:
   case e_uint:
-  case e_slong:
-  case e_ulong:
-  case e_slonglong:
-  case e_ulonglong:
-  case e_sint128:
-  case e_uint128:
-  case e_sint256:
-  case e_uint256:
-  case e_sint512:
-  case e_uint512:
     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);
   }
case Category::Float:
     llvm::SmallString<24> string;
     m_float.toString(string);
     s->PutCString(string);
     break;
   }
 }
 
 Scalar::Type Scalar::GetBestTypeForBitSize(size_t bit_size, bool sign) {
-  // Scalar types are always host types, hence the sizeof().
-  if (sign) {
-    if (bit_size <= sizeof(int)*8) return Scalar::e_sint;
-    if (bit_size <= sizeof(long)*8) return Scalar::e_slong;
-    if (bit_size <= sizeof(long long)*8) return Scalar::e_slonglong;
-    if (bit_size <= 128) return Scalar::e_sint128;
-    if (bit_size <= 256) return Scalar::e_sint256;
-    if (bit_size <= 512) return Scalar::e_sint512;
-  } else {
-    if (bit_size <= sizeof(unsigned int)*8) return Scalar::e_uint;
-    if (bit_size <= sizeof(unsigned long)*8) return Scalar::e_ulong;
-    if (bit_size <= sizeof(unsigned long long)*8) return Scalar::e_ulonglong;
-    if (bit_size <= 128) return Scalar::e_uint128;
-    if (bit_size <= 256) return Scalar::e_uint256;
-    if (bit_size <= 512) return Scalar::e_uint512;
-  }
-  return Scalar::e_void;
+  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 size_t GetBitSize(Scalar::Type type) {
-  switch (type) {
-  case Scalar::e_void:
-    return 0;
-  case Scalar::e_sint:
-    return 8 * sizeof(int);
-  case Scalar::e_uint:
-    return 8 * sizeof(unsigned int);
-  case Scalar::e_slong:
-    return 8 * sizeof(long);
-  case Scalar::e_ulong:
-    return 8 * sizeof(unsigned long);
-  case Scalar::e_slonglong:
-    return 8 * sizeof(long long);
-  case Scalar::e_ulonglong:
-    return 8 * sizeof(unsigned long long);
-  case Scalar::e_sint128:
-  case Scalar::e_uint128:
-    return BITWIDTH_INT128;
-  case Scalar::e_sint256:
-  case Scalar::e_uint256:
-    return BITWIDTH_INT256;
-  case Scalar::e_sint512:
-  case Scalar::e_uint512:
-    return BITWIDTH_INT512;
-  case Scalar::e_float:
-    return 8 * sizeof(float);
-  case Scalar::e_double:
-    return 8 * sizeof(double);
-  case Scalar::e_long_double:
-    return 8 * sizeof(long double);
-  }
-  llvm_unreachable("Unhandled type!");
-}
-
 static const llvm::fltSemantics &GetFltSemantics(Scalar::Type type) {
   switch (type) {
   case Scalar::e_void:
   case Scalar::e_sint:
-  case Scalar::e_slong:
-  case Scalar::e_slonglong:
-  case Scalar::e_sint128:
-  case Scalar::e_sint256:
-  case Scalar::e_sint512:
   case Scalar::e_uint:
-  case Scalar::e_ulong:
-  case Scalar::e_ulonglong:
-  case Scalar::e_uint128:
-  case Scalar::e_uint256:
-  case Scalar::e_uint512:
     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::Promote(Scalar::Type type) {
-  bool success = false;
+bool Scalar::IntegralPromote(uint16_t bits, bool sign) {
   switch (GetCategory(m_type)) {
   case Category::Void:
+  case Category::Float:
     break;
   case Category::Integral:
-    switch (GetCategory(type)) {
-    case Category::Void:
-      break;
-    case Category::Integral:
-      if (type < m_type)
-        break;
-      success = true;
-      if (IsSigned(m_type))
-        m_integer = m_integer.sextOrTrunc(GetBitSize(type));
-      else
-        m_integer = m_integer.zextOrTrunc(GetBitSize(type));
-      break;
-    case Category::Float:
-      m_float = llvm::APFloat(GetFltSemantics(type));
-      m_float.convertFromAPInt(m_integer, IsSigned(m_type),
-                               llvm::APFloat::rmNearestTiesToEven);
-      success = true;
-      break;
-    }
-    break;
-  case Category::Float:
-    switch (GetCategory(type)) {
-    case Category::Void:
-    case Category::Integral:
-      break;
-    case Category::Float:
-      if (type < m_type)
-        break;
-      bool ignore;
-      success = true;
-      m_float.convert(GetFltSemantics(type), llvm::APFloat::rmNearestTiesToEven,
-                      &ignore);
-    }
-  }
+    if (GetIntKey() > IntPromotionKey(bits, !sign))
+      m_integer = m_integer.sextOrTrunc(bits);
+      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 success = false;
+  switch (GetCategory(m_type)) {
+  case Category::Void:
+  case Category::Integral:
 
   if (success)
     m_type = type;
   return success;
 }
 
 const char *Scalar::GetValueTypeAsCString(Scalar::Type type) {
   switch (type) {
   case e_void:
     return "void";
   case e_sint:
-    return "int";
+    return "signed int";
   case e_uint:
     return "unsigned int";
-  case e_slong:
-    return "long";
-  case e_ulong:
-    return "unsigned long";
-  case e_slonglong:
-    return "long long";
-  case e_ulonglong:
-    return "unsigned long long";
   case e_float:
     return "float";
   case e_double:
     return "double";
   case e_long_double:
     return "long double";
-  case e_sint128:
-    return "int128_t";
-  case e_uint128:
-    return "uint128_t";
-  case e_sint256:
-    return "int256_t";
-  case e_uint256:
-    return "uint256_t";
-  case e_sint512:
-    return "int512_t";
-  case e_uint512:
-    return "uint512_t";
   }
   return "???";
 }
 
 Scalar::Type
 Scalar::GetValueTypeForSignedIntegerWithByteSize(size_t byte_size) {
-  if (byte_size <= sizeof(sint_t))
-    return e_sint;
-  if (byte_size <= sizeof(slong_t))
-    return e_slong;
-  if (byte_size <= sizeof(slonglong_t))
-    return e_slonglong;
-  return e_void;
 }
 
 Scalar::Type
 Scalar::GetValueTypeForUnsignedIntegerWithByteSize(size_t byte_size) {
-  if (byte_size <= sizeof(uint_t))
-    return e_uint;
-  if (byte_size <= sizeof(ulong_t))
-    return e_ulong;
-  if (byte_size <= sizeof(ulonglong_t))
-    return e_ulonglong;
-  return e_void;
 }
 
 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))
case e_void:
     break;
   case e_sint:
     success = true;
     break;
   case e_uint:
     m_type = e_sint;
     success = true;
     break;
-  case e_slong:
-    success = true;
-    break;
-  case e_ulong:
-    m_type = e_slong;
-    success = true;
-    break;
-  case e_slonglong:
-    success = true;
-    break;
-  case e_ulonglong:
-    m_type = e_slonglong;
-    success = true;
-    break;
-  case e_sint128:
-    success = true;
-    break;
-  case e_uint128:
-    m_type = e_sint128;
-    success = true;
-    break;
-  case e_sint256:
-    success = true;
-    break;
-  case e_uint256:
-    m_type = e_sint256;
-    success = true;
-    break;
-  case e_sint512:
-    success = true;
-    break;
-  case e_uint512:
-    m_type = e_sint512;
-    success = true;
-    break;
   case e_float:
     success = true;
     break;
   case e_double:
     success = true;
     break;
   case e_long_double:
     success = true;
case e_void:
     break;
   case e_sint:
     m_type = e_uint;
     success = true;
     break;
   case e_uint:
     success = true;
     break;
-  case e_slong:
-    m_type = e_ulong;
-    success = true;
-    break;
-  case e_ulong:
-    success = true;
-    break;
-  case e_slonglong:
-    m_type = e_ulonglong;
-    success = true;
-    break;
-  case e_ulonglong:
-    success = true;
-    break;
-  case e_sint128:
-    m_type = e_uint128;
-    success = true;
-    break;
-  case e_uint128:
-    success = true;
-    break;
-  case e_sint256:
-    m_type = e_uint256;
-    success = true;
-    break;
-  case e_uint256:
-    success = true;
-    break;
-  case e_sint512:
-    m_type = e_uint512;
-    success = true;
-    break;
-  case e_uint512:
-    success = true;
-    break;
   case e_float:
     success = true;
     break;
   case e_double:
     success = true;
     break;
   case e_long_double:
     success = true;
long double Scalar::LongDouble(long double fail_value) const {
   /// No way to get more precision at the moment.
   return static_cast<long double>(Double(fail_value));
 }
 
 Scalar &Scalar::operator+=(const Scalar &rhs) {
   Scalar temp_value;
   const Scalar *a;
   const Scalar *b;
-  if ((m_type = PromoteToMaxType(*this, rhs, temp_value, a, b)) !=
+  if ((m_type = Scalar::PromoteToMaxType(*this, rhs, temp_value, a, b)) !=
       Scalar::e_void) {
     switch (GetCategory(m_type)) {
     case Category::Void:
       break;
     case Category::Integral:
       m_integer = a->m_integer + b->m_integer;
       break;
 
Scalar &Scalar::operator>>=(const Scalar &rhs) {
   case e_float:
   case e_double:
   case e_long_double:
     m_type = e_void;
     break;
 
   case e_sint:
   case e_uint:
-  case e_slong:
-  case e_ulong:
-  case e_slonglong:
-  case e_ulonglong:
-  case e_sint128:
-  case e_uint128:
-  case e_sint256:
-  case e_uint256:
-  case e_sint512:
-  case e_uint512:
     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:
-    case e_slong:
-    case e_ulong:
-    case e_slonglong:
-    case e_ulonglong:
-    case e_sint128:
-    case e_uint128:
-    case e_sint256:
-    case e_uint256:
-    case e_sint512:
-    case e_uint512:
       m_integer = m_integer.ashr(rhs.m_integer);
       break;
     }
     break;
   }
   return *this;
 }
 
 Scalar &Scalar::operator&=(const Scalar &rhs) {
   if (GetCategory(m_type) == Category::Integral &&
       GetCategory(rhs.m_type) == Category::Integral)
     m_integer &= rhs.m_integer;
   else
     m_type = e_void;
   return *this;
 }
 
 bool Scalar::AbsoluteValue() {
   switch (m_type) {
   case e_void:
     break;
 
   case e_sint:
-  case e_slong:
-  case e_slonglong:
-  case e_sint128:
-  case e_sint256:
-  case e_sint512:
     if (m_integer.isNegative())
       m_integer = -m_integer;
     return true;
 
   case e_uint:
-  case e_ulong:
-  case e_ulonglong:
     return true;
-  case e_uint128:
-  case e_uint256:
-  case e_uint512:
   case e_float:
   case e_double:
   case e_long_double:
     m_float.clearSign();
     return true;
   }
   return false;
 }
const Scalar lldb_private::operator+(const Scalar &lhs, const Scalar &rhs) {
   return result;
 }
 
 const Scalar lldb_private::operator-(const Scalar &lhs, const Scalar &rhs) {
   Scalar result;
   Scalar temp_value;
   const Scalar *a;
   const Scalar *b;
-  if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
+  if ((result.m_type = Scalar::PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
       Scalar::e_void) {
     switch (GetCategory(result.m_type)) {
     case Category::Void:
       break;
     case Category::Integral:
       result.m_integer = a->m_integer - b->m_integer;
       break;
     case Category::Float:
       result.m_float = a->m_float - b->m_float;
       break;
     }
   }
   return result;
 }
 
 const Scalar lldb_private::operator/(const Scalar &lhs, const Scalar &rhs) {
   Scalar result;
   Scalar temp_value;
   const Scalar *a;
   const Scalar *b;
-  if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
+  if ((result.m_type = Scalar::PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
           Scalar::e_void &&
       !b->IsZero()) {
     switch (GetCategory(result.m_type)) {
     case Category::Void:
       break;
     case Category::Integral:
       if (IsSigned(result.m_type))
         result.m_integer = a->m_integer.sdiv(b->m_integer);
const Scalar lldb_private::operator/(const Scalar &lhs, const Scalar &rhs) {
   return result;
 }
 
 const Scalar lldb_private::operator*(const Scalar &lhs, const Scalar &rhs) {
   Scalar result;
   Scalar temp_value;
   const Scalar *a;
   const Scalar *b;
-  if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
+  if ((result.m_type = Scalar::PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
       Scalar::e_void) {
     switch (GetCategory(result.m_type)) {
     case Category::Void:
       break;
     case Category::Integral:
       result.m_integer = a->m_integer * b->m_integer;
       break;
     case Category::Float:
       result.m_float = a->m_float * b->m_float;
       break;
     }
   }
   return result;
 }
 
 const Scalar lldb_private::operator&(const Scalar &lhs, const Scalar &rhs) {
   Scalar result;
   Scalar temp_value;
   const Scalar *a;
   const Scalar *b;
-  if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
+  if ((result.m_type = Scalar::PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
       Scalar::e_void) {
     if (GetCategory(result.m_type) == Category::Integral)
       result.m_integer = a->m_integer & b->m_integer;
     else
       result.m_type = Scalar::e_void;
   }
   return result;
 }
 
 const Scalar lldb_private::operator|(const Scalar &lhs, const Scalar &rhs) {
   Scalar result;
   Scalar temp_value;
   const Scalar *a;
   const Scalar *b;
-  if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
+  if ((result.m_type = Scalar::PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
       Scalar::e_void) {
     if (GetCategory(result.m_type) == Category::Integral)
       result.m_integer = a->m_integer | b->m_integer;
     else
       result.m_type = Scalar::e_void;
   }
   return result;
 }
 
 const Scalar lldb_private::operator%(const Scalar &lhs, const Scalar &rhs) {
   Scalar result;
   Scalar temp_value;
   const Scalar *a;
   const Scalar *b;
-  if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
+  if ((result.m_type = Scalar::PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
       Scalar::e_void) {
     if (!b->IsZero() && GetCategory(result.m_type) == Category::Integral) {
       if (IsSigned(result.m_type))
         result.m_integer = a->m_integer.srem(b->m_integer);
       else
         result.m_integer = a->m_integer.urem(b->m_integer);
       return result;
     }
   }
   result.m_type = Scalar::e_void;
   return result;
 }
 
 const Scalar lldb_private::operator^(const Scalar &lhs, const Scalar &rhs) {
   Scalar result;
   Scalar temp_value;
   const Scalar *a;
   const Scalar *b;
-  if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
+  if ((result.m_type = Scalar::PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
       Scalar::e_void) {
     if (GetCategory(result.m_type) == Category::Integral)
       result.m_integer = a->m_integer ^ b->m_integer;
     else
       result.m_type = Scalar::e_void;
   }
   return result;
 }
case eEncodingUint: {
     } else
       fits = integer.isIntN(byte_size * 8);
     if (!fits) {
       error.SetErrorStringWithFormatv(
           "value {0} is too large to fit in a {1} byte integer value",
           value_str, byte_size);
       break;
     }
-    m_type = GetBestTypeForBitSize(8 * byte_size, is_signed);
-    if (m_type == e_void) {
-      error.SetErrorStringWithFormatv("unsupported integer byte size: {0}",
-                                      byte_size);
-      break;
+    if (is_signed) {
+      m_type = e_sint;
+      m_integer = integer.sextOrTrunc(8 * byte_size);
+    } else {
+      m_type = e_uint;
+      m_integer = integer.zextOrTrunc(8 * byte_size);
     }
-    if (is_signed)
-      m_integer = integer.sextOrTrunc(GetBitSize(m_type));
-    else
-      m_integer = integer.zextOrTrunc(GetBitSize(m_type));
     break;
   }
 
   case eEncodingIEEE754: {
     Type type = GetValueTypeForFloatWithByteSize(byte_size);
     if (type == e_void) {
       error.SetErrorStringWithFormatv("unsupported float byte size: {0}",
                                       byte_size);
if (sign_bit_pos < max_bit_pos) {
     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:
-    case Scalar::e_slong:
-    case Scalar::e_ulong:
-    case Scalar::e_slonglong:
-    case Scalar::e_ulonglong:
-    case Scalar::e_sint128:
-    case Scalar::e_uint128:
-    case Scalar::e_sint256:
-    case Scalar::e_uint256:
-    case Scalar::e_sint512:
-    case Scalar::e_uint512:
       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);
         llvm::APInt bitwize_and = m_integer & sign_bit;
         if (bitwize_and.getBoolValue()) {
           const llvm::APInt mask =
               ~(sign_bit) + llvm::APInt(m_integer.getBitWidth(), 1);
bool Scalar::ExtractBitfield(uint32_t bit_size, uint32_t bit_offset) {
   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:
-  case Scalar::e_slong:
-  case Scalar::e_slonglong:
-  case Scalar::e_sint128:
-  case Scalar::e_sint256:
-  case Scalar::e_sint512:
     m_integer = m_integer.ashr(bit_offset)
                     .sextOrTrunc(bit_size)
                     .sextOrSelf(8 * GetByteSize());
     return true;
 
   case Scalar::e_uint:
-  case Scalar::e_ulong:
-  case Scalar::e_ulonglong:
-  case Scalar::e_uint128:
-  case Scalar::e_uint256:
-  case Scalar::e_uint512:
     m_integer = m_integer.lshr(bit_offset)
                     .zextOrTrunc(bit_size)
                     .zextOrSelf(8 * GetByteSize());
     return true;
   }
   return false;
 }
 
 bool lldb_private::operator==(const Scalar &lhs, const Scalar &rhs) {
   // If either entry is void then we can just compare the types
   if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
     return lhs.m_type == rhs.m_type;
 
   Scalar temp_value;
   const Scalar *a;
   const Scalar *b;
   llvm::APFloat::cmpResult result;
-  switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) {
+  switch (Scalar::PromoteToMaxType(lhs, rhs, temp_value, a, b)) {
   case Scalar::e_void:
     break;
   case Scalar::e_sint:
   case Scalar::e_uint:
-  case Scalar::e_slong:
-  case Scalar::e_ulong:
-  case Scalar::e_slonglong:
-  case Scalar::e_ulonglong:
-  case Scalar::e_sint128:
-  case Scalar::e_uint128:
-  case Scalar::e_sint256:
-  case Scalar::e_uint256:
-  case Scalar::e_sint512:
-  case Scalar::e_uint512:
     return a->m_integer == b->m_integer;
   case Scalar::e_float:
   case Scalar::e_double:
   case Scalar::e_long_double:
     result = a->m_float.compare(b->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<(const Scalar &lhs, const Scalar &rhs) {
   if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
     return false;
 
   Scalar temp_value;
   const Scalar *a;
   const Scalar *b;
   llvm::APFloat::cmpResult result;
-  switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) {
+  switch (Scalar::PromoteToMaxType(lhs, rhs, temp_value, a, b)) {
   case Scalar::e_void:
     break;
   case Scalar::e_sint:
-  case Scalar::e_slong:
-  case Scalar::e_slonglong:
-  case Scalar::e_sint128:
-  case Scalar::e_sint256:
-  case Scalar::e_sint512:
-  case Scalar::e_uint512:
     return a->m_integer.slt(b->m_integer);
   case Scalar::e_uint:
-  case Scalar::e_ulong:
-  case Scalar::e_ulonglong:
-  case Scalar::e_uint128:
-  case Scalar::e_uint256:
     return a->m_integer.ult(b->m_integer);
   case Scalar::e_float:
   case Scalar::e_double:
   case Scalar::e_long_double:
     result = a->m_float.compare(b->m_float);
     if (result == llvm::APFloat::cmpLessThan)
       return true;
   }

 }
 
 bool Scalar::ClearBit(uint32_t bit) {
   switch (m_type) {
   case e_void:
     break;
   case e_sint:
   case e_uint:
-  case e_slong:
-  case e_ulong:
-  case e_slonglong:
-  case e_ulonglong:
-  case e_sint128:
-  case e_uint128:
-  case e_sint256:
-  case e_uint256:
-  case e_sint512:
-  case e_uint512:
     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:
-  case e_slong:
-  case e_ulong:
-  case e_slonglong:
-  case e_ulonglong:
-  case e_sint128:
-  case e_uint128:
-  case e_sint256:
-  case e_uint256:
-  case e_sint512:
-  case e_uint512:
     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

 //===-- ScalarTest.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 "gtest/gtest.h"
 
 #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::APInt;
TEST(ScalarTest, Division) {
   Scalar lhs(5.0);
   Scalar rhs(2.0);
   Scalar r = lhs / rhs;
   EXPECT_TRUE(r.IsValid());
   EXPECT_EQ(r, Scalar(2.5));
 }
 
 TEST(ScalarTest, Promotion) {
-  static Scalar::Type int_types[] = {
-      Scalar::e_sint,    Scalar::e_uint,      Scalar::e_slong,
-      Scalar::e_ulong,   Scalar::e_slonglong, Scalar::e_ulonglong,
-      Scalar::e_sint128, Scalar::e_uint128,   Scalar::e_sint256,
-      Scalar::e_uint256,
-      Scalar::e_void // sentinel
-  };
-
-  static Scalar::Type float_types[] = {
-      Scalar::e_float, Scalar::e_double, Scalar::e_long_double,
-      Scalar::e_void // sentinel
-  };
-
-  for (int i = 0; int_types[i] != Scalar::e_void; ++i) {
-    for (int j = 0; float_types[j] != Scalar::e_void; ++j) {
-      Scalar lhs(2);
-      EXPECT_TRUE(lhs.Promote(int_types[i])) << "int promotion #" << i;
-      Scalar rhs(0.5f);
-      EXPECT_TRUE(rhs.Promote(float_types[j])) << "float promotion #" << j;
-      Scalar x(2.5f);
-      EXPECT_TRUE(x.Promote(float_types[j]));
-      EXPECT_EQ(lhs + rhs, x);
-    }
-  }
-
-  for (int i = 0; float_types[i] != Scalar::e_void; ++i) {
-    for (int j = 0; float_types[j] != Scalar::e_void; ++j) {
-      Scalar lhs(2);
-      EXPECT_TRUE(lhs.Promote(float_types[i])) << "float promotion #" << i;
-      Scalar rhs(0.5f);
-      EXPECT_TRUE(rhs.Promote(float_types[j])) << "float promotion #" << j;
-      Scalar x(2.5f);
-      EXPECT_TRUE(x.Promote(float_types[j]));
-      EXPECT_EQ(lhs + rhs, x);
-    }
-  }
+  Scalar a(47);
+  EXPECT_TRUE(a.IntegralPromote(64, true));
+  EXPECT_EQ(Scalar::e_sint, a.GetType());
+  EXPECT_EQ(APInt(64, 47), a.UInt128(APInt()));
+
+  EXPECT_FALSE(a.IntegralPromote(32, true));
+  EXPECT_FALSE(a.IntegralPromote(32, false));
+  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_EQ(47.0, a.Double());
+
+  EXPECT_FALSE(a.FloatPromote(Scalar::e_float));
+  EXPECT_TRUE(a.FloatPromote(Scalar::e_long_double));
+  EXPECT_EQ(47.0L, a.LongDouble());
 }
 
 TEST(ScalarTest, SetValueFromCString) {
   Scalar a;
 
   EXPECT_THAT_ERROR(
       a.SetValueFromCString("1234567890123", lldb::eEncodingUint, 8).ToError(),
       Succeeded());
EXPECT_THAT_ERROR(
       Succeeded());
   EXPECT_EQ(47.25f, a);
   EXPECT_THAT_ERROR(
       a.SetValueFromCString("asdf", lldb::eEncodingIEEE754, 4).ToError(),
       Failed());
 }
 
 TEST(ScalarTest, APIntConstructor) {
-  auto width_array = {8, 16, 32};
-  for (auto &w : width_array) {
-    Scalar A(APInt(w, 24));
+  for (auto &width : {8, 16, 32}) {
+    Scalar A(APInt(width, 24));
     EXPECT_EQ(A.GetType(), Scalar::e_sint);
+    EXPECT_EQ(APInt(width, 24), A.UInt128(APInt()));
   }
-
-  Scalar B(APInt(64, 42));
-  EXPECT_EQ(B.GetType(), Scalar::GetBestTypeForBitSize(64, true));
-  Scalar C(APInt(128, 96));
-  EXPECT_EQ(C.GetType(), Scalar::e_sint128);
-  Scalar D(APInt(256, 156));
-  EXPECT_EQ(D.GetType(), Scalar::e_sint256);
-  Scalar E(APInt(512, 456));
-  EXPECT_EQ(E.GetType(), Scalar::e_sint512);
 }
 
 TEST(ScalarTest, Scalar_512) {
   Scalar Z(APInt(512, 0));
   ASSERT_TRUE(Z.IsZero());
   Z.MakeUnsigned();
   ASSERT_TRUE(Z.IsZero());
 
   Scalar S(APInt(512, 2000));
-  ASSERT_STREQ(S.GetTypeAsCString(), "int512_t");
-  ASSERT_STREQ(S.GetValueTypeAsCString(Scalar::e_sint512), "int512_t");
+  ASSERT_STREQ(S.GetTypeAsCString(), "signed int");
 
   ASSERT_TRUE(S.MakeUnsigned());
-  EXPECT_EQ(S.GetType(), Scalar::e_uint512);
-  ASSERT_STREQ(S.GetTypeAsCString(), "uint512_t");
-  ASSERT_STREQ(S.GetValueTypeAsCString(Scalar::e_uint512), "uint512_t");
+  EXPECT_EQ(S.GetType(), Scalar::e_uint);
+  ASSERT_STREQ(S.GetTypeAsCString(), "unsigned int");
   EXPECT_EQ(S.GetByteSize(), 64U);
 
   ASSERT_TRUE(S.MakeSigned());
-  EXPECT_EQ(S.GetType(), Scalar::e_sint512);
+  EXPECT_EQ(S.GetType(), Scalar::e_sint);
   EXPECT_EQ(S.GetByteSize(), 64U);
 }
 
 TEST(ScalarTest, TruncOrExtendTo) {
   Scalar S(0xffff);
   S.TruncOrExtendTo(12, true);
   EXPECT_EQ(S.UInt128(APInt()), APInt(12, 0xfffu));
   S.TruncOrExtendTo(20, true);
   EXPECT_EQ(S.UInt128(APInt()), APInt(20, 0xfffffu));
   S.TruncOrExtendTo(24, false);
   EXPECT_EQ(S.UInt128(APInt()), APInt(24, 0x0fffffu));
   S.TruncOrExtendTo(16, false);
   EXPECT_EQ(S.UInt128(APInt()), APInt(16, 0xffffu));
 }