[lldb] Add support for negative integer to {SB,}StructuredData

[mib]

Summary

This patch refactors the StructuredData::Integer class to make it
templated, makes it private and adds 2 public specialization for both
int64_t & uint64_t with a public type aliases, respectively
SignedInteger & UnsignedInteger.

It adds new getter for signed and unsigned interger values to the
StructuredData::Object base class and changes the implementation of
StructuredData::Array::GetItemAtIndexAsInteger and
StructuredData::Dictionary::GetValueForKeyAsInteger to support signed
and unsigned integers.

This patch also adds 2 new Get{Signed,Unsigned}IntegerValue to the
SBStructuredData class and marks GetIntegerValue as deprecated.

Finally, this patch audits all the caller of StructuredData::Integer
or StructuredData::GetIntegerValue to use the proper type as well the
various tests that uses SBStructuredData.GetIntegerValue.

rdar://105575764

Signed-off-by: Med Ismail Bennani <[e-mail]>

[bulbazord]

This is going to need some tests... And because you're adding templates to the SBAPI we'll need multiple tests -- Not just on the python side but I think we should add some actual C++ tests here in test/API/api/

lldb/include/lldb/API/SBStructuredData.h

12–13

You can't include a private header in a public header.

77–78

All the SB API classes are non-virtual, single inheritance classes. They should only include SBDefines.h or other SB headers as needed. There should be no inlined method implementations in the header files, they should all be in the implementation files. And there should be no direct ivar access.

Emphasis mine, from: https://lldb.llvm.org/design/sbapi.html

We should be able to move this into the implementation file.

78–79

This implementation allows us to generate GetIntegerValue for things like const char * and will just return a fail_value for those things. I think the interface would be better if it could give users feedback when they accidentally do something wrong with types instead of just giving them back whatever they want the failure value to be. Is there a way we can use SFINAE to only generate GetIntegerValue for things that are integral type? Would such a thing be compatible with SWIG?

lldb/include/lldb/Core/StructuredDataImpl.h

131

Not related to your change, we should probably move StructuredDataImpl to Utility :P

lldb/include/lldb/Utility/StructuredData.h

313–314

Check for floating type here in addition, just like below.

lldb/include/lldb/lldb-enumerations.h

819–820

Is it a good idea to insert these in the middle? Not that people should do this, but I assume some people hardcode these values in their script....

[JDevlieghere]

lldb/include/lldb/API/SBStructuredData.h

77

I'm open to the idea of adding templates to the SB API, but I think that will require careful considerations in terms of impact on the ABI, the bindings, etc. I'm not convinced this use case really warrants that: it looks like there's only really two meaningful instantiations.

[mib]

Many changes:

• Change SBAPI templated specialization for 2 distinct methods GetUnsignedIntegerValue & GetSignedIntegerValue
• Add new tests
• Update previous tests

[bulbazord]

Ok, this is a pretty big patch so we probably don't want to leave it in review for a long time or it just gets harder to land correctly.

I've looked over most of this patch and it looks fine to me. A lot of is rather mechanical: Changing things like GetIntegerValue to GetUnsignedIntegerValue and using GetSignedIntegerValue where it makes sense. There are lots of little cleanups as well, like correcting the type of some variables (e.g. addr_t -> offset_t) and these are fine too. I don't have much of a problem with any of that.

2 small things though and I think this should probably be good after that.

lldb/include/lldb/API/SBStructuredData.h

81–84

Did you mean to remove the deprecated attribute and use LLDB_DEPRECATED directly?

lldb/include/lldb/Utility/StructuredData.h

105–106

Could you add a small note here specifying why eStructuredDataTypeInteger corresponds to UnsignedInteger and not SignedInteger?

[mib]

Address @bulbazord comments.

[bulbazord]

Alright, looks good to me. Let's see what the bots think!

