[lldb/Utility] Use APSInt in the Scalar class

This enables us to further simplify some code because it no longer needs
to switch on the signedness of the type (APSInt handles that).

Author: labath

lldb/include/lldb/Utility/Scalar.h

@@ -14,7 +14,7 @@
 #include "lldb/lldb-enumerations.h"
 #include "lldb/lldb-private-types.h"
 #include "llvm/ADT/APFloat.h"
-#include "llvm/ADT/APInt.h"
+#include "llvm/ADT/APSInt.h"
 #include <cstddef>
 #include <cstdint>
 #include <utility>
@@ -38,35 +38,35 @@ namespace lldb_private {
 // and values before performing these operations. Type promotion currently
 // follows the ANSI C type promotion rules.
 class Scalar {
+  template<typename T>
+  static llvm::APSInt MakeAPSInt(T v) {
+    static_assert(std::is_integral<T>::value, "");
+    static_assert(sizeof(T) <= sizeof(uint64_t), "Conversion loses precision!");
+    return llvm::APSInt(
+        llvm::APInt(sizeof(T) * 8, uint64_t(v), std::is_signed<T>::value),
+        std::is_unsigned<T>::value);
+  }
+
 public:
   // FIXME: These are host types which seems to be an odd choice.
   enum Type {
     e_void = 0,
-    e_sint,
-    e_uint,
+    e_int,
     e_float,
   };
 
   // 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(int v) : m_type(e_int), m_integer(MakeAPSInt(v)), 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) {}
+      : m_type(e_int), m_integer(MakeAPSInt(v)), m_float(0.0f) {}
+  Scalar(long v) : m_type(e_int), m_integer(MakeAPSInt(v)), 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) {}
+      : m_type(e_int), m_integer(MakeAPSInt(v)), 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) {}
+      : m_type(e_int), m_integer(MakeAPSInt(v)), 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) {}
+      : m_type(e_int), m_integer(MakeAPSInt(v)), m_float(0.0f) {}
   Scalar(float v) : m_type(e_float), m_float(v) {}
   Scalar(double v) : m_type(e_float), m_float(v) {}
   Scalar(long double v) : m_type(e_float), m_float(double(v)) {
@@ -75,7 +75,7 @@ class Scalar {
                     llvm::APFloat::rmNearestTiesToEven, &ignore);
   }
   Scalar(llvm::APInt v)
-      : m_type(e_sint), m_integer(std::move(v)), m_float(0.0f) {}
+      : m_type(e_int), m_integer(std::move(v), false), m_float(0.0f) {}
 
   bool SignExtend(uint32_t bit_pos);
 
@@ -108,14 +108,15 @@ class Scalar {
 
   void GetValue(Stream *s, bool show_type) const;
 
-  bool IsValid() const { return (m_type >= e_sint) && (m_type <= e_float); }
+  bool IsValid() const { return (m_type >= e_int) && (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(const llvm::fltSemantics &semantics);
 
+  bool IsSigned() const;
   bool MakeSigned();
 
   bool MakeUnsigned();
@@ -234,7 +235,7 @@ class Scalar {
 
   // Classes that inherit from Scalar can see and modify these
   Scalar::Type m_type;
-  llvm::APInt m_integer;
+  llvm::APSInt m_integer;
   llvm::APFloat m_float;
 
   template <typename T> T GetAs(T fail_value) const;