lldb/include/lldb/API/SBStructuredData.h

 //===-- SBStructuredData.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_API_SBSTRUCTUREDDATA_H
 #define LLDB_API_SBSTRUCTUREDDATA_H
 
 #include "lldb/API/SBDefines.h"
 #include "lldb/API/SBModule.h"
 
 namespace lldb_private {
 namespace python {
 class SWIGBridge;
 }
 namespace lua {
 class SWIGBridge;
 }
public:
 
   /// Return the size (i.e. number of elements) in this data structure
   /// if it is an array or dictionary type. For other types, 0 will be
   //  returned.
   size_t GetSize() const;
 
   /// Fill keys with the keys in this object and return true if this data
   /// structure is a dictionary.  Returns false otherwise.
-   bool GetKeys(lldb::SBStringList &keys) const;
 
   /// Return the value corresponding to a key if this data structure
   /// is a dictionary type.
   lldb::SBStructuredData GetValueForKey(const char *key) const;
 
   /// Return the value corresponding to an index if this data structure
   /// is array.
   lldb::SBStructuredData GetItemAtIndex(size_t idx) const;
 
   /// Return the integer value if this data structure is an integer type.
+  uint64_t GetUnsignedIntegerValue(uint64_t fail_value = 0) const;
+  /// Return the integer value if this data structure is an integer type.
+  int64_t GetSignedIntegerValue(int64_t fail_value = 0) const;
+
+  LLDB_DEPRECATED("Specify if the value is signed or unsigned",
+                  "uint64_t GetUnsignedIntegerValue(uint64_t fail_value = 0)")
   uint64_t GetIntegerValue(uint64_t fail_value = 0) const;
 
   /// Return the floating point value if this data structure is a floating
   /// type.
   double GetFloatValue(double fail_value = 0.0) const;
 
   /// Return the boolean value if this data structure is a boolean type.
   bool GetBooleanValue(bool fail_value = false) const;
 
   /// Provides the string value if this data structure is a string type.
   ///
   /// \param[out] dst
   ///     pointer where the string value will be written. In case it is null,
   ///     nothing will be written at \a dst.
   ///
   /// \param[in] dst_len

lldb/include/lldb/Core/StructuredDataImpl.h

StructuredData::ObjectSP GetItemAtIndex(size_t idx) const {
     if (m_data_sp) {
       auto array = m_data_sp->GetAsArray();
       if (array)
         return array->GetItemAtIndex(idx);
     }
     return StructuredData::ObjectSP();
   }
 
   uint64_t GetIntegerValue(uint64_t fail_value = 0) const {
-    return (m_data_sp ? m_data_sp->GetIntegerValue(fail_value) : fail_value);
+    return (m_data_sp ? m_data_sp->GetUnsignedIntegerValue(fail_value)
+                      : fail_value);
+  }
+
+  int64_t GetIntegerValue(int64_t fail_value = 0) const {
+    return (m_data_sp ? m_data_sp->GetSignedIntegerValue(fail_value)
+                      : fail_value);
   }
 
   double GetFloatValue(double fail_value = 0.0) const {
     return (m_data_sp ? m_data_sp->GetFloatValue(fail_value) : fail_value);
   }
 
   bool GetBooleanValue(bool fail_value = false) const {
     return (m_data_sp ? m_data_sp->GetBooleanValue(fail_value) : fail_value);

lldb/include/lldb/Utility/StructuredData.h

 #include <cstddef>
 #include <cstdint>
 #include <functional>
 #include <map>
 #include <memory>
 #include <string>
 #include <type_traits>
 #include <utility>
+#include <variant>
 #include <vector>
 
 namespace lldb_private {
 class Status;
 }
 
 namespace lldb_private {
 
 /// \class StructuredData StructuredData.h "lldb/Utility/StructuredData.h"
 /// A class which can hold structured data
 ///
 /// The StructuredData class is designed to hold the data from a JSON or plist
 /// style file -- a serialized data structure with dictionaries (maps,
 /// hashes), arrays, and concrete values like integers, floating point
 /// numbers, strings, booleans.
 ///
 /// StructuredData does not presuppose any knowledge of the schema for the
 /// data it is holding; it can parse JSON data, for instance, and other parts
 /// of lldb can iterate through the parsed data set to find keys and values
 /// that may be present.
 
 class StructuredData {
+  template <typename N> class Integer;
+
 public:
   class Object;
   class Array;
-  class Integer;
+  using UnsignedInteger = Integer<uint64_t>;
+  using SignedInteger = Integer<int64_t>;
   class Float;
   class Boolean;
   class String;
   class Dictionary;
   class Generic;
 
   typedef std::shared_ptr<Object> ObjectSP;
   typedef std::shared_ptr<Array> ArraySP;
-  typedef std::shared_ptr<Integer> IntegerSP;
+  typedef std::shared_ptr<UnsignedInteger> UnsignedIntegerSP;
+  typedef std::shared_ptr<SignedInteger> SignedIntegerSP;
   typedef std::shared_ptr<Float> FloatSP;
   typedef std::shared_ptr<Boolean> BooleanSP;
   typedef std::shared_ptr<String> StringSP;
   typedef std::shared_ptr<Dictionary> DictionarySP;
   typedef std::shared_ptr<Generic> GenericSP;
 
+  typedef std::variant<UnsignedIntegerSP, SignedIntegerSP> IntegerSP;
+
   class Object : public std::enable_shared_from_this<Object> {
   public:
     Object(lldb::StructuredDataType t = lldb::eStructuredDataTypeInvalid)
         : m_type(t) {}
 
     virtual ~Object() = default;
 
     virtual bool IsValid() const { return true; }
public:
     }
 
     Dictionary *GetAsDictionary() {
       return ((m_type == lldb::eStructuredDataTypeDictionary)
                   ? static_cast<Dictionary *>(this)
                   : nullptr);
     }
 
-    Integer *GetAsInteger() {
-      return ((m_type == lldb::eStructuredDataTypeInteger)
-                  ? static_cast<Integer *>(this)
+    UnsignedInteger *GetAsUnsignedInteger() {
+      // NOTE: For backward compatibility, eStructuredDataTypeInteger is
+      // the same as eStructuredDataTypeUnsignedInteger.
+      return ((m_type == lldb::eStructuredDataTypeInteger ||
+               m_type == lldb::eStructuredDataTypeUnsignedInteger)
+                  ? static_cast<UnsignedInteger *>(this)
+                  : nullptr);
+    }
+
+    SignedInteger *GetAsSignedInteger() {
+      return ((m_type == lldb::eStructuredDataTypeSignedInteger)
+                  ? static_cast<SignedInteger *>(this)
                   : nullptr);
     }
 
-    uint64_t GetIntegerValue(uint64_t fail_value = 0) {
-      Integer *integer = GetAsInteger();
+    uint64_t GetUnsignedIntegerValue(uint64_t fail_value = 0) {
+      UnsignedInteger *integer = GetAsUnsignedInteger();
+      return ((integer != nullptr) ? integer->GetValue() : fail_value);
+    }
+
+    int64_t GetSignedIntegerValue(int64_t fail_value = 0) {
+      SignedInteger *integer = GetAsSignedInteger();
       return ((integer != nullptr) ? integer->GetValue() : fail_value);
     }
 
     Float *GetAsFloat() {
       return ((m_type == lldb::eStructuredDataTypeFloat)
                   ? static_cast<Float *>(this)
                   : nullptr);
     }
ObjectSP GetItemAtIndex(size_t idx) const {
         return m_items[idx];
       return ObjectSP();
     }
 
     template <class IntType>
     bool GetItemAtIndexAsInteger(size_t idx, IntType &result) const {
       ObjectSP value_sp = GetItemAtIndex(idx);
       if (value_sp.get()) {
-        if (auto int_value = value_sp->GetAsInteger()) {
-          result = static_cast<IntType>(int_value->GetValue());
+        if constexpr (std::numeric_limits<IntType>::is_signed) {
+          if (auto signed_value = value_sp->GetAsSignedInteger()) {
+            result = static_cast<IntType>(signed_value->GetValue());
+            return true;
+          }
+        } else {
+          if (auto unsigned_value = value_sp->GetAsUnsignedInteger()) {
+            result = static_cast<IntType>(unsigned_value->GetValue());
             return true;
           }
         }
+      }
       return false;
     }
 
     template <class IntType>
     bool GetItemAtIndexAsInteger(size_t idx, IntType &result,
                                  IntType default_val) const {
       bool success = GetItemAtIndexAsInteger(idx, result);
       if (!success)
bool GetItemAtIndexAsArray(size_t idx, Array *&result) const {
       }
       return false;
     }
 
     void Push(const ObjectSP &item) { m_items.push_back(item); }
 
     void AddItem(const ObjectSP &item) { m_items.push_back(item); }
 
+    template <typename T> void AddIntegerItem(T value) {
+      static_assert(std::is_integral<T>::value ||
+                        std::is_floating_point<T>::value,
+                    "value type should be integral");
+      if constexpr (std::numeric_limits<T>::is_signed)
+        AddItem(std::make_shared<SignedInteger>(value));
+      else
+        AddItem(std::make_shared<UnsignedInteger>(value));
+    }
+
+    void AddFloatItem(double value) { AddItem(std::make_shared<Float>(value)); }
+
+    void AddStringItem(llvm::StringRef value) {
+      AddItem(std::make_shared<String>(std::move(value)));
+    }
+
+    void AddBooleanItem(bool value) {
+      AddItem(std::make_shared<Boolean>(value));
+    }
+
     void Serialize(llvm::json::OStream &s) const override;
 
     void GetDescription(lldb_private::Stream &s) const override;
 
   protected:
     typedef std::vector<ObjectSP> collection;
     collection m_items;
   };
 
-  class Integer : public Object {
-  public:
-    Integer(uint64_t i = 0)
-        : Object(lldb::eStructuredDataTypeInteger), m_value(i) {}
+private:
+  template <typename N> class Integer : public Object {
+    static_assert(std::is_integral<N>::value, "N must be an integral type");
 
+  public:
+    Integer(N i = 0)
+        : Object(std::numeric_limits<N>::is_signed
+                     ? lldb::eStructuredDataTypeSignedInteger
+                     : lldb::eStructuredDataTypeUnsignedInteger),
+          m_value(i) {}
     ~Integer() override = default;
 
-    void SetValue(uint64_t value) { m_value = value; }
+    void SetValue(N value) { m_value = value; }
 
-    uint64_t GetValue() { return m_value; }
+    N GetValue() { return m_value; }
 
-    void Serialize(llvm::json::OStream &s) const override;
+    void Serialize(llvm::json::OStream &s) const override {
+      s.value(static_cast<N>(m_value));
+    }
 
-    void GetDescription(lldb_private::Stream &s) const override;
+    void GetDescription(lldb_private::Stream &s) const override {
+      s.Printf(std::numeric_limits<N>::is_signed ? "%" PRId64 : "%" PRIu64,
+               static_cast<N>(m_value));
+    }
 
   protected:
-    uint64_t m_value;
+    N m_value;
   };
 
+public:
   class Float : public Object {
   public:
     Float(double d = 0.0)
         : Object(lldb::eStructuredDataTypeFloat), m_value(d) {}
 
     ~Float() override = default;
 
     void SetValue(double value) { m_value = value; }
bool GetValueForKeyAsBoolean(llvm::StringRef key, bool &result) const {
         }
       }
       return success;
     }
     template <class IntType>
     bool GetValueForKeyAsInteger(llvm::StringRef key, IntType &result) const {
       ObjectSP value_sp = GetValueForKey(key);
       if (value_sp) {
-        if (auto int_value = value_sp->GetAsInteger()) {
-          result = static_cast<IntType>(int_value->GetValue());
+        if constexpr (std::numeric_limits<IntType>::is_signed) {
+          if (auto signed_value = value_sp->GetAsSignedInteger()) {
+            result = static_cast<IntType>(signed_value->GetValue());
             return true;
           }
+        } else {
+          if (auto unsigned_value = value_sp->GetAsUnsignedInteger()) {
+            result = static_cast<IntType>(unsigned_value->GetValue());
+            return true;
+          }
+        }
       }
       return false;
     }
 
     template <class IntType>
     bool GetValueForKeyAsInteger(llvm::StringRef key, IntType &result,
                                  IntType default_val) const {
       bool success = GetValueForKeyAsInteger<IntType>(key, result);
bool HasKey(llvm::StringRef key) const {
       return search != m_dict.end();
     }
 
     void AddItem(llvm::StringRef key, ObjectSP value_sp) {
       ConstString key_cs(key);
       m_dict[key_cs] = std::move(value_sp);
     }
 
-    void AddIntegerItem(llvm::StringRef key, uint64_t value) {
-      AddItem(key, std::make_shared<Integer>(value));
+    template <typename T> void AddIntegerItem(llvm::StringRef key, T value) {
+      static_assert(std::is_integral<T>::value ||
+                        std::is_floating_point<T>::value,
+                    "value type should be integral");
+      if constexpr (std::numeric_limits<T>::is_signed)
+        AddItem(key, std::make_shared<SignedInteger>(value));
+      else
+        AddItem(key, std::make_shared<UnsignedInteger>(value));
     }
 
     void AddFloatItem(llvm::StringRef key, double value) {
       AddItem(key, std::make_shared<Float>(value));
     }
 
     void AddStringItem(llvm::StringRef key, llvm::StringRef value) {
       AddItem(key, std::make_shared<String>(std::move(value)));

lldb/include/lldb/lldb-enumerations.h

 };
 
 enum StructuredDataType {
   eStructuredDataTypeInvalid = -1,
   eStructuredDataTypeNull = 0,
   eStructuredDataTypeGeneric,
   eStructuredDataTypeArray,
   eStructuredDataTypeInteger,
   eStructuredDataTypeFloat,
   eStructuredDataTypeBoolean,
   eStructuredDataTypeString,
-  eStructuredDataTypeDictionary
+  eStructuredDataTypeDictionary,
+  eStructuredDataTypeSignedInteger,
+  eStructuredDataTypeUnsignedInteger = eStructuredDataTypeInteger,
 };
 
 FLAGS_ENUM(TypeClass){
     eTypeClassInvalid = (0u), eTypeClassArray = (1u << 0),
     eTypeClassBlockPointer = (1u << 1), eTypeClassBuiltin = (1u << 2),
     eTypeClassClass = (1u << 3), eTypeClassComplexFloat = (1u << 4),
     eTypeClassComplexInteger = (1u << 5), eTypeClassEnumeration = (1u << 6),
     eTypeClassFunction = (1u << 7), eTypeClassMemberPointer = (1u << 8),

lldb/source/API/SBStructuredData.cpp

 //===-- SBStructuredData.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/API/SBStructuredData.h"
+#include "lldb/Core/StructuredDataImpl.h"
 #include "lldb/Utility/Instrumentation.h"
 
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBStringList.h"
-#include "lldb/Core/StructuredDataImpl.h"
 #include "lldb/Target/StructuredDataPlugin.h"
 #include "lldb/Utility/Event.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/StructuredData.h"
 
 using namespace lldb;
 using namespace lldb_private;
lldb::SBStructuredData SBStructuredData::GetItemAtIndex(size_t idx) const {
   SBStructuredData result;
   result.m_impl_up->SetObjectSP(m_impl_up->GetItemAtIndex(idx));
   return result;
 }
 
 uint64_t SBStructuredData::GetIntegerValue(uint64_t fail_value) const {
   LLDB_INSTRUMENT_VA(this, fail_value);
 
+  return GetUnsignedIntegerValue(fail_value);
+}
+
+uint64_t SBStructuredData::GetUnsignedIntegerValue(uint64_t fail_value) const {
+  LLDB_INSTRUMENT_VA(this, fail_value);
+
+  return m_impl_up->GetIntegerValue(fail_value);
+}
+
+int64_t SBStructuredData::GetSignedIntegerValue(int64_t fail_value) const {
+  LLDB_INSTRUMENT_VA(this, fail_value);
+
   return m_impl_up->GetIntegerValue(fail_value);
 }
 
 double SBStructuredData::GetFloatValue(double fail_value) const {
   LLDB_INSTRUMENT_VA(this, fail_value);
 
   return m_impl_up->GetFloatValue(fail_value);
 }

lldb/source/API/SBThread.cpp

if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) {
         StructuredData::ObjectSP node =
             info_root_sp->GetObjectForDotSeparatedPath(path);
         if (node) {
           if (node->GetType() == eStructuredDataTypeString) {
             strm.Printf("%s", node->GetAsString()->GetValue().str().c_str());
             success = true;
           }
           if (node->GetType() == eStructuredDataTypeInteger) {
-            strm.Printf("0x%" PRIx64, node->GetAsInteger()->GetValue());
+            strm.Printf("0x%" PRIx64, node->GetUnsignedIntegerValue());
             success = true;
           }
           if (node->GetType() == eStructuredDataTypeFloat) {
             strm.Printf("0x%f", node->GetAsFloat()->GetValue());
             success = true;
           }
           if (node->GetType() == eStructuredDataTypeBoolean) {
             if (node->GetAsBoolean()->GetValue())

lldb/source/Breakpoint/BreakpointOptions.cpp

 BreakpointOptions::~BreakpointOptions() = default;
 
 std::unique_ptr<BreakpointOptions> BreakpointOptions::CreateFromStructuredData(
     Target &target, const StructuredData::Dictionary &options_dict,
     Status &error) {
   bool enabled = true;
   bool one_shot = false;
   bool auto_continue = false;
-  int32_t ignore_count = 0;
+  uint32_t ignore_count = 0;
   llvm::StringRef condition_ref("");
   Flags set_options;
 
   const char *key = GetKey(OptionNames::EnabledState);
   bool success;
   if (key && options_dict.HasKey(key)) {
     success = options_dict.GetValueForKeyAsBoolean(key, enabled);
     if (!success) {

lldb/source/Breakpoint/BreakpointResolver.cpp

BreakpointResolverSP BreakpointResolver::CreateFromStructuredData(
   StructuredData::Dictionary *subclass_options = nullptr;
   success = resolver_dict.GetValueForKeyAsDictionary(
       GetSerializationSubclassOptionsKey(), subclass_options);
   if (!success || !subclass_options || !subclass_options->IsValid()) {
     error.SetErrorString("Resolver data missing subclass options key.");
     return result_sp;
   }
 
-  lldb::addr_t offset;
+  lldb::offset_t offset;
   success = subclass_options->GetValueForKeyAsInteger(
       GetKey(OptionNames::Offset), offset);
   if (!success) {
     error.SetErrorString("Resolver data missing offset options key.");
     return result_sp;
   }
 
   BreakpointResolver *resolver = nullptr;

lldb/source/Breakpoint/BreakpointResolverAddress.cpp

BreakpointResolverAddress::BreakpointResolverAddress(const BreakpointSP &bkpt,
                                                      const Address &addr)
     : BreakpointResolver(bkpt, BreakpointResolver::AddressResolver),
       m_addr(addr), m_resolved_addr(LLDB_INVALID_ADDRESS) {}
 
 BreakpointResolver *BreakpointResolverAddress::CreateFromStructuredData(
     const BreakpointSP &bkpt, const StructuredData::Dictionary &options_dict,
     Status &error) {
   llvm::StringRef module_name;
-  lldb::addr_t addr_offset;
+  lldb::offset_t addr_offset;
   FileSpec module_filespec;
   bool success;
 
   success = options_dict.GetValueForKeyAsInteger(
       GetKey(OptionNames::AddressOffset), addr_offset);
   if (!success) {
     error.SetErrorString("BRFL::CFSD: Couldn't find address offset entry.");
     return nullptr;

lldb/source/Breakpoint/BreakpointResolverName.cpp

if (success) {
     language = Language::GetLanguageTypeFromString(language_name);
     if (language == eLanguageTypeUnknown) {
       error.SetErrorStringWithFormatv("BRN::CFSD: Unknown language: {0}.",
                                       language_name);
       return nullptr;
     }
   }
 
-  lldb::addr_t offset = 0;
+  lldb::offset_t offset = 0;
   success =
       options_dict.GetValueForKeyAsInteger(GetKey(OptionNames::Offset), offset);
   if (!success) {
     error.SetErrorString("BRN::CFSD: Missing offset entry.");
     return nullptr;
   }
 
   bool skip_prologue;
if (m_regex.IsValid()) {
     options_dict_sp->AddStringItem(GetKey(OptionNames::RegexString),
                                    m_regex.GetText());
   } else {
     StructuredData::ArraySP names_sp(new StructuredData::Array());
     StructuredData::ArraySP name_masks_sp(new StructuredData::Array());
     for (auto lookup : m_lookups) {
       names_sp->AddItem(StructuredData::StringSP(
           new StructuredData::String(lookup.GetName().GetStringRef())));
-      name_masks_sp->AddItem(StructuredData::IntegerSP(
-          new StructuredData::Integer(lookup.GetNameTypeMask())));
+      name_masks_sp->AddItem(StructuredData::UnsignedIntegerSP(
+          new StructuredData::UnsignedInteger(lookup.GetNameTypeMask())));
     }
     options_dict_sp->AddItem(GetKey(OptionNames::SymbolNameArray), names_sp);
     options_dict_sp->AddItem(GetKey(OptionNames::NameMaskArray), name_masks_sp);
   }
   if (m_language != eLanguageTypeUnknown)
     options_dict_sp->AddStringItem(
         GetKey(OptionNames::LanguageName),
         Language::GetNameForLanguageType(m_language));

lldb/source/Core/FormatEntity.cpp

static bool FormatThreadExtendedInfoRecurse(
   StructuredData::ObjectSP value =
       thread_info_dictionary->GetObjectForDotSeparatedPath(path);
 
   if (value) {
     if (value->GetType() == eStructuredDataTypeInteger) {
       const char *token_format = "0x%4.4" PRIx64;
       if (!entry.printf_format.empty())
         token_format = entry.printf_format.c_str();
-      s.Printf(token_format, value->GetAsInteger()->GetValue());
+      s.Printf(token_format, value->GetUnsignedIntegerValue());
       return true;
     } else if (value->GetType() == eStructuredDataTypeFloat) {
       s.Printf("%f", value->GetAsFloat()->GetValue());
       return true;
     } else if (value->GetType() == eStructuredDataTypeString) {
       s.Format("{0}", value->GetAsString()->GetValue());
       return true;
     } else if (value->GetType() == eStructuredDataTypeArray) {

lldb/source/Host/common/XML.cpp

if (element_name == "array") {
     return dict_sp;
   } else if (element_name == "real") {
     double value = 0.0;
     node.GetElementTextAsFloat(value);
     return StructuredData::ObjectSP(new StructuredData::Float(value));
   } else if (element_name == "integer") {
     uint64_t value = 0;
     node.GetElementTextAsUnsigned(value, 0, 0);
-    return StructuredData::ObjectSP(new StructuredData::Integer(value));
+    return StructuredData::ObjectSP(new StructuredData::UnsignedInteger(value));
   } else if ((element_name == "string") || (element_name == "data") ||
              (element_name == "date")) {
     std::string text;
     node.GetElementText(text);
     return StructuredData::ObjectSP(
         new StructuredData::String(std::move(text)));
   } else if (element_name == "true") {
     return StructuredData::ObjectSP(new StructuredData::Boolean(true));

lldb/source/Interpreter/OptionGroupPythonClassWithDict.cpp

case 1: {
         error.SetErrorStringWithFormat("Key: \"%s\" missing value.",
                                         m_current_key.c_str());
     
   } break;
   case 2: {
       if (!m_dict_sp)
         m_dict_sp = std::make_shared<StructuredData::Dictionary>();
       if (!m_current_key.empty()) {
+        if (!option_arg.empty()) {
+          double d = 0;
+          std::string opt = option_arg.lower();
+
+          if (llvm::to_integer(option_arg, d)) {
+            if (opt[0] == '-')
+              m_dict_sp->AddIntegerItem(m_current_key, static_cast<int64_t>(d));
+            else
+              m_dict_sp->AddIntegerItem(m_current_key,
+                                        static_cast<uint64_t>(d));
+          } else if (llvm::to_float(option_arg, d)) {
+            m_dict_sp->AddFloatItem(m_current_key, d);
+          } else if (opt == "true" || opt == "false") {
+            m_dict_sp->AddBooleanItem(m_current_key, opt == "true");
+          } else {
             m_dict_sp->AddStringItem(m_current_key, option_arg);
-          m_current_key.clear();
+          }
+        }
+
       }
       else
         error.SetErrorStringWithFormat("Value: \"%s\" missing matching key.",
                                        option_arg.str().c_str());
   } break;
   default:
     llvm_unreachable("Unimplemented option");
   }

lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderDarwin.cpp

if (!image->HasKey("load_address") ||
         image->GetValueForKey("mach_header")->GetAsDictionary() == nullptr ||
         !image->HasKey("segments") ||
         image->GetValueForKey("segments")->GetAsArray() == nullptr ||
         !image->HasKey("uuid")) {
       return false;
     }
     // clang-format on
     image_infos[i].address =
-        image->GetValueForKey("load_address")->GetAsInteger()->GetValue();
+        image->GetValueForKey("load_address")->GetUnsignedIntegerValue();
     image_infos[i].file_spec.SetFile(
         image->GetValueForKey("pathname")->GetAsString()->GetValue(),
         FileSpec::Style::native);
 
     StructuredData::Dictionary *mh =
         image->GetValueForKey("mach_header")->GetAsDictionary();
     image_infos[i].header.magic =
-        mh->GetValueForKey("magic")->GetAsInteger()->GetValue();
+        mh->GetValueForKey("magic")->GetUnsignedIntegerValue();
     image_infos[i].header.cputype =
-        mh->GetValueForKey("cputype")->GetAsInteger()->GetValue();
+        mh->GetValueForKey("cputype")->GetUnsignedIntegerValue();
     image_infos[i].header.cpusubtype =
-        mh->GetValueForKey("cpusubtype")->GetAsInteger()->GetValue();
+        mh->GetValueForKey("cpusubtype")->GetUnsignedIntegerValue();
     image_infos[i].header.filetype =
-        mh->GetValueForKey("filetype")->GetAsInteger()->GetValue();
+        mh->GetValueForKey("filetype")->GetUnsignedIntegerValue();
 
     if (image->HasKey("min_version_os_name")) {
       std::string os_name =
           std::string(image->GetValueForKey("min_version_os_name")
                           ->GetAsString()
                           ->GetValue());
       if (os_name == "macosx")
         image_infos[i].os_type = llvm::Triple::MacOSX;
if (image->HasKey("min_version_os_sdk")) {
                           ->GetValue());
     }
 
     // Fields that aren't used by DynamicLoaderDarwin so debugserver doesn't
     // currently send them in the reply.
 
     if (mh->HasKey("flags"))
       image_infos[i].header.flags =
-          mh->GetValueForKey("flags")->GetAsInteger()->GetValue();
+          mh->GetValueForKey("flags")->GetUnsignedIntegerValue();
     else
       image_infos[i].header.flags = 0;
 
     if (mh->HasKey("ncmds"))
       image_infos[i].header.ncmds =
-          mh->GetValueForKey("ncmds")->GetAsInteger()->GetValue();
+          mh->GetValueForKey("ncmds")->GetUnsignedIntegerValue();
     else
       image_infos[i].header.ncmds = 0;
 
     if (mh->HasKey("sizeofcmds"))
       image_infos[i].header.sizeofcmds =
-          mh->GetValueForKey("sizeofcmds")->GetAsInteger()->GetValue();
+          mh->GetValueForKey("sizeofcmds")->GetUnsignedIntegerValue();
     else
       image_infos[i].header.sizeofcmds = 0;
 
     StructuredData::Array *segments =
         image->GetValueForKey("segments")->GetAsArray();
     uint32_t segcount = segments->GetSize();
     for (size_t j = 0; j < segcount; j++) {
       Segment segment;
       StructuredData::Dictionary *seg =
           segments->GetItemAtIndex(j)->GetAsDictionary();
       segment.name =
           ConstString(seg->GetValueForKey("name")->GetAsString()->GetValue());
-      segment.vmaddr =
-          seg->GetValueForKey("vmaddr")->GetAsInteger()->GetValue();
-      segment.vmsize =
-          seg->GetValueForKey("vmsize")->GetAsInteger()->GetValue();
+      segment.vmaddr = seg->GetValueForKey("vmaddr")->GetUnsignedIntegerValue();
+      segment.vmsize = seg->GetValueForKey("vmsize")->GetUnsignedIntegerValue();
       segment.fileoff =
-          seg->GetValueForKey("fileoff")->GetAsInteger()->GetValue();
+          seg->GetValueForKey("fileoff")->GetUnsignedIntegerValue();
       segment.filesize =
-          seg->GetValueForKey("filesize")->GetAsInteger()->GetValue();
+          seg->GetValueForKey("filesize")->GetUnsignedIntegerValue();
       segment.maxprot =
-          seg->GetValueForKey("maxprot")->GetAsInteger()->GetValue();
+          seg->GetValueForKey("maxprot")->GetUnsignedIntegerValue();
 
       // Fields that aren't used by DynamicLoaderDarwin so debugserver doesn't
       // currently send them in the reply.
 
       if (seg->HasKey("initprot"))
         segment.initprot =
-            seg->GetValueForKey("initprot")->GetAsInteger()->GetValue();
+            seg->GetValueForKey("initprot")->GetUnsignedIntegerValue();
       else
         segment.initprot = 0;
 
       if (seg->HasKey("flags"))
-        segment.flags =
-            seg->GetValueForKey("flags")->GetAsInteger()->GetValue();
+        segment.flags = seg->GetValueForKey("flags")->GetUnsignedIntegerValue();
       else
         segment.flags = 0;
 
       if (seg->HasKey("nsects"))
         segment.nsects =
-            seg->GetValueForKey("nsects")->GetAsInteger()->GetValue();
+            seg->GetValueForKey("nsects")->GetUnsignedIntegerValue();
       else
         segment.nsects = 0;
 
       image_infos[i].segments.push_back(segment);
     }
 
     image_infos[i].uuid.SetFromStringRef(
         image->GetValueForKey("uuid")->GetAsString()->GetValue());

lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOS.cpp

if (m_process) {
     // {"shared_cache_base_address":140735683125248,"shared_cache_uuid
     // ":"DDB8D70C-
     // C9A2-3561-B2C8-BE48A4F33F96","no_shared_cache":false,"shared_cache_private_cache":false}
 
     if (info_dict && info_dict->HasKey("shared_cache_uuid") &&
         info_dict->HasKey("no_shared_cache") &&
         info_dict->HasKey("shared_cache_base_address")) {
       base_address = info_dict->GetValueForKey("shared_cache_base_address")
-                         ->GetIntegerValue(LLDB_INVALID_ADDRESS);
+                         ->GetUnsignedIntegerValue(LLDB_INVALID_ADDRESS);
       std::string uuid_str = std::string(
           info_dict->GetValueForKey("shared_cache_uuid")->GetStringValue());
       if (!uuid_str.empty())
         uuid.SetFromStringRef(uuid_str);
       if (!info_dict->GetValueForKey("no_shared_cache")->GetBooleanValue())
         using_shared_cache = eLazyBoolYes;
       else
         using_shared_cache = eLazyBoolNo;

lldb/source/Plugins/InstrumentationRuntime/MainThreadChecker/InstrumentationRuntimeMainThreadChecker.cpp

for (unsigned I = 0; I < thread_sp->GetStackFrameCount(); ++I) {
     if (addr.GetModule() == runtime_module_sp) // Skip PCs from the runtime.
       continue;
 
     // The first non-runtime frame is responsible for the bug.
     if (!responsible_frame)
       responsible_frame = frame;
 
     lldb::addr_t PC = addr.GetLoadAddress(&target);
-    trace->AddItem(StructuredData::ObjectSP(new StructuredData::Integer(PC)));
+    trace->AddIntegerItem(PC);
   }
 
   auto *d = new StructuredData::Dictionary();
   auto dict_sp = StructuredData::ObjectSP(d);
   d->AddStringItem("instrumentation_class", "MainThreadChecker");
   d->AddStringItem("api_name", apiName);
   d->AddStringItem("class_name", className);
   d->AddStringItem("selector", selector);
InstrumentationRuntimeMainThreadChecker::GetBacktracesFromExtendedStopInfo(
 
   if (info->GetObjectForDotSeparatedPath("instrumentation_class")
           ->GetStringValue() != "MainThreadChecker")
     return threads;
 
   std::vector<lldb::addr_t> PCs;
   auto trace = info->GetObjectForDotSeparatedPath("trace")->GetAsArray();
   trace->ForEach([&PCs](StructuredData::Object *PC) -> bool {
-    PCs.push_back(PC->GetAsInteger()->GetValue());
+    PCs.push_back(PC->GetUnsignedIntegerValue());
     return true;
   });
 
   if (PCs.empty())
     return threads;
 
   StructuredData::ObjectSP thread_id_obj =
       info->GetObjectForDotSeparatedPath("tid");
-  tid_t tid = thread_id_obj ? thread_id_obj->GetIntegerValue() : 0;
+  tid_t tid = thread_id_obj ? thread_id_obj->GetUnsignedIntegerValue() : 0;
 
   // We gather symbolication addresses above, so no need for HistoryThread to
   // try to infer the call addresses.
   bool pcs_are_call_addresses = true;
   ThreadSP new_thread_sp = std::make_shared<HistoryThread>(
       *process_sp, tid, PCs, pcs_are_call_addresses);
 
   // Save this in the Process' ExtendedThreadList so a strong pointer retains
   // the object
   process_sp->GetExtendedThreadList().AddThread(new_thread_sp);
   threads->AddThread(new_thread_sp);
 
   return threads;
 }

lldb/source/Plugins/InstrumentationRuntime/TSan/InstrumentationRuntimeTSan.cpp

CreateStackTrace(ValueObjectSP o,
   ValueObjectSP trace_value_object =
       o->GetValueForExpressionPath(trace_item_name.c_str());
   size_t count = trace_value_object->GetNumChildren();
   for (size_t j = 0; j < count; j++) {
     addr_t trace_addr =
         trace_value_object->GetChildAtIndex(j, true)->GetValueAsUnsigned(0);
     if (trace_addr == 0)
       break;
-    trace_sp->AddItem(std::make_shared<StructuredData::Integer>(trace_addr));
+    trace_sp->AddIntegerItem(trace_addr);
   }
   return trace_sp;
 }
 
 static StructuredData::ArraySP ConvertToStructuredArray(
     ValueObjectSP return_value_sp, const std::string &items_name,
     const std::string &count_name,
     std::function<void(const ValueObjectSP &o,
std::string object_type = std::string(loc->GetAsDictionary()
                                               ->GetValueForKey("object_type")
                                               ->GetAsString()
                                               ->GetValue());
     if (!object_type.empty()) {
       summary = "Race on " + object_type + " object";
     }
     addr_t addr = loc->GetAsDictionary()
                       ->GetValueForKey("address")
-                      ->GetAsInteger()
-                      ->GetValue();
+                      ->GetUnsignedIntegerValue();
     if (addr == 0)
       addr = loc->GetAsDictionary()
                  ->GetValueForKey("start")
-                 ->GetAsInteger()
-                 ->GetValue();
+                 ->GetUnsignedIntegerValue();
 
     if (addr != 0) {
       std::string global_name = GetSymbolNameFromAddress(process_sp, addr);
       if (!global_name.empty()) {
         summary = summary + " at " + global_name;
       } else {
         summary = summary + " at " + Sprintf("0x%llx", addr);
       }
     } else {
       int fd = loc->GetAsDictionary()
                    ->GetValueForKey("file_descriptor")
-                   ->GetAsInteger()
-                   ->GetValue();
+                   ->GetSignedIntegerValue();
       if (fd != 0) {
         summary = summary + " on file descriptor " + Sprintf("%d", fd);
       }
     }
   }
 
   return summary;
 }
 
 addr_t InstrumentationRuntimeTSan::GetMainRacyAddress(
     StructuredData::ObjectSP report) {
   addr_t result = (addr_t)-1;
 
   report->GetObjectForDotSeparatedPath("mops")->GetAsArray()->ForEach(
       [&result](StructuredData::Object *o) -> bool {
-        addr_t addr =
-            o->GetObjectForDotSeparatedPath("address")->GetIntegerValue();
+        addr_t addr = o->GetObjectForDotSeparatedPath("address")
+                          ->GetUnsignedIntegerValue();
         if (addr < result)
           result = addr;
         return true;
       });
 
   return (result == (addr_t)-1) ? 0 : result;
 }
 
StructuredData::ObjectSP loc = report->GetAsDictionary()
                                        ->GetValueForKey("locs")
                                        ->GetAsArray()
                                        ->GetItemAtIndex(0);
     std::string type = std::string(
         loc->GetAsDictionary()->GetValueForKey("type")->GetStringValue());
     if (type == "global") {
       global_addr = loc->GetAsDictionary()
                         ->GetValueForKey("address")
-                        ->GetAsInteger()
-                        ->GetValue();
+                        ->GetUnsignedIntegerValue();
+
       global_name = GetSymbolNameFromAddress(process_sp, global_addr);
       if (!global_name.empty()) {
         result = Sprintf("'%s' is a global variable (0x%llx)",
                          global_name.c_str(), global_addr);
       } else {
         result = Sprintf("0x%llx is a global variable", global_addr);
       }
 
       Declaration decl;
       GetSymbolDeclarationFromAddress(process_sp, global_addr, decl);
       if (decl.GetFile()) {
         filename = decl.GetFile().GetPath();
         line = decl.GetLine();
       }
     } else if (type == "heap") {
       addr_t addr = loc->GetAsDictionary()
                         ->GetValueForKey("start")
-                        ->GetAsInteger()
-                        ->GetValue();
-      long size = loc->GetAsDictionary()
+                        ->GetUnsignedIntegerValue();
+
+      size_t size = loc->GetAsDictionary()
                         ->GetValueForKey("size")
-                      ->GetAsInteger()
-                      ->GetValue();
+                        ->GetUnsignedIntegerValue();
+
       std::string object_type = std::string(loc->GetAsDictionary()
                                                 ->GetValueForKey("object_type")
                                                 ->GetAsString()
                                                 ->GetValue());
       if (!object_type.empty()) {
         result = Sprintf("Location is a %ld-byte %s object at 0x%llx", size,
                          object_type.c_str(), addr);
       } else {
         result =
             Sprintf("Location is a %ld-byte heap object at 0x%llx", size, addr);
       }
     } else if (type == "stack") {
-      int tid = loc->GetAsDictionary()
+      tid_t tid = loc->GetAsDictionary()
                       ->GetValueForKey("thread_id")
-                    ->GetAsInteger()
-                    ->GetValue();
+                      ->GetUnsignedIntegerValue();
+
       result = Sprintf("Location is stack of thread %d", tid);
     } else if (type == "tls") {
-      int tid = loc->GetAsDictionary()
+      tid_t tid = loc->GetAsDictionary()
                       ->GetValueForKey("thread_id")
-                    ->GetAsInteger()
-                    ->GetValue();
+                      ->GetUnsignedIntegerValue();
+
       result = Sprintf("Location is TLS of thread %d", tid);
     } else if (type == "fd") {
       int fd = loc->GetAsDictionary()
                    ->GetValueForKey("file_descriptor")
-                   ->GetAsInteger()
-                   ->GetValue();
+                   ->GetSignedIntegerValue();
+
       result = Sprintf("Location is file descriptor %d", fd);
     }
   }
 
   return result;
 }
 
 bool InstrumentationRuntimeTSan::NotifyBreakpointHit(
if (location_filename != "") {
                                                location_filename);
       report->GetAsDictionary()->AddIntegerItem("location_line", location_line);
     }
 
     bool all_addresses_are_same = true;
     report->GetObjectForDotSeparatedPath("mops")->GetAsArray()->ForEach(
         [&all_addresses_are_same,
          main_address](StructuredData::Object *o) -> bool {
-          addr_t addr =
-              o->GetObjectForDotSeparatedPath("address")->GetIntegerValue();
+          addr_t addr = o->GetObjectForDotSeparatedPath("address")
+                            ->GetUnsignedIntegerValue();
           if (main_address != addr)
             all_addresses_are_same = false;
           return true;
         });
     report->GetAsDictionary()->AddBooleanItem("all_addresses_are_same",
                                               all_addresses_are_same);
   }
 
void InstrumentationRuntimeTSan::Deactivate() {
   SetActive(false);
 }
 static std::string GenerateThreadName(const std::string &path,
                                       StructuredData::Object *o,
                                       StructuredData::ObjectSP main_info) {
   std::string result = "additional information";
 
   if (path == "mops") {
-    int size = o->GetObjectForDotSeparatedPath("size")->GetIntegerValue();
-    int thread_id =
-        o->GetObjectForDotSeparatedPath("thread_id")->GetIntegerValue();
+    size_t size =
+        o->GetObjectForDotSeparatedPath("size")->GetUnsignedIntegerValue();
+    tid_t thread_id =
+        o->GetObjectForDotSeparatedPath("thread_id")->GetUnsignedIntegerValue();
     bool is_write =
         o->GetObjectForDotSeparatedPath("is_write")->GetBooleanValue();
     bool is_atomic =
         o->GetObjectForDotSeparatedPath("is_atomic")->GetBooleanValue();
-    addr_t addr = o->GetObjectForDotSeparatedPath("address")->GetIntegerValue();
+    addr_t addr =
+        o->GetObjectForDotSeparatedPath("address")->GetUnsignedIntegerValue();
 
     std::string addr_string = Sprintf(" at 0x%llx", addr);
 
     if (main_info->GetObjectForDotSeparatedPath("all_addresses_are_same")
             ->GetBooleanValue()) {
       addr_string = "";
     }
 
     if (main_info->GetObjectForDotSeparatedPath("issue_type")
             ->GetStringValue() == "external-race") {
       result = Sprintf("%s access by thread %d",
                        is_write ? "mutating" : "read-only", thread_id);
     } else if (main_info->GetObjectForDotSeparatedPath("issue_type")
                    ->GetStringValue() == "swift-access-race") {
       result = Sprintf("modifying access by thread %d", thread_id);
     } else {
-      result = Sprintf("%s%s of size %d%s by thread %d",
+      result = Sprintf("%s%s of size %zu%s by thread %" PRIu64,
                        is_atomic ? "atomic " : "", is_write ? "write" : "read",
                        size, addr_string.c_str(), thread_id);
     }
   }
 
   if (path == "threads") {
-    int thread_id =
-        o->GetObjectForDotSeparatedPath("thread_id")->GetIntegerValue();
-    result = Sprintf("Thread %d created", thread_id);
+    tid_t thread_id =
+        o->GetObjectForDotSeparatedPath("thread_id")->GetUnsignedIntegerValue();
+    result = Sprintf("Thread %zu created", thread_id);
   }
 
   if (path == "locs") {
     std::string type = std::string(
         o->GetAsDictionary()->GetValueForKey("type")->GetStringValue());
-    int thread_id =
-        o->GetObjectForDotSeparatedPath("thread_id")->GetIntegerValue();
-    int fd =
-        o->GetObjectForDotSeparatedPath("file_descriptor")->GetIntegerValue();
+    tid_t thread_id =
+        o->GetObjectForDotSeparatedPath("thread_id")->GetUnsignedIntegerValue();
+    int fd = o->GetObjectForDotSeparatedPath("file_descriptor")
+                 ->GetSignedIntegerValue();
     if (type == "heap") {
-      result = Sprintf("Heap block allocated by thread %d", thread_id);
+      result = Sprintf("Heap block allocated by thread %" PRIu64, thread_id);
     } else if (type == "fd") {
-      result =
-          Sprintf("File descriptor %d created by thread %t", fd, thread_id);
+      result = Sprintf("File descriptor %d created by thread %" PRIu64, fd,
+                       thread_id);
     }
   }
 
   if (path == "mutexes") {
     int mutex_id =
-        o->GetObjectForDotSeparatedPath("mutex_id")->GetIntegerValue();
+        o->GetObjectForDotSeparatedPath("mutex_id")->GetSignedIntegerValue();
 
     result = Sprintf("Mutex M%d created", mutex_id);
   }
 
   if (path == "stacks") {
-    int thread_id =
-        o->GetObjectForDotSeparatedPath("thread_id")->GetIntegerValue();
-    result = Sprintf("Thread %d", thread_id);
+    tid_t thread_id =
+        o->GetObjectForDotSeparatedPath("thread_id")->GetUnsignedIntegerValue();
+    result = Sprintf("Thread %" PRIu64, thread_id);
   }
 
   result[0] = toupper(result[0]);
 
   return result;
 }
 
 static void AddThreadsForPath(const std::string &path,
                               ThreadCollectionSP threads, ProcessSP process_sp,
                               StructuredData::ObjectSP info) {
   info->GetObjectForDotSeparatedPath(path)->GetAsArray()->ForEach(
       [process_sp, threads, path, info](StructuredData::Object *o) -> bool {
         std::vector<lldb::addr_t> pcs;
         o->GetObjectForDotSeparatedPath("trace")->GetAsArray()->ForEach(
             [&pcs](StructuredData::Object *pc) -> bool {
-              pcs.push_back(pc->GetAsInteger()->GetValue());
+              pcs.push_back(pc->GetUnsignedIntegerValue());
               return true;
             });
 
         if (pcs.size() == 0)
           return true;
 
         StructuredData::ObjectSP thread_id_obj =
             o->GetObjectForDotSeparatedPath("thread_os_id");
-        tid_t tid = thread_id_obj ? thread_id_obj->GetIntegerValue() : 0;
+        tid_t tid =
+            thread_id_obj ? thread_id_obj->GetUnsignedIntegerValue() : 0;
 
         ThreadSP new_thread_sp =
             std::make_shared<HistoryThread>(*process_sp, tid, pcs);
         new_thread_sp->SetName(GenerateThreadName(path, o, info).c_str());
 
         // Save this in the Process' ExtendedThreadList so a strong pointer
         // retains the object
         process_sp->GetExtendedThreadList().AddThread(new_thread_sp);

lldb/source/Plugins/InstrumentationRuntime/UBSan/InstrumentationRuntimeUBSan.cpp

StructuredData::ObjectSP InstrumentationRuntimeUBSan::RetrieveReportData(
   auto trace_sp = StructuredData::ObjectSP(trace);
   for (unsigned I = 0; I < thread_sp->GetStackFrameCount(); ++I) {
     const Address FCA = thread_sp->GetStackFrameAtIndex(I)
                             ->GetFrameCodeAddressForSymbolication();
     if (FCA.GetModule() == runtime_module_sp) // Skip PCs from the runtime.
       continue;
 
     lldb::addr_t PC = FCA.GetLoadAddress(&target);
-    trace->AddItem(StructuredData::ObjectSP(new StructuredData::Integer(PC)));
+    trace->AddIntegerItem(PC);
   }
 
   std::string IssueKind = RetrieveString(main_value, process_sp, ".issue_kind");
   std::string ErrMessage = RetrieveString(main_value, process_sp, ".message");
   std::string Filename = RetrieveString(main_value, process_sp, ".filename");
   unsigned Line = RetrieveUnsigned(main_value, process_sp, ".line");
   unsigned Col = RetrieveUnsigned(main_value, process_sp, ".col");
   uintptr_t MemoryAddr =
InstrumentationRuntimeUBSan::GetBacktracesFromExtendedStopInfo(
 
   if (info->GetObjectForDotSeparatedPath("instrumentation_class")
           ->GetStringValue() != "UndefinedBehaviorSanitizer")
     return threads;
 
   std::vector<lldb::addr_t> PCs;
   auto trace = info->GetObjectForDotSeparatedPath("trace")->GetAsArray();
   trace->ForEach([&PCs](StructuredData::Object *PC) -> bool {
-    PCs.push_back(PC->GetAsInteger()->GetValue());
+    PCs.push_back(PC->GetUnsignedIntegerValue());
     return true;
   });
 
   if (PCs.empty())
     return threads;
 
   StructuredData::ObjectSP thread_id_obj =
       info->GetObjectForDotSeparatedPath("tid");
-  tid_t tid = thread_id_obj ? thread_id_obj->GetIntegerValue() : 0;
+  tid_t tid = thread_id_obj ? thread_id_obj->GetUnsignedIntegerValue() : 0;
 
   // We gather symbolication addresses above, so no need for HistoryThread to
   // try to infer the call addresses.
   bool pcs_are_call_addresses = true;
   ThreadSP new_thread_sp = std::make_shared<HistoryThread>(
       *process_sp, tid, PCs, pcs_are_call_addresses);
   std::string stop_reason_description = GetStopReasonDescription(info);
   new_thread_sp->SetName(stop_reason_description.c_str());
 
   // Save this in the Process' ExtendedThreadList so a strong pointer retains
   // the object
   process_sp->GetExtendedThreadList().AddThread(new_thread_sp);
   threads->AddThread(new_thread_sp);
 
   return threads;
 }

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp

lldb::addr_t AppleObjCRuntimeV2::GetSharedCacheBaseAddress() {
   if (!info_dict)
     return LLDB_INVALID_ADDRESS;
 
   StructuredData::ObjectSP value =
       info_dict->GetValueForKey("shared_cache_base_address");
   if (!value)
     return LLDB_INVALID_ADDRESS;
 
-  return value->GetIntegerValue(LLDB_INVALID_ADDRESS);
+  return value->GetUnsignedIntegerValue(LLDB_INVALID_ADDRESS);
 }
 
 void AppleObjCRuntimeV2::UpdateISAToDescriptorMapIfNeeded() {
   LLDB_SCOPED_TIMER();
 
   Log *log = GetLog(LLDBLog::Process | LLDBLog::Types);
 
   // Else we need to check with our process to see when the map was updated.

lldb/source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.cpp

bool done = array_sp->ForEach(
         if (!object || !object->IsValid())
           return false;
 
         auto dict = object->GetAsDictionary();
         if (!dict || !dict->IsValid())
           return false;
 
         // Signal number and signal name are required.
-        int signo;
+        uint64_t signo;
         if (!dict->GetValueForKeyAsInteger("signo", signo))
           return false;
 
         llvm::StringRef name;
         if (!dict->GetValueForKeyAsString("name", name))
           return false;
 
         // We can live without short_name, description, etc.

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp

size_t GDBRemoteCommunicationClient::QueryGDBServer(
   for (size_t i = 0, count = array->GetSize(); i < count; ++i) {
     StructuredData::Dictionary *element = nullptr;
     if (!array->GetItemAtIndexAsDictionary(i, element))
       continue;
 
     uint16_t port = 0;
     if (StructuredData::ObjectSP port_osp =
             element->GetValueForKey(llvm::StringRef("port")))
-      port = port_osp->GetIntegerValue(0);
+      port = port_osp->GetUnsignedIntegerValue(0);
 
     std::string socket_name;
     if (StructuredData::ObjectSP socket_name_osp =
             element->GetValueForKey(llvm::StringRef("socket_name")))
       socket_name = std::string(socket_name_osp->GetStringValue());
 
     if (port != 0 || !socket_name.empty())
       connection_urls.emplace_back(port, socket_name);

lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

if (target_definition_sp) {
           }
         }
       }
       m_breakpoint_pc_offset = 0;
       StructuredData::ObjectSP breakpoint_pc_offset_value =
           target_definition_sp->GetValueForKey("breakpoint-pc-offset");
       if (breakpoint_pc_offset_value) {
         if (auto breakpoint_pc_int_value =
-                breakpoint_pc_offset_value->GetAsInteger())
+                breakpoint_pc_offset_value->GetAsSignedInteger())
           m_breakpoint_pc_offset = breakpoint_pc_int_value->GetValue();
       }
 
       if (m_register_info_sp->SetRegisterInfo(
               *target_definition_sp, GetTarget().GetArchitecture()) > 0) {
         return true;
       }
     }
thread_dict->ForEach([this, &tid, &expedited_register_map, &thread_name,
                         &signo, &reason, &description, &exc_type, &exc_data,
                         &thread_dispatch_qaddr, &queue_vars_valid,
                         &associated_with_dispatch_queue, &dispatch_queue_t,
                         &queue_name, &queue_kind, &queue_serial_number](
                            ConstString key,
                            StructuredData::Object *object) -> bool {
     if (key == g_key_tid) {
       // thread in big endian hex
-      tid = object->GetIntegerValue(LLDB_INVALID_THREAD_ID);
+      tid = object->GetUnsignedIntegerValue(LLDB_INVALID_THREAD_ID);
     } else if (key == g_key_metype) {
       // exception type in big endian hex
-      exc_type = object->GetIntegerValue(0);
+      exc_type = object->GetUnsignedIntegerValue(0);
     } else if (key == g_key_medata) {
       // exception data in big endian hex
       StructuredData::Array *array = object->GetAsArray();
       if (array) {
         array->ForEach([&exc_data](StructuredData::Object *object) -> bool {
-          exc_data.push_back(object->GetIntegerValue());
+          exc_data.push_back(object->GetUnsignedIntegerValue());
           return true; // Keep iterating through all array items
         });
       }
     } else if (key == g_key_name) {
       thread_name = std::string(object->GetStringValue());
     } else if (key == g_key_qaddr) {
-      thread_dispatch_qaddr = object->GetIntegerValue(LLDB_INVALID_ADDRESS);
+      thread_dispatch_qaddr =
+          object->GetUnsignedIntegerValue(LLDB_INVALID_ADDRESS);
     } else if (key == g_key_queue_name) {
       queue_vars_valid = true;
       queue_name = std::string(object->GetStringValue());
     } else if (key == g_key_queue_kind) {
       std::string queue_kind_str = std::string(object->GetStringValue());
       if (queue_kind_str == "serial") {
         queue_vars_valid = true;
         queue_kind = eQueueKindSerial;
       } else if (queue_kind_str == "concurrent") {
         queue_vars_valid = true;
         queue_kind = eQueueKindConcurrent;
       }
     } else if (key == g_key_queue_serial_number) {
-      queue_serial_number = object->GetIntegerValue(0);
+      queue_serial_number = object->GetUnsignedIntegerValue(0);
       if (queue_serial_number != 0)
         queue_vars_valid = true;
     } else if (key == g_key_dispatch_queue_t) {
-      dispatch_queue_t = object->GetIntegerValue(0);
+      dispatch_queue_t = object->GetUnsignedIntegerValue(0);
       if (dispatch_queue_t != 0 && dispatch_queue_t != LLDB_INVALID_ADDRESS)
         queue_vars_valid = true;
     } else if (key == g_key_associated_with_dispatch_queue) {
       queue_vars_valid = true;
       bool associated = object->GetBooleanValue();
       if (associated)
         associated_with_dispatch_queue = eLazyBoolYes;
       else
if (key == g_key_tid) {
               }
             }
           }
           return true; // Keep iterating through all array items
         });
       }
 
     } else if (key == g_key_signal)
-      signo = object->GetIntegerValue(LLDB_INVALID_SIGNAL_NUMBER);
+      signo = object->GetUnsignedIntegerValue(LLDB_INVALID_SIGNAL_NUMBER);
     return true; // Keep iterating through all dictionary key/value pairs
   });
 
   return SetThreadStopInfo(tid, expedited_register_map, signo, thread_name,
                            reason, description, exc_type, exc_data,
                            thread_dispatch_qaddr, queue_vars_valid,
                            associated_with_dispatch_queue, dispatch_queue_t,
                            queue_name, queue_kind, queue_serial_number);
StructuredData::ObjectSP ProcessGDBRemote::GetLoadedDynamicLibrariesInfos() {
   return GetLoadedDynamicLibrariesInfos_sender(args_dict);
 }
 
 StructuredData::ObjectSP ProcessGDBRemote::GetLoadedDynamicLibrariesInfos(
     const std::vector<lldb::addr_t> &load_addresses) {
   StructuredData::ObjectSP args_dict(new StructuredData::Dictionary());
   StructuredData::ArraySP addresses(new StructuredData::Array);
 
-  for (auto addr : load_addresses) {
-    StructuredData::ObjectSP addr_sp(new StructuredData::Integer(addr));
-    addresses->AddItem(addr_sp);
-  }
+  for (auto addr : load_addresses)
+    addresses->AddIntegerItem(addr);
 
   args_dict->GetAsDictionary()->AddItem("solib_addresses", addresses);
 
   return GetLoadedDynamicLibrariesInfos_sender(args_dict);
 }
 
 StructuredData::ObjectSP
 ProcessGDBRemote::GetLoadedDynamicLibrariesInfos_sender(

lldb/source/Plugins/Process/scripted/ScriptedProcess.cpp

auto reload_image = [&target, &module_list, &error_with_message](
 
     ModuleSP module_sp =
         target.GetOrCreateModule(module_spec, true /* notify */);
 
     if (!module_sp)
       return error_with_message("Couldn't create or get module.");
 
     lldb::addr_t load_addr = LLDB_INVALID_ADDRESS;
-    lldb::addr_t slide = LLDB_INVALID_OFFSET;
+    lldb::offset_t slide = LLDB_INVALID_OFFSET;
     dict->GetValueForKeyAsInteger("load_addr", load_addr);
     dict->GetValueForKeyAsInteger("slide", slide);
     if (load_addr == LLDB_INVALID_ADDRESS)
       return error_with_message(
           "Couldn't get valid load address or slide offset.");
 
     if (slide != LLDB_INVALID_OFFSET)
       load_addr += slide;

lldb/source/Plugins/Process/scripted/ScriptedThread.cpp

if (data_dict->GetValueForKeyAsDictionary("mach_exception",
       llvm::SmallVector<uint64_t, 3> raw_codes;
 
       StructuredData::Array *exc_rawcodes;
       mach_exception->GetValueForKeyAsArray("rawCodes", exc_rawcodes);
       if (exc_rawcodes) {
         auto fetch_data = [&raw_codes](StructuredData::Object *obj) {
           if (!obj)
             return false;
-          raw_codes.push_back(obj->GetIntegerValue());
+          raw_codes.push_back(obj->GetUnsignedIntegerValue());
           return true;
         };
 
         exc_rawcodes->ForEach(fetch_data);
         exc_data_size = raw_codes.size();
       }
 
       stop_info_sp = StopInfoMachException::CreateStopReasonWithMachException(

lldb/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.h

llvm::Expected<bool> IsTrue() {
     int r = PyObject_IsTrue(m_py_obj);
     if (r < 0)
       return exception();
     return !!r;
   }
 
   llvm::Expected<long long> AsLongLong() const;
 
-  llvm::Expected<long long> AsUnsignedLongLong() const;
+  llvm::Expected<unsigned long long> AsUnsignedLongLong() const;
 
   // wraps on overflow, instead of raising an error.
   llvm::Expected<unsigned long long> AsModuloUnsignedLongLong() const;
 
   llvm::Expected<bool> IsInstance(const PythonObject &cls) {
     if (!m_py_obj || !cls.IsValid())
       return nullDeref();
     int r = PyObject_IsInstance(m_py_obj, cls.get());
public:
 
   explicit PythonInteger(int64_t value);
 
   static bool Check(PyObject *py_obj);
 
   void SetInteger(int64_t value);
 
   StructuredData::IntegerSP CreateStructuredInteger() const;
+
+  StructuredData::UnsignedIntegerSP CreateStructuredUnsignedInteger() const;
+
+  StructuredData::SignedIntegerSP CreateStructuredSignedInteger() const;
 };
 
 class PythonBoolean : public TypedPythonObject<PythonBoolean> {
 public:
   using TypedPythonObject::TypedPythonObject;
 
   explicit PythonBoolean(bool value);
 

lldb/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.cpp

 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Stream.h"
 
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/Errno.h"
 
 #include <cstdio>
+#include <variant>
 
 using namespace lldb_private;
 using namespace lldb;
 using namespace lldb_private::python;
 using llvm::cantFail;
 using llvm::Error;
 using llvm::Expected;
 using llvm::Twine;
if (!m_py_obj)
     return nullDeref();
   assert(!PyErr_Occurred());
   long long r = PyLong_AsLongLong(m_py_obj);
   if (PyErr_Occurred())
     return exception();
   return r;
 }
 
-Expected<long long> PythonObject::AsUnsignedLongLong() const {
+Expected<unsigned long long> PythonObject::AsUnsignedLongLong() const {
   if (!m_py_obj)
     return nullDeref();
   assert(!PyErr_Occurred());
   long long r = PyLong_AsUnsignedLongLong(m_py_obj);
   if (PyErr_Occurred())
     return exception();
   return r;
 }
 
 // wraps on overflow, instead of raising an error.
 Expected<unsigned long long> PythonObject::AsModuloUnsignedLongLong() const {
   if (!m_py_obj)
     return nullDeref();
   assert(!PyErr_Occurred());
   unsigned long long r = PyLong_AsUnsignedLongLongMask(m_py_obj);
+  // FIXME: We should fetch the exception message and hoist it.
   if (PyErr_Occurred())
     return exception();
   return r;
 }
 
 void StructuredPythonObject::Serialize(llvm::json::OStream &s) const {
   s.value(llvm::formatv("Python Obj: {0:X}", GetValue()).str());
 }
StructuredData::ObjectSP PythonObject::CreateStructuredObject() const {
   assert(PyGILState_Check());
   switch (GetObjectType()) {
   case PyObjectType::Dictionary:
     return PythonDictionary(PyRefType::Borrowed, m_py_obj)
         .CreateStructuredDictionary();
   case PyObjectType::Boolean:
     return PythonBoolean(PyRefType::Borrowed, m_py_obj)
         .CreateStructuredBoolean();
-  case PyObjectType::Integer:
-    return PythonInteger(PyRefType::Borrowed, m_py_obj)
-        .CreateStructuredInteger();
+  case PyObjectType::Integer: {
+    StructuredData::IntegerSP int_sp =
+        PythonInteger(PyRefType::Borrowed, m_py_obj).CreateStructuredInteger();
+    if (std::holds_alternative<StructuredData::UnsignedIntegerSP>(int_sp))
+      return std::get<StructuredData::UnsignedIntegerSP>(int_sp);
+    if (std::holds_alternative<StructuredData::SignedIntegerSP>(int_sp))
+      return std::get<StructuredData::SignedIntegerSP>(int_sp);
+    return nullptr;
+  };
   case PyObjectType::List:
     return PythonList(PyRefType::Borrowed, m_py_obj).CreateStructuredArray();
   case PyObjectType::String:
     return PythonString(PyRefType::Borrowed, m_py_obj).CreateStructuredString();
   case PyObjectType::Bytes:
     return PythonBytes(PyRefType::Borrowed, m_py_obj).CreateStructuredString();
   case PyObjectType::ByteArray:
     return PythonByteArray(PyRefType::Borrowed, m_py_obj)
bool PythonInteger::Check(PyObject *py_obj) {
   return PyLong_Check(py_obj);
 }
 
 void PythonInteger::SetInteger(int64_t value) {
   *this = Take<PythonInteger>(PyLong_FromLongLong(value));
 }
 
 StructuredData::IntegerSP PythonInteger::CreateStructuredInteger() const {
-  StructuredData::IntegerSP result(new StructuredData::Integer);
-  // FIXME this is really not ideal.   Errors are silently converted to 0
-  // and overflows are silently wrapped.   But we'd need larger changes
-  // to StructuredData to fix it, so that's how it is for now.
-  llvm::Expected<unsigned long long> value = AsModuloUnsignedLongLong();
-  if (!value) {
+  StructuredData::UnsignedIntegerSP uint_sp = CreateStructuredUnsignedInteger();
+  return uint_sp ? StructuredData::IntegerSP(uint_sp)
+                 : CreateStructuredSignedInteger();
+}
+
+StructuredData::UnsignedIntegerSP
+PythonInteger::CreateStructuredUnsignedInteger() const {
+  StructuredData::UnsignedIntegerSP result = nullptr;
+  llvm::Expected<unsigned long long> value = AsUnsignedLongLong();
+  if (!value)
     llvm::consumeError(value.takeError());
-    result->SetValue(0);
-  } else {
-    result->SetValue(value.get());
-  }
+  else
+    result = std::make_shared<StructuredData::UnsignedInteger>(value.get());
+
+  return result;
+
+StructuredData::SignedIntegerSP
+PythonInteger::CreateStructuredSignedInteger() const {
+  StructuredData::SignedIntegerSP result = nullptr;
+  llvm::Expected<long long> value = AsLongLong();
+  if (!value)
+    llvm::consumeError(value.takeError());
+  else
+    result = std::make_shared<StructuredData::SignedInteger>(value.get());
+
   return result;
 }
 
 // PythonBoolean
 
 PythonBoolean::PythonBoolean(bool value) {
   SetValue(value);
 }

lldb/source/Plugins/ScriptInterpreter/Python/ScriptedProcessPythonInterface.cpp

lldb::offset_t ScriptedProcessPythonInterface::WriteMemoryAtAddress(
 
   if (!CheckStructuredDataObject(LLVM_PRETTY_FUNCTION, obj, error))
     return LLDB_INVALID_OFFSET;
 
   // If there was an error on the python call, surface it to the user.
   if (py_error.Fail())
     error = py_error;
 
-  return obj->GetIntegerValue(LLDB_INVALID_OFFSET);
+  return obj->GetUnsignedIntegerValue(LLDB_INVALID_OFFSET);
 }
 
 StructuredData::ArraySP ScriptedProcessPythonInterface::GetLoadedImages() {
   Status error;
   StructuredData::ArraySP array =
       Dispatch<StructuredData::ArraySP>("get_loaded_images", error);
 
   if (!CheckStructuredDataObject(LLVM_PRETTY_FUNCTION, array, error))
     return {};
 
   return array;
 }
 
 lldb::pid_t ScriptedProcessPythonInterface::GetProcessID() {
   Status error;
   StructuredData::ObjectSP obj = Dispatch("get_process_id", error);
 
   if (!CheckStructuredDataObject(LLVM_PRETTY_FUNCTION, obj, error))
     return LLDB_INVALID_PROCESS_ID;
 
-  return obj->GetIntegerValue(LLDB_INVALID_PROCESS_ID);
+  return obj->GetUnsignedIntegerValue(LLDB_INVALID_PROCESS_ID);
 }
 
 bool ScriptedProcessPythonInterface::IsAlive() {
   Status error;
   StructuredData::ObjectSP obj = Dispatch("is_alive", error);
 
   if (!CheckStructuredDataObject(LLVM_PRETTY_FUNCTION, obj, error))
     return {};

lldb/source/Plugins/ScriptInterpreter/Python/ScriptedThreadPythonInterface.cpp

 
 lldb::tid_t ScriptedThreadPythonInterface::GetThreadID() {
   Status error;
   StructuredData::ObjectSP obj = Dispatch("get_thread_id", error);
 
   if (!CheckStructuredDataObject(LLVM_PRETTY_FUNCTION, obj, error))
     return LLDB_INVALID_THREAD_ID;
 
-  return obj->GetIntegerValue(LLDB_INVALID_THREAD_ID);
+  return obj->GetUnsignedIntegerValue(LLDB_INVALID_THREAD_ID);
 }
 
 std::optional<std::string> ScriptedThreadPythonInterface::GetName() {
   Status error;
   StructuredData::ObjectSP obj = Dispatch("get_name", error);
 
   if (!CheckStructuredDataObject(LLVM_PRETTY_FUNCTION, obj, error))
     return {};
 
   return obj->GetStringValue().str();
 }
 
 lldb::StateType ScriptedThreadPythonInterface::GetState() {
   Status error;
   StructuredData::ObjectSP obj = Dispatch("get_state", error);
 
   if (!CheckStructuredDataObject(LLVM_PRETTY_FUNCTION, obj, error))
     return eStateInvalid;
 
-  return static_cast<StateType>(obj->GetIntegerValue(eStateInvalid));
+  return static_cast<StateType>(obj->GetUnsignedIntegerValue(eStateInvalid));
 }
 
 std::optional<std::string> ScriptedThreadPythonInterface::GetQueue() {
   Status error;
   StructuredData::ObjectSP obj = Dispatch("get_queue", error);
 
   if (!CheckStructuredDataObject(LLVM_PRETTY_FUNCTION, obj, error))
     return {};

lldb/source/Target/DynamicRegisterInfo.cpp

for (uint32_t i = 0; i < num_regs; ++i) {
     else {
       LLDB_LOG_ERROR(log, byte_offset.takeError(),
                      "error while parsing register {1}: {0}", reg_info.name);
       Clear();
       reg_info_dict->DumpToStdout();
       return 0;
     }
 
-    int64_t bitsize = 0;
+    uint64_t bitsize = 0;
     if (!reg_info_dict->GetValueForKeyAsInteger("bitsize", bitsize)) {
       Clear();
       printf("error: invalid or missing 'bitsize' key/value pair in register "
              "dictionary\n");
       reg_info_dict->DumpToStdout();
       return 0;
     }
 
for (uint32_t i = 0; i < num_regs; ++i) {
     llvm::StringRef encoding_str;
     if (reg_info_dict->GetValueForKeyAsString("encoding", encoding_str))
       reg_info.encoding = Args::StringToEncoding(encoding_str, eEncodingUint);
     else
       reg_info_dict->GetValueForKeyAsInteger("encoding", reg_info.encoding,
                                              eEncodingUint);
 
     size_t set = 0;
-    if (!reg_info_dict->GetValueForKeyAsInteger<size_t>("set", set, -1) ||
+    if (!reg_info_dict->GetValueForKeyAsInteger("set", set) ||
         set >= m_sets.size()) {
       Clear();
       printf("error: invalid 'set' value in register dictionary, valid values "
              "are 0 - %i\n",
              (int)set);
       reg_info_dict->DumpToStdout();
       return 0;
     }

lldb/source/Target/Thread.cpp

if (thread_info) {
     if (activity && activity->GetType() == eStructuredDataTypeDictionary) {
       StructuredData::Dictionary *activity_dict = activity->GetAsDictionary();
       StructuredData::ObjectSP id = activity_dict->GetValueForKey("id");
       StructuredData::ObjectSP name = activity_dict->GetValueForKey("name");
       if (name && name->GetType() == eStructuredDataTypeString && id &&
           id->GetType() == eStructuredDataTypeInteger) {
         strm.Format("  Activity '{0}', {1:x}\n",
                     name->GetAsString()->GetValue(),
-                    id->GetAsInteger()->GetValue());
+                    id->GetUnsignedIntegerValue());
       }
       printed_activity = true;
     }
     bool printed_breadcrumb = false;
     if (breadcrumb && breadcrumb->GetType() == eStructuredDataTypeDictionary) {
       if (printed_activity)
         strm.Printf("\n");
       StructuredData::Dictionary *breadcrumb_dict =

lldb/source/Utility/StructuredData.cpp

static StructuredData::ObjectSP ParseJSONValue(json::Value &value) {
 
   if (auto s = value.getAsString())
     return std::make_shared<StructuredData::String>(*s);
 
   if (auto b = value.getAsBoolean())
     return std::make_shared<StructuredData::Boolean>(*b);
 
   if (auto u = value.getAsUINT64())
-    return std::make_shared<StructuredData::Integer>(*u);
+    return std::make_shared<StructuredData::UnsignedInteger>(*u);
 
   if (auto i = value.getAsInteger())
-    return std::make_shared<StructuredData::Integer>(*i);
+    return std::make_shared<StructuredData::SignedInteger>(*i);
 
   if (auto d = value.getAsNumber())
     return std::make_shared<StructuredData::Float>(*d);
 
   if (auto n = value.getAsNull())
     return std::make_shared<StructuredData::Null>();
 
   return StructuredData::ObjectSP();

 void StructuredData::Array::Serialize(json::OStream &s) const {
   s.arrayBegin();
   for (const auto &item_sp : m_items) {
     item_sp->Serialize(s);
   }
   s.arrayEnd();
 }
 
-void StructuredData::Integer::Serialize(json::OStream &s) const {
-  s.value(static_cast<int64_t>(m_value));
-}
-
 void StructuredData::Float::Serialize(json::OStream &s) const {
   s.value(m_value);
 }
 
 void StructuredData::Boolean::Serialize(json::OStream &s) const {
   s.value(m_value);
 }
 

 void StructuredData::Null::Serialize(json::OStream &s) const {
   s.value(nullptr);
 }
 
 void StructuredData::Generic::Serialize(json::OStream &s) const {
   s.value(llvm::formatv("{0:X}", m_object));
 }
 
-void StructuredData::Integer::GetDescription(lldb_private::Stream &s) const {
-  s.Printf("%" PRId64, static_cast<int64_t>(m_value));
-}
-
 void StructuredData::Float::GetDescription(lldb_private::Stream &s) const {
   s.Printf("%f", m_value);
 }
 
 void StructuredData::Boolean::GetDescription(lldb_private::Stream &s) const {
   s.Printf(m_value ? "True" : "False");
 }
 

lldb/test/API/commands/target/stop-hooks/stop_hook.py

def __init__(self, target, extra_args, dict):
             self.ret_val = True
 
     def handle_stop(self, exe_ctx, stream):
         self.counter += 1
         stream.Print("I have stopped %d times.\n"%(self.counter))
         increment = 1
         value = self.extra_args.GetValueForKey("increment")
         if value:
-            incr_as_str = value.GetStringValue(100)
-            increment = int(incr_as_str)
+            increment = value.GetUnsignedIntegerValue()
         else:
             stream.Print("Could not find increment in extra_args\n")
         frame = exe_ctx.GetFrame()
         expression = "g_var += %d"%(increment)
         expr_result = frame.EvaluateExpression(expression)
         if not expr_result.GetError().Success():
             stream.Print("Error running expression: %s"%(expr_result.GetError().GetCString()))
         value = exe_ctx.target.FindFirstGlobalVariable("g_var")

lldb/test/API/functionalities/step_scripted/Steps.py

         
 # This plan does nothing, but sets stop_mode to the
 # value of GetStopOthers for this plan.
 class StepReportsStopOthers():
     stop_mode_dict = {}
     
     def __init__(self, thread_plan, args_data, dict):
         self.thread_plan = thread_plan
-        self.key = args_data.GetValueForKey("token").GetStringValue(1000)
+        self.key = str(args_data.GetValueForKey("token").GetUnsignedIntegerValue(1000))
         
     def should_stop(self, event):
         self.thread_plan.SetPlanComplete(True)
         StepReportsStopOthers.stop_mode_dict[self.key] = self.thread_plan.GetStopOthers()
         return True
 
     def should_step(self):
         return True
 
     def explains_stop(self, event):
         return True

lldb/test/API/python_api/sbstructureddata/TestStructuredDataAPI.py

class TestStructuredDataAPI(TestBase):
     def test(self):
         self.structured_data_api_test()
 
     def structured_data_api_test(self):
         error = lldb.SBError()
         s = lldb.SBStream()
 
         dict_str = json.dumps(
-                {"key_dict":
-                 {"key_string":"STRING",
-                  "key_uint":0xffffffff00000000,
-                  "key_float":2.99,
-                  "key_bool":True,
-                  "key_array":["23","arr"]}})
+            {
+                "key_dict": {
+                    "key_string": "STRING",
+                    "key_uint": 0xFFFFFFFF00000000,
+                    "key_sint": -42,
+                    "key_float": 2.99,
+                    "key_bool": True,
+                    "key_array": ["23", "arr"],
+                }
+            }
+        )
         s.Print(dict_str)
         example = lldb.SBStructuredData()
 
         # Check SetFromJSON API for dictionaries, integers, floating point
         # values, strings and arrays
         error = example.SetFromJSON(s)
         if not error.Success():
             self.fail("FAILED:   " + error.GetCString())
 
         # Tests for invalid data type
         self.invalid_struct_test(example)
 
         # Test that GetDescription works:
         s.Clear()
         error = example.GetDescription(s)
         self.assertSuccess(error, "GetDescription works")
         if not "key_float" in s.GetData():
             self.fail("FAILED: could not find key_float in description output")
-        
         dict_struct = lldb.SBStructuredData()
         dict_struct = example.GetValueForKey("key_dict")
 
         # Tests for dictionary data type
         self.dictionary_struct_test(example)
 
         # Tests for string data type
         self.string_struct_test(dict_struct)
 
         # Tests for integer data type
         self.uint_struct_test(dict_struct)
 
+        # Tests for integer data type
+        self.sint_struct_test(dict_struct)
+
         # Tests for floating point data type
         self.double_struct_test(dict_struct)
 
         # Tests for boolean data type
         self.bool_struct_test(dict_struct)
 
         # Tests for array data type
         self.array_struct_test(dict_struct)
def dictionary_struct_test(self, example):
         if not dict_struct.IsValid():
             self.fail("A valid object should have been returned")
 
         # Check Type API
         if not dict_struct.GetType() == lldb.eStructuredDataTypeDictionary:
             self.fail("Wrong type returned: " + str(dict_struct.GetType()))
 
         # Check Size API for 'dictionary' type
-        if not dict_struct.GetSize() == 5:
+        if not dict_struct.GetSize() == 6:
             self.fail("Wrong no of elements returned: " +
                       str(dict_struct.GetSize()))
 
     def string_struct_test(self, dict_struct):
         string_struct = lldb.SBStructuredData()
         string_struct = dict_struct.GetValueForKey("key_string")
         if not string_struct.IsValid():
             self.fail("A valid object should have been returned")
def uint_struct_test(self, dict_struct):
         uint_struct = dict_struct.GetValueForKey("key_uint")
         if not uint_struct.IsValid():
             self.fail("A valid object should have been returned")
 
         # Check Type API
         if not uint_struct.GetType() == lldb.eStructuredDataTypeInteger:
             self.fail("Wrong type returned: " + str(uint_struct.GetType()))
 
-        # Check API returning 'integer' value
-        output = uint_struct.GetIntegerValue()
+        # Check API returning unsigned integer value
+        output = uint_struct.GetUnsignedIntegerValue()
         if not output == 0xffffffff00000000:
             self.fail("wrong output: " + str(output))
 
         # Calling wrong API on a SBStructuredData
         # (e.g. getting a string value from an integer type structure)
         output = uint_struct.GetStringValue(25)
         if output:
+            self.fail("Valid string " + output + " returned for an integer object")
+
+    def sint_struct_test(self, dict_struct):
+        # Check a valid SBStructuredData containing an signed integer.
+        # We intentionally make this smaller than what an uint64_t can hold but
+        # still small enough to fit a int64_t
+        sint_struct = lldb.SBStructuredData()
+        sint_struct = dict_struct.GetValueForKey("key_sint")
+        if not sint_struct.IsValid():
+            self.fail("A valid object should have been returned")
+
+        # Check Type API
+        if not sint_struct.GetType() == lldb.eStructuredDataTypeSignedInteger:
+            self.fail("Wrong type returned: " + str(sint_struct.GetType()))
+
+        # Check API returning signed integer value
+        output = sint_struct.GetSignedIntegerValue()
+        if not output == -42:
+            self.fail("wrong output: " + str(output))
+
+        # Calling wrong API on a SBStructuredData
+        # (e.g. getting a string value from an integer type structure)
+        output = sint_struct.GetStringValue(69)
+        if output:
             self.fail(
                 "Valid string " +
                 output +
                 " returned for an integer object")
 
     def double_struct_test(self, dict_struct):
         floating_point_struct = lldb.SBStructuredData()
         floating_point_struct = dict_struct.GetValueForKey("key_float")

lldb/tools/lldb-vscode/JSONUtils.cpp

void FilterAndGetValueForKey(const lldb::SBStructuredData data, const char *key,
   lldb::SBStructuredData value = data.GetValueForKey(key);
   std::string key_utf8 = llvm::json::fixUTF8(key);
   if (strcmp(key, "modules") == 0)
     return;
   switch (value.GetType()) {
   case lldb::eStructuredDataTypeFloat:
     out.try_emplace(key_utf8, value.GetFloatValue());
     break;
-  case lldb::eStructuredDataTypeInteger:
-    out.try_emplace(key_utf8, value.GetIntegerValue());
+  case lldb::eStructuredDataTypeUnsignedInteger:
+    out.try_emplace(key_utf8, value.GetIntegerValue((uint64_t)0));
+    break;
+  case lldb::eStructuredDataTypeSignedInteger:
+    out.try_emplace(key_utf8, value.GetIntegerValue((int64_t)0));
     break;
   case lldb::eStructuredDataTypeArray: {
     lldb::SBStream contents;
     value.GetAsJSON(contents);
     out.try_emplace(key_utf8, llvm::json::fixUTF8(contents.GetData()));
   } break;
   case lldb::eStructuredDataTypeBoolean:
     out.try_emplace(key_utf8, value.GetBooleanValue());

lldb/unittests/Process/gdb-remote/GDBRemoteCommunicationClientTest.cpp

TEST_F(GDBRemoteCommunicationClientTest, TestPacketSpeedJSON) {
   auto dict_sp = object_sp->GetAsDictionary();
   ASSERT_TRUE(bool(dict_sp));
 
   object_sp = dict_sp->GetValueForKey("packet_speeds");
   ASSERT_TRUE(bool(object_sp));
   dict_sp = object_sp->GetAsDictionary();
   ASSERT_TRUE(bool(dict_sp));
 
-  int num_packets;
+  size_t num_packets;
   ASSERT_TRUE(dict_sp->GetValueForKeyAsInteger("num_packets", num_packets))
       << ss.GetString();
   ASSERT_EQ(10, num_packets);
 }
 
 TEST_F(GDBRemoteCommunicationClientTest, SendSignalsToIgnore) {
   std::future<Status> result = std::async(std::launch::async, [&] {
     return client.SendSignalsToIgnore({2, 3, 5, 7, 0xB, 0xD, 0x11});

lldb/unittests/ScriptInterpreter/Python/PythonDataObjectsTests.cpp

 #include "lldb/Host/File.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/lldb-enumerations.h"
 #include "llvm/Testing/Support/Error.h"
 
 #include "PythonTestSuite.h"
 
+#include <variant>
+
 using namespace lldb_private;
 using namespace lldb_private::python;
 using llvm::Error;
 using llvm::Expected;
 
 class PythonDataObjectsTest : public PythonTestSuite {
 public:
   void SetUp() override {
TEST_F(PythonDataObjectsTest, TestPythonStringToStr) {
   EXPECT_EQ(GetString, str.GetString());
 
   PythonString str_str = str.Str();
   EXPECT_EQ(GetString, str_str.GetString());
 }
 
 TEST_F(PythonDataObjectsTest, TestPythonIntegerToStr) {}
 
-TEST_F(PythonDataObjectsTest, TestPythonIntegerToStructuredInteger) {
+TEST_F(PythonDataObjectsTest, TestPythonIntegerToStructuredUnsignedInteger) {
   PythonInteger integer(7);
   auto int_sp = integer.CreateStructuredInteger();
-  EXPECT_EQ(7U, int_sp->GetValue());
+  EXPECT_TRUE(
+      std::holds_alternative<StructuredData::UnsignedIntegerSP>(int_sp));
+  StructuredData::UnsignedIntegerSP uint_sp =
+      std::get<StructuredData::UnsignedIntegerSP>(int_sp);
+  EXPECT_EQ(7U, uint_sp->GetValue());
+}
+
+TEST_F(PythonDataObjectsTest, TestPythonIntegerToStructuredSignedInteger) {
+  PythonInteger integer(-42);
+  auto int_sp = integer.CreateStructuredInteger();
+  EXPECT_TRUE(std::holds_alternative<StructuredData::SignedIntegerSP>(int_sp));
+  StructuredData::SignedIntegerSP sint_sp =
+      std::get<StructuredData::SignedIntegerSP>(int_sp);
+  EXPECT_EQ(-42, sint_sp->GetValue());
 }
 
 TEST_F(PythonDataObjectsTest, TestPythonStringToStructuredString) {
   static const char *test_string =
       "PythonDataObjectsTest::TestPythonStringToStructuredString";
   PythonString constructed_string(test_string);
   auto string_sp = constructed_string.CreateStructuredString();
   EXPECT_EQ(test_string, string_sp->GetStringValue());
TEST_F(PythonDataObjectsTest, TestPythonListToStructuredList) {
   list.AppendItem(PythonString(string_value1));
 
   auto array_sp = list.CreateStructuredArray();
   EXPECT_EQ(lldb::eStructuredDataTypeInteger,
             array_sp->GetItemAtIndex(0)->GetType());
   EXPECT_EQ(lldb::eStructuredDataTypeString,
             array_sp->GetItemAtIndex(1)->GetType());
 
-  auto int_sp = array_sp->GetItemAtIndex(0)->GetAsInteger();
+  auto int_sp = array_sp->GetItemAtIndex(0)->GetAsUnsignedInteger();
   auto string_sp = array_sp->GetItemAtIndex(1)->GetAsString();
 
   EXPECT_EQ(long_value0, long(int_sp->GetValue()));
   EXPECT_EQ(string_value1, string_sp->GetValue());
 }
 
 TEST_F(PythonDataObjectsTest, TestPythonTupleSize) {
   PythonTuple tuple(PyInitialValue::Empty);
TEST_F(PythonDataObjectsTest, TestPythonDictionaryToStructuredDictionary) {
 
   auto dict_sp = dict.CreateStructuredDictionary();
   EXPECT_EQ(2U, dict_sp->GetSize());
 
   EXPECT_TRUE(dict_sp->HasKey(string_key0));
   EXPECT_TRUE(dict_sp->HasKey(string_key1));
 
   auto string_sp = dict_sp->GetValueForKey(string_key0)->GetAsString();
-  auto int_sp = dict_sp->GetValueForKey(string_key1)->GetAsInteger();
+  auto int_sp = dict_sp->GetValueForKey(string_key1)->GetAsUnsignedInteger();
 
   EXPECT_EQ(string_value0, string_sp->GetValue());
   EXPECT_EQ(int_value1, long(int_sp->GetValue()));
 }
 
 TEST_F(PythonDataObjectsTest, TestPythonCallableCheck) {
   PythonObject sys_exc_info = m_sys_module.ResolveName("exc_info");
   PythonObject none(PyRefType::Borrowed, Py_None);
if (structured_data_sp) {
     StructuredData::Dictionary *structured_dict_ptr =
         structured_data_sp->GetAsDictionary();
     EXPECT_TRUE(structured_dict_ptr != nullptr);
     if (structured_dict_ptr) {
       StructuredData::ObjectSP structured_addr_value_sp =
           structured_dict_ptr->GetValueForKey(key_name);
       EXPECT_TRUE((bool)structured_addr_value_sp);
       const uint64_t extracted_value =
-          structured_addr_value_sp->GetIntegerValue(123);
+          structured_addr_value_sp->GetUnsignedIntegerValue(123);
       EXPECT_TRUE(extracted_value == value);
     }
   }
 }
 
 TEST_F(PythonDataObjectsTest, TestCallable) {
 
   PythonDictionary globals(PyInitialValue::Empty);