[lldb] Replace host-typed Scalar accessors with [SZ]ExtOrTruncInt

[labath]

Summary

The Scalar class gives off the impression that it follows the C type
conversion rules, but this is not true for its host-typed accessor
methods. For example, Scalar((int)-1).ULongLong() returns 0xffffffff,
but (unsigned long long)(int)-1 is 0xffffffffffffffff. I.e., Scalar's
ULongLong always zero-extends, but C semantics require sign-extension.

This patch renames [SU]LongLong to [SZ]ExtOrTruncInt to better reflect
the conversion being done (name chosen after the underlying APInt
operation). Accessors for smaller types are removed completely as the
are not necessary -- normal C conversions from (u)int64_t will handle
that for us in most cases.

[mib]

Looks good to me apart from one small detail.

I'll leave it open for others to comment on this, since there are lots of changes.

lldb/source/Core/ValueObject.cpp

467

Any reason why this is not inlined in the definition ?

[labath]

Not relevant now that D82772 is in. It still may make sense to revisit this idea later.

[jankratochvil]

lldb/source/Core/ValueObject.cpp

467

IMO this patch does only the renaming, it should not do unrelated code cleanups.
For example by s/ZExtOrTruncInt/ULongLong/ s/SExtOrTruncInt/SLongLong/ + clang-format one should get zero-sized patch to verify there are no unintended changes.

[jankratochvil]

This patch no longer applies, it needs a rebase.

[labath]

Just abandoning. I believe I've removed the most egregious parts of the Scalar class now. There's still room for improvement, but that requires a fresh start anyway...

lldb/include/lldb/Utility/RegisterValue.h

 //===-- RegisterValue.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_REGISTERVALUE_H
 #define LLDB_UTILITY_REGISTERVALUE_H
 
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/Scalar.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/lldb-enumerations.h"
 #include "lldb/lldb-types.h"
 #include "llvm/ADT/APInt.h"
 #include "llvm/ADT/StringRef.h"
 #include <cstdint>
 #include <cstring>
public:
 
   bool GetScalarValue(Scalar &scalar) const;
 
   uint8_t GetAsUInt8(uint8_t fail_value = UINT8_MAX,
                      bool *success_ptr = nullptr) const {
     if (m_type == eTypeUInt8) {
       if (success_ptr)
         *success_ptr = true;
-      return m_scalar.UChar(fail_value);
+      return m_scalar.ZExtOrTruncInt(fail_value);
     }
     if (success_ptr)
       *success_ptr = true;
     return fail_value;
   }
 
   uint16_t GetAsUInt16(uint16_t fail_value = UINT16_MAX,
                        bool *success_ptr = nullptr) const;

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/Status.h"
 #include "lldb/lldb-enumerations.h"
 #include "lldb/lldb-private-types.h"
 #include "lldb/Utility/LLDBAssert.h"
 #include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/APInt.h"
 #include <cstddef>
 #include <cstdint>
 
public:
   // float/double/long double type. Returns false if the contained value has a
   // void/float/double/long double type, else the value is inverted and true is
   // returned.
   bool OnesComplement(); // Returns true on success
 
   // Access the type of the current value.
   Scalar::Type GetType() const { return m_type; }
 
-  // Returns a casted value of the current contained data without modifying the
-  // current value. FAIL_VALUE will be returned if the type of the value is
-  // void or invalid.
-  int SInt(int fail_value = 0) const;
-
-  unsigned char UChar(unsigned char fail_value = 0) const;
-
-  signed char SChar(signed char fail_value = 0) const;
-
-  unsigned short UShort(unsigned short fail_value = 0) const;
-
-  short SShort(short fail_value = 0) const;
-
-  unsigned int UInt(unsigned int fail_value = 0) const;
-
-  long SLong(long fail_value = 0) const;
-
-  unsigned long ULong(unsigned long fail_value = 0) const;
-
-  long long SLongLong(long long fail_value = 0) const;
-
-  unsigned long long ULongLong(unsigned long long fail_value = 0) const;
+  /// Return an unsigned integer representation of this value. Integers values
+  /// will be zero-extended or truncated. Floating point values will be
+  /// converted to integers first. In case of a void type, fail_value is
+  /// returned.
+  uint64_t ZExtOrTruncInt(uint64_t fail_value = 0) const;
+
+  /// Return an signed integer representation of this value. Integers values
+  /// will be sign-extended or truncated. Floating point values will be
+  /// converted to integers first. In case of a void type, fail_value is
+  /// returned.
+  int64_t SExtOrTruncInt(int64_t fail_value = 0) const;
 
   llvm::APInt SInt128(const llvm::APInt &fail_value) const;
 
   llvm::APInt UInt128(const llvm::APInt &fail_value) const;
 
   float Float(float fail_value = 0.0f) const;
 
   double Double(double fail_value = 0.0) const;
protected:
   typedef double double_t;
   typedef long double long_double_t;
 
   // 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 GetAsSigned(T fail_value) const;
-  template <typename T> T GetAsUnsigned(T fail_value) 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/Core/Value.cpp

 //===-- Value.cpp ---------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/Value.h"
 
 #include "lldb/Core/Address.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Symbol/Variable.h"

 }
 
 Value::Value(const Value &v)
     : m_value(v.m_value), m_vector(v.m_vector),
       m_compiler_type(v.m_compiler_type), m_context(v.m_context),
       m_value_type(v.m_value_type), m_context_type(v.m_context_type),
       m_data_buffer() {
   const uintptr_t rhs_value =
-      (uintptr_t)v.m_value.ULongLong(LLDB_INVALID_ADDRESS);
+      (uintptr_t)v.m_value.ZExtOrTruncInt(LLDB_INVALID_ADDRESS);
   if ((rhs_value != 0) &&
       (rhs_value == (uintptr_t)v.m_data_buffer.GetBytes())) {
     m_data_buffer.CopyData(v.m_data_buffer.GetBytes(),
                            v.m_data_buffer.GetByteSize());
 
     m_value = (uintptr_t)m_data_buffer.GetBytes();
   }
 }
 
 Value &Value::operator=(const Value &rhs) {
   if (this != &rhs) {
     m_value = rhs.m_value;
     m_vector = rhs.m_vector;
     m_compiler_type = rhs.m_compiler_type;
     m_context = rhs.m_context;
     m_value_type = rhs.m_value_type;
     m_context_type = rhs.m_context_type;
     const uintptr_t rhs_value =
-        (uintptr_t)rhs.m_value.ULongLong(LLDB_INVALID_ADDRESS);
+        (uintptr_t)rhs.m_value.ZExtOrTruncInt(LLDB_INVALID_ADDRESS);
     if ((rhs_value != 0) &&
         (rhs_value == (uintptr_t)rhs.m_data_buffer.GetBytes())) {
       m_data_buffer.CopyData(rhs.m_data_buffer.GetBytes(),
                              rhs.m_data_buffer.GetByteSize());
 
       m_value = (uintptr_t)m_data_buffer.GetBytes();
     }
   }
if (exe_ctx == nullptr) {
         Target *target = exe_ctx->GetTargetPtr();
         if (target) {
           // Allow expressions to run and evaluate things when the target has
           // memory sections loaded. This allows you to use "target modules
           // load" to load your executable and any shared libraries, then
           // execute commands where you can look at types in data sections.
           const SectionLoadList &target_sections = target->GetSectionLoadList();
           if (!target_sections.IsEmpty()) {
-            address = m_value.ULongLong(LLDB_INVALID_ADDRESS);
+            address = m_value.ZExtOrTruncInt(LLDB_INVALID_ADDRESS);
             if (target_sections.ResolveLoadAddress(address, file_so_addr)) {
               address_type = eAddressTypeLoad;
               data.SetByteOrder(target->GetArchitecture().GetByteOrder());
               data.SetAddressByteSize(
                   target->GetArchitecture().GetAddressByteSize());
             } else
               address = LLDB_INVALID_ADDRESS;
           }
         } else {
           error.SetErrorString("can't read load address (invalid process)");
         }
       } else {
-        address = m_value.ULongLong(LLDB_INVALID_ADDRESS);
+        address = m_value.ZExtOrTruncInt(LLDB_INVALID_ADDRESS);
         address_type = eAddressTypeLoad;
         data.SetByteOrder(
             process->GetTarget().GetArchitecture().GetByteOrder());
         data.SetAddressByteSize(
             process->GetTarget().GetArchitecture().GetAddressByteSize());
       }
     }
     break;
 
   case eValueTypeFileAddress:
     if (exe_ctx == nullptr) {
       error.SetErrorString("can't read file address (no execution context)");
     } else if (exe_ctx->GetTargetPtr() == nullptr) {
       error.SetErrorString("can't read file address (invalid target)");
     } else {
-      address = m_value.ULongLong(LLDB_INVALID_ADDRESS);
+      address = m_value.ZExtOrTruncInt(LLDB_INVALID_ADDRESS);
       if (address == LLDB_INVALID_ADDRESS) {
         error.SetErrorString("invalid file address");
       } else {
         if (module == nullptr) {
           // The only thing we can currently lock down to a module so that we
           // can resolve a file address, is a variable.
           Variable *variable = GetVariable();
           if (variable) {
if (exe_ctx == nullptr) {
           error.SetErrorString(
               "can't read memory from file address without more context");
         }
       }
     }
     break;
 
   case eValueTypeHostAddress:
-    address = m_value.ULongLong(LLDB_INVALID_ADDRESS);
+    address = m_value.ZExtOrTruncInt(LLDB_INVALID_ADDRESS);
     address_type = eAddressTypeHost;
     if (exe_ctx) {
       Target *target = exe_ctx->GetTargetPtr();
       if (target) {
         data.SetByteOrder(target->GetArchitecture().GetByteOrder());
         data.SetAddressByteSize(target->GetArchitecture().GetAddressByteSize());
         break;
       }
if (compiler_type.IsValid()) {
 
     default:
     case eValueTypeFileAddress:
     case eValueTypeLoadAddress: // load address value
     case eValueTypeHostAddress: // host address value (for memory in the process
                                 // that is using liblldb)
     {
       DataExtractor data;
-      lldb::addr_t addr = m_value.ULongLong(LLDB_INVALID_ADDRESS);
+      lldb::addr_t addr = m_value.ZExtOrTruncInt(LLDB_INVALID_ADDRESS);
       Status error(GetValueAsData(exe_ctx, data, nullptr));
       if (error.Success()) {
         Scalar scalar;
         if (compiler_type.GetValueAsScalar(data, 0, data.GetByteSize(),
                                            scalar)) {
           m_value = scalar;
           m_value_type = eValueTypeScalar;
         } else {
const char *Value::GetContextTypeAsCString(ContextType context_type) {
   };
   return "???";
 }
 
 void Value::ConvertToLoadAddress(Module *module, Target *target) {
   if (!module || !target || (GetValueType() != eValueTypeFileAddress))
     return;
 
-  lldb::addr_t file_addr = GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
+  lldb::addr_t file_addr = GetScalar().ZExtOrTruncInt(LLDB_INVALID_ADDRESS);
   if (file_addr == LLDB_INVALID_ADDRESS)
     return;
 
   Address so_addr;
   if (!module->ResolveFileAddress(file_addr, so_addr))
     return;
   lldb::addr_t load_addr = so_addr.GetLoadAddress(target);
   if (load_addr == LLDB_INVALID_ADDRESS)

lldb/source/Core/ValueObject.cpp

 //===-- ValueObject.cpp ---------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/ValueObject.h"
 
 #include "lldb/Core/Address.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ValueObjectCast.h"
 #include "lldb/Core/ValueObjectChild.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/Core/ValueObjectDynamicValue.h"
 #include "lldb/Core/ValueObjectMemory.h"
if (m_location_str.empty()) {
           m_location_str =
               (value_type == Value::eValueTypeVector) ? "vector" : "scalar";
         break;
 
       case Value::eValueTypeLoadAddress:
       case Value::eValueTypeFileAddress:
       case Value::eValueTypeHostAddress: {
         uint32_t addr_nibble_size = data.GetAddressByteSize() * 2;
-        sstr.Printf("0x%*.*llx", addr_nibble_size, addr_nibble_size,
-                    value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS));
+        sstr.Printf("0x%*.*" PRIx64, addr_nibble_size, addr_nibble_size,
+                    value.GetScalar().ZExtOrTruncInt(LLDB_INVALID_ADDRESS));
         m_location_str = std::string(sstr.GetString());
       } break;
       }
     }
   }
   return m_location_str.c_str();
 }
 
bool ValueObject::IsLogicalTrue(Status &error) {
   Scalar scalar_value;
 
   if (!ResolveValue(scalar_value)) {
     error.SetErrorString("failed to get a scalar result");
     return false;
   }
 
   bool ret;
-  ret = scalar_value.ULongLong(1) != 0;
+  ret = scalar_value != 0;
   error.Clear();
   return ret;
 }
 
 bool ValueObject::GetValueIsValid() const { return m_value_is_valid; }
 
 void ValueObject::SetValueIsValid(bool b) { m_value_is_valid = b; }
 
case eAddressTypeLoad: {
         }
       }
     } break;
     case eAddressTypeHost: {
       auto max_bytes =
           GetCompilerType().GetByteSize(exe_ctx.GetBestExecutionContextScope());
       if (max_bytes && *max_bytes > offset) {
         size_t bytes_read = std::min<uint64_t>(*max_bytes - offset, bytes);
-        addr = m_value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
+        addr = m_value.GetScalar().ZExtOrTruncInt(LLDB_INVALID_ADDRESS);
         if (addr == 0 || addr == LLDB_INVALID_ADDRESS)
           break;
         heap_buf_ptr->CopyData((uint8_t *)(addr + offset), bytes_read);
         data.SetData(data_sp);
         return bytes_read;
       }
     } break;
     case eAddressTypeInvalid:
case Value::eValueTypeScalar: {
     }
   } break;
   case Value::eValueTypeLoadAddress: {
     // If it is a load address, then the scalar value is the storage location
     // of the data, and we have to shove this value down to that load location.
     ExecutionContext exe_ctx(GetExecutionContextRef());
     Process *process = exe_ctx.GetProcessPtr();
     if (process) {
-      addr_t target_addr = m_value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
+      addr_t target_addr =
+          m_value.GetScalar().ZExtOrTruncInt(LLDB_INVALID_ADDRESS);
       size_t bytes_written = process->WriteMemory(
           target_addr, data.GetDataStart(), byte_size, error);
       if (!error.Success())
         return false;
       if (bytes_written != byte_size) {
         error.SetErrorString("unable to write value to memory");
         return false;
       }

 // address values out of pointers
 uint64_t ValueObject::GetValueAsUnsigned(uint64_t fail_value, bool *success) {
   // If our byte size is zero this is an aggregate type that has children
   if (CanProvideValue()) {
     Scalar scalar;
     if (ResolveValue(scalar)) {
       if (success)
         *success = true;
-      return scalar.ULongLong(fail_value);
+      return scalar.ZExtOrTruncInt(fail_value);
     }
     // fallthrough, otherwise...
   }
 
   if (success)
     *success = false;
   return fail_value;
 }
 
 int64_t ValueObject::GetValueAsSigned(int64_t fail_value, bool *success) {
   // If our byte size is zero this is an aggregate type that has children
   if (CanProvideValue()) {
     Scalar scalar;
     if (ResolveValue(scalar)) {
       if (success)
         *success = true;
-      return scalar.SLongLong(fail_value);
+      return scalar.SExtOrTruncInt(fail_value);
     }
     // fallthrough, otherwise...
   }
 
   if (success)
     *success = false;
   return fail_value;
 }
if (!UpdateValueIfNeeded(false))
     return LLDB_INVALID_ADDRESS;
 
   switch (m_value.GetValueType()) {
   case Value::eValueTypeScalar:
   case Value::eValueTypeVector:
     if (scalar_is_load_address) {
       if (address_type)
         *address_type = eAddressTypeLoad;
-      return m_value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
+      return m_value.GetScalar().ZExtOrTruncInt(LLDB_INVALID_ADDRESS);
     }
     break;
 
   case Value::eValueTypeLoadAddress:
   case Value::eValueTypeFileAddress: {
     if (address_type)
       *address_type = m_value.GetValueAddressType();
-    return m_value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
+    return m_value.GetScalar().ZExtOrTruncInt(LLDB_INVALID_ADDRESS);
   } break;
   case Value::eValueTypeHostAddress: {
     if (address_type)
       *address_type = m_value.GetValueAddressType();
     return LLDB_INVALID_ADDRESS;
   } break;
   }
   if (address_type)
     *address_type = eAddressTypeInvalid;
   return LLDB_INVALID_ADDRESS;
 }
 
 addr_t ValueObject::GetPointerValue(AddressType *address_type) {
   addr_t address = LLDB_INVALID_ADDRESS;
   if (address_type)
     *address_type = eAddressTypeInvalid;
 
   if (!UpdateValueIfNeeded(false))
     return address;
 
   switch (m_value.GetValueType()) {
   case Value::eValueTypeScalar:
   case Value::eValueTypeVector:
-    address = m_value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
+    address = m_value.GetScalar().ZExtOrTruncInt(LLDB_INVALID_ADDRESS);
     break;
 
   case Value::eValueTypeHostAddress:
   case Value::eValueTypeLoadAddress:
   case Value::eValueTypeFileAddress: {
     lldb::offset_t data_offset = 0;
     address = m_data.GetAddress(&data_offset);
   } break;
if (error.Success()) {
       case Value::eValueTypeLoadAddress: {
         // If it is a load address, then the scalar value is the storage
         // location of the data, and we have to shove this value down to that
         // load location.
         ExecutionContext exe_ctx(GetExecutionContextRef());
         Process *process = exe_ctx.GetProcessPtr();
         if (process) {
           addr_t target_addr =
-              m_value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
+              m_value.GetScalar().ZExtOrTruncInt(LLDB_INVALID_ADDRESS);
           size_t bytes_written = process->WriteScalarToMemory(
               target_addr, new_scalar, byte_size, error);
           if (!error.Success())
             return false;
           if (bytes_written != byte_size) {
             error.SetErrorString("unable to write value to memory");
             return false;
           }
if (m_is_synthetic_children_generated) {
 
     if (m_value.GetValueType() == Value::eValueTypeLoadAddress) {
       if (IsPointerOrReferenceType()) {
         s.Printf("((%s)0x%" PRIx64 ")", GetTypeName().AsCString("void"),
                  GetValueAsUnsigned(0));
         return;
       } else {
         uint64_t load_addr =
-            m_value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
+            m_value.GetScalar().ZExtOrTruncInt(LLDB_INVALID_ADDRESS);
         if (load_addr != LLDB_INVALID_ADDRESS) {
           s.Printf("(*( (%s *)0x%" PRIx64 "))", GetTypeName().AsCString("void"),
                    load_addr);
           return;
         }
       }
     }
 

lldb/source/Core/ValueObjectChild.cpp

 //===-- ValueObjectChild.cpp ----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/ValueObjectChild.h"
 
 #include "lldb/Core/Value.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Utility/Flags.h"
 #include "lldb/Utility/Scalar.h"
 #include "lldb/Utility/Status.h"
if (parent->UpdateValueIfNeeded(false)) {
           }
         }
       } else {
         switch (value_type) {
         case Value::eValueTypeLoadAddress:
         case Value::eValueTypeFileAddress:
         case Value::eValueTypeHostAddress: {
           lldb::addr_t addr =
-              m_value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
+              m_value.GetScalar().ZExtOrTruncInt(LLDB_INVALID_ADDRESS);
           if (addr == LLDB_INVALID_ADDRESS) {
             m_error.SetErrorString("parent address is invalid.");
           } else if (addr == 0) {
             m_error.SetErrorString("parent is NULL");
           } else {
             // Set this object's scalar value to the address of its value by
             // adding its byte offset to the parent address
             m_value.GetScalar() += GetByteOffset();

lldb/source/Expression/DWARFExpression.cpp

 //===-- DWARFExpression.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/Expression/DWARFExpression.h"
 
 #include <inttypes.h>
 
 #include <vector>
 
 #include "lldb/Core/Module.h"
 #include "lldb/Core/Value.h"
 #include "lldb/Core/dwarf.h"
case DW_OP_deref: {
       if (stack.empty()) {
         if (error_ptr)
           error_ptr->SetErrorString("Expression stack empty for DW_OP_deref.");
         return false;
       }
       Value::ValueType value_type = stack.back().GetValueType();
       switch (value_type) {
       case Value::eValueTypeHostAddress: {
-        void *src = (void *)stack.back().GetScalar().ULongLong();
+        void *src = (void *)stack.back().GetScalar().ZExtOrTruncInt();
         intptr_t ptr;
         ::memcpy(&ptr, src, sizeof(void *));
         stack.back().GetScalar() = ptr;
         stack.back().ClearContext();
       } break;
       case Value::eValueTypeFileAddress: {
-        auto file_addr = stack.back().GetScalar().ULongLong(
-            LLDB_INVALID_ADDRESS);
+        auto file_addr =
+            stack.back().GetScalar().ZExtOrTruncInt(LLDB_INVALID_ADDRESS);
         if (!module_sp) {
           if (error_ptr)
             error_ptr->SetErrorStringWithFormat(
                 "need module to resolve file address for DW_OP_deref");
           return false;
         }
         Address so_addr;
         if (!module_sp->ResolveFileAddress(file_addr, so_addr)) {
case DW_OP_deref: {
         stack.back().GetScalar() = load_Addr;
         stack.back().SetValueType(Value::eValueTypeLoadAddress);
         // Fall through to load address code below...
       } LLVM_FALLTHROUGH;
       case Value::eValueTypeLoadAddress:
         if (exe_ctx) {
           if (process) {
             lldb::addr_t pointer_addr =
-                stack.back().GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
+                stack.back().GetScalar().ZExtOrTruncInt(LLDB_INVALID_ADDRESS);
             Status error;
             lldb::addr_t pointer_value =
                 process->ReadPointerFromMemory(pointer_addr, error);
             if (pointer_value != LLDB_INVALID_ADDRESS) {
               stack.back().GetScalar() = pointer_value;
               stack.back().ClearContext();
             } else {
               if (error_ptr)
case DW_OP_deref_size: {
           error_ptr->SetErrorString(
               "Expression stack empty for DW_OP_deref_size.");
         return false;
       }
       uint8_t size = opcodes.GetU8(&offset);
       Value::ValueType value_type = stack.back().GetValueType();
       switch (value_type) {
       case Value::eValueTypeHostAddress: {
-        void *src = (void *)stack.back().GetScalar().ULongLong();
+        void *src = (void *)stack.back().GetScalar().ZExtOrTruncInt();
         intptr_t ptr;
         ::memcpy(&ptr, src, sizeof(void *));
         // I can't decide whether the size operand should apply to the bytes in
         // their
         // lldb-host endianness or the target endianness.. I doubt this'll ever
         // come up but I'll opt for assuming big endian regardless.
         switch (size) {
         case 1:
case DW_OP_deref_size: {
         }
         stack.back().GetScalar() = ptr;
         stack.back().ClearContext();
       } break;
       case Value::eValueTypeLoadAddress:
         if (exe_ctx) {
           if (process) {
             lldb::addr_t pointer_addr =
-                stack.back().GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
+                stack.back().GetScalar().ZExtOrTruncInt(LLDB_INVALID_ADDRESS);
             uint8_t addr_bytes[sizeof(lldb::addr_t)];
             Status error;
             if (process->ReadMemory(pointer_addr, &addr_bytes, size, error) ==
                 size) {
               DataExtractor addr_data(addr_bytes, sizeof(addr_bytes),
                                       process->GetByteOrder(), size);
               lldb::offset_t addr_data_offset = 0;
               switch (size) {
case DW_OP_piece: {
 
           const Value::ValueType curr_piece_source_value_type =
               curr_piece_source_value.GetValueType();
           switch (curr_piece_source_value_type) {
           case Value::eValueTypeLoadAddress:
             if (process) {
               if (curr_piece.ResizeData(piece_byte_size) == piece_byte_size) {
                 lldb::addr_t load_addr =
-                    curr_piece_source_value.GetScalar().ULongLong(
+                    curr_piece_source_value.GetScalar().ZExtOrTruncInt(
                         LLDB_INVALID_ADDRESS);
                 if (process->ReadMemory(
                         load_addr, curr_piece.GetBuffer().GetBytes(),
                         piece_byte_size, error) != piece_byte_size) {
                   if (error_ptr)
                     error_ptr->SetErrorStringWithFormat(
                         "failed to read memory DW_OP_piece(%" PRIu64
                         ") from 0x%" PRIx64,
case DW_OP_piece: {
                 return false;
               }
             }
             break;
 
           case Value::eValueTypeFileAddress:
           case Value::eValueTypeHostAddress:
             if (error_ptr) {
-              lldb::addr_t addr = curr_piece_source_value.GetScalar().ULongLong(
+              lldb::addr_t addr =
+                  curr_piece_source_value.GetScalar().ZExtOrTruncInt(
                       LLDB_INVALID_ADDRESS);
               error_ptr->SetErrorStringWithFormat(
                   "failed to read memory DW_OP_piece(%" PRIu64
                   ") from %s address 0x%" PRIx64,
                   piece_byte_size, curr_piece_source_value.GetValueType() ==
                                            Value::eValueTypeFileAddress
                                        ? "file"
                                        : "host",
                   addr);
case DW_OP_GNU_push_tls_address: {
       if (!thread) {
         if (error_ptr)
           error_ptr->SetErrorString("No thread to evaluate TLS within.");
         return false;
       }
 
       // Lookup the TLS block address for this thread and module.
       const addr_t tls_file_addr =
-          stack.back().GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
+          stack.back().GetScalar().ZExtOrTruncInt(LLDB_INVALID_ADDRESS);
       const addr_t tls_load_addr =
           thread->GetThreadLocalData(module_sp, tls_file_addr);
 
       if (tls_load_addr == LLDB_INVALID_ADDRESS) {
         if (error_ptr)
           error_ptr->SetErrorString(
               "No TLS data currently exists for this thread.");
         return false;

lldb/source/Expression/IRInterpreter.cpp

 //===-- IRInterpreter.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/Expression/IRInterpreter.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Expression/DiagnosticManager.h"
 #include "lldb/Expression/IRExecutionUnit.h"
 #include "lldb/Expression/IRMemoryMap.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/DataExtractor.h"
bool AssignValue(const Value *value, lldb_private::Scalar &scalar,
                    Module &module) {
     lldb::addr_t process_address = ResolveValue(value, module);
 
     if (process_address == LLDB_INVALID_ADDRESS)
       return false;
 
     lldb_private::Scalar cast_scalar;
 
-    if (!AssignToMatchType(cast_scalar, scalar.ULongLong(), value->getType()))
+    if (!AssignToMatchType(cast_scalar, scalar.ZExtOrTruncInt(),
+                           value->getType()))
       return false;
 
     size_t value_byte_size = m_target_data.getTypeStoreSize(value->getType());
 
     lldb_private::DataBufferHeap buf(value_byte_size, 0);
 
     lldb_private::Status get_data_error;
 
case Instruction::SExt: {
         LLDB_LOGF(log, "Couldn't evaluate %s", PrintValue(source).c_str());
         error.SetErrorToGenericError();
         error.SetErrorString(bad_value_error);
         return false;
       }
 
       S.MakeSigned();
 
-      lldb_private::Scalar S_signextend(S.SLongLong());
+      lldb_private::Scalar S_signextend(S.SExtOrTruncInt());
 
       frame.AssignValue(inst, S_signextend, module);
     } break;
     case Instruction::Br: {
       const BranchInst *br_inst = cast<BranchInst>(inst);
 
       if (br_inst->isConditional()) {
         Value *condition = br_inst->getCondition();
case Instruction::GetElementPtr: {
 
           if (!frame.EvaluateValue(I, *ii, module)) {
             LLDB_LOGF(log, "Couldn't evaluate %s", PrintValue(*ii).c_str());
             error.SetErrorToGenericError();
             error.SetErrorString(bad_value_error);
             return false;
           }
 
-          LLDB_LOGF(log, "Evaluated constant index %s as %llu",
-                    PrintValue(*ii).c_str(), I.ULongLong(LLDB_INVALID_ADDRESS));
+          LLDB_LOG(log, "Evaluated constant index {0} as {1}", PrintValue(*ii),
+                   I.ZExtOrTruncInt(LLDB_INVALID_ADDRESS));
 
           constant_index = cast<ConstantInt>(ConstantInt::get(
-              (*ii)->getType(), I.ULongLong(LLDB_INVALID_ADDRESS)));
+              (*ii)->getType(), I.ZExtOrTruncInt(LLDB_INVALID_ADDRESS)));
         }
 
         const_indices.push_back(constant_index);
       }
 
       uint64_t offset =
           data_layout.getIndexedOffsetInType(src_elem_ty, const_indices);
 
case Instruction::Call: {
       lldb_private::Scalar I;
       const llvm::Value *val = call_inst->getCalledOperand();
 
       if (!frame.EvaluateValue(I, val, module)) {
         error.SetErrorToGenericError();
         error.SetErrorString("unable to get address of function");
         return false;
       }
-      lldb_private::Address funcAddr(I.ULongLong(LLDB_INVALID_ADDRESS));
+      lldb_private::Address funcAddr(I.ZExtOrTruncInt(LLDB_INVALID_ADDRESS));
 
       lldb_private::DiagnosticManager diagnostics;
       lldb_private::EvaluateExpressionOptions options;
 
       // We generally receive a function pointer which we must dereference
       llvm::Type *prototype = val->getType();
       if (!prototype->isPointerTy()) {
         error.SetErrorToGenericError();
case Instruction::Call: {
         if (!frame.EvaluateValue(tmp_op, arg_op, module)) {
           error.SetErrorToGenericError();
           error.SetErrorStringWithFormat("unable to evaluate argument %d", i);
           return false;
         }
 
         // Check if this is a string literal or constant string pointer
         if (arg_ty->isPointerTy()) {
-          lldb::addr_t addr = tmp_op.ULongLong();
+          lldb::addr_t addr = tmp_op.ZExtOrTruncInt();
           size_t dataSize = 0;
 
           bool Success = execution_unit.GetAllocSize(addr, dataSize);
           (void)Success;
           assert(Success &&
                  "unable to locate host data for transfer to device");
           // Create the required buffer
           rawArgs[i].size = dataSize;
case Instruction::Call: {
           rawArgs[i].data_up[dataSize] = '\0';
           rawArgs[i].type = lldb_private::ABI::CallArgument::HostPointer;
         } else /* if ( arg_ty->isPointerTy() ) */
         {
           rawArgs[i].type = lldb_private::ABI::CallArgument::TargetValue;
           // Get argument size in bytes
           rawArgs[i].size = arg_ty->getIntegerBitWidth() / 8;
           // Push value into argument list for thread plan
-          rawArgs[i].value = tmp_op.ULongLong();
+          rawArgs[i].value = tmp_op.ZExtOrTruncInt();
         }
       }
 
       // Pack the arguments into an llvm::array
       llvm::ArrayRef<lldb_private::ABI::CallArgument> args(rawArgs, numArgs);
 
       // Setup a thread plan to call the target function
       lldb::ThreadPlanSP call_plan_sp(
           new lldb_private::ThreadPlanCallFunctionUsingABI(
               exe_ctx.GetThreadRef(), funcAddr, *prototype, *returnType, args,
               options));
 
       // Check if the plan is valid
       lldb_private::StreamString ss;
       if (!call_plan_sp || !call_plan_sp->ValidatePlan(&ss)) {
         error.SetErrorToGenericError();
-        error.SetErrorStringWithFormat(
-            "unable to make ThreadPlanCallFunctionUsingABI for 0x%llx",
-            I.ULongLong());
+        error.SetErrorStringWithFormatv(
+            "unable to make ThreadPlanCallFunctionUsingABI for {0:x}",
+            I.ZExtOrTruncInt());
         return false;
       }
 
       exe_ctx.GetProcessPtr()->SetRunningUserExpression(true);
 
       // Execute the actual function call thread plan
       lldb::ExpressionResults res = exe_ctx.GetProcessRef().RunThreadPlan(
           exe_ctx, call_plan_sp, options, diagnostics);

lldb/source/Expression/IRMemoryMap.cpp

 //===-- IRMemoryMap.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/Expression/IRMemoryMap.h"
 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Scalar.h"
void IRMemoryMap::ReadPointerFromMemory(lldb::addr_t *address,
 
   Scalar pointer_scalar;
   ReadScalarFromMemory(pointer_scalar, process_address, GetAddressByteSize(),
                        error);
 
   if (!error.Success())
     return;
 
-  *address = pointer_scalar.ULongLong();
+  *address = pointer_scalar.ZExtOrTruncInt();
 
   return;
 }
 
 void IRMemoryMap::GetMemoryData(DataExtractor &extractor,
                                 lldb::addr_t process_address, size_t size,
                                 Status &error) {
   error.Clear();

lldb/source/Expression/Materializer.cpp

 //===-- Materializer.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/Expression/Materializer.h"
 #include "lldb/Core/DumpDataExtractor.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/Core/ValueObjectVariable.h"
 #include "lldb/Expression/ExpressionVariable.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Symbol/Variable.h"
 #include "lldb/Target/ExecutionContext.h"
void MakeAllocation(IRMemoryMap &map, Status &err) {
     }
   }
 
   void DestroyAllocation(IRMemoryMap &map, Status &err) {
     Status deallocate_error;
 
     map.Free((lldb::addr_t)m_persistent_variable_sp->m_live_sp->GetValue()
                  .GetScalar()
-                 .ULongLong(),
+                 .ZExtOrTruncInt(),
              deallocate_error);
 
     m_persistent_variable_sp->m_live_sp.reset();
 
     if (!deallocate_error.Success()) {
       err.SetErrorStringWithFormat(
           "couldn't deallocate memory for %s: %s",
           m_persistent_variable_sp->GetName().GetCString(),
if ((m_persistent_variable_sp->m_flags &
               ExpressionVariable::EVNeedsFreezeDry;
           m_persistent_variable_sp->m_flags &=
               ~ExpressionVariable::EVIsProgramReference;
         }
       }
 
       lldb::addr_t mem = m_persistent_variable_sp->m_live_sp->GetValue()
                              .GetScalar()
-                             .ULongLong();
+                             .ZExtOrTruncInt();
 
       if (!m_persistent_variable_sp->m_live_sp) {
         err.SetErrorStringWithFormat(
             "couldn't find the memory area used to store %s",
             m_persistent_variable_sp->GetName().GetCString());
         return;
       }
 

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

 //===-- DynamicLoaderMacOS.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/Breakpoint/StoppointCallbackContext.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Target/ABI.h"
 #include "lldb/Target/StackFrame.h"
if (abi) {
     headers_value.SetCompilerType(clang_void_ptr_type);
 
     argument_values.PushValue(mode_value);
     argument_values.PushValue(count_value);
     argument_values.PushValue(headers_value);
 
     if (abi->GetArgumentValues(exe_ctx.GetThreadRef(), argument_values)) {
       uint32_t dyld_mode =
-          argument_values.GetValueAtIndex(0)->GetScalar().UInt(-1);
+          argument_values.GetValueAtIndex(0)->GetScalar().ZExtOrTruncInt(-1);
       if (dyld_mode != static_cast<uint32_t>(-1)) {
         // Okay the mode was right, now get the number of elements, and the
         // array of new elements...
         uint32_t image_infos_count =
-            argument_values.GetValueAtIndex(1)->GetScalar().UInt(-1);
+            argument_values.GetValueAtIndex(1)->GetScalar().ZExtOrTruncInt(-1);
         if (image_infos_count != static_cast<uint32_t>(-1)) {
           addr_t header_array =
-              argument_values.GetValueAtIndex(2)->GetScalar().ULongLong(-1);
+              argument_values.GetValueAtIndex(2)->GetScalar().ZExtOrTruncInt(
+                  -1);
           if (header_array != static_cast<uint64_t>(-1)) {
             std::vector<addr_t> image_load_addresses;
             for (uint64_t i = 0; i < image_infos_count; i++) {
               Status error;
               addr_t addr = process->ReadUnsignedIntegerFromMemory(
                   header_array + (8 * i), 8, LLDB_INVALID_ADDRESS, error);
               if (addr != LLDB_INVALID_ADDRESS) {
                 image_load_addresses.push_back(addr);

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

if (abi) {
     argument_values.PushValue(input_value);
     input_value.SetCompilerType(clang_void_ptr_type);
     //        input_value.SetContext (Value::eContextTypeClangType,
     //        clang_void_ptr_type);
     argument_values.PushValue(input_value);
 
     if (abi->GetArgumentValues(exe_ctx.GetThreadRef(), argument_values)) {
       uint32_t dyld_mode =
-          argument_values.GetValueAtIndex(0)->GetScalar().UInt(-1);
+          argument_values.GetValueAtIndex(0)->GetScalar().ZExtOrTruncInt(-1);
       if (dyld_mode != static_cast<uint32_t>(-1)) {
         // Okay the mode was right, now get the number of elements, and the
         // array of new elements...
         uint32_t image_infos_count =
-            argument_values.GetValueAtIndex(1)->GetScalar().UInt(-1);
+            argument_values.GetValueAtIndex(1)->GetScalar().ZExtOrTruncInt(-1);
         if (image_infos_count != static_cast<uint32_t>(-1)) {
           // Got the number added, now go through the array of added elements,
           // putting out the mach header address, and adding the image. Note,
           // I'm not putting in logging here, since the AddModules &
           // RemoveModules functions do all the logging internally.
 
           lldb::addr_t image_infos_addr =
-              argument_values.GetValueAtIndex(2)->GetScalar().ULongLong();
+              argument_values.GetValueAtIndex(2)->GetScalar().ZExtOrTruncInt();
           if (dyld_mode == 0) {
             // This is add:
             dyld_instance->AddModulesUsingImageInfosAddress(image_infos_addr,
                                                             image_infos_count);
           } else {
             // This is remove:
             dyld_instance->RemoveModulesUsingImageInfosAddress(
                 image_infos_addr, image_infos_count);

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp

if (!entity)
     return false;
 
   // We know m_parser_vars is valid since we searched for the variable by its
   // NamedDecl
 
   ClangExpressionVariable::ParserVars *parser_vars =
       entity->GetParserVars(GetParserID());
 
-  ptr = parser_vars->m_lldb_value.GetScalar().ULongLong();
+  ptr = parser_vars->m_lldb_value.GetScalar().ZExtOrTruncInt();
 
   return true;
 }
 
 addr_t ClangExpressionDeclMap::GetSymbolAddress(Target &target,
                                                 Process *process,
                                                 ConstString name,
                                                 lldb::SymbolType symbol_type,
bool ClangExpressionDeclMap::GetVariableValue(VariableSP &var,
 
   if (var_location.GetValueType() == Value::eValueTypeFileAddress) {
     SymbolContext var_sc;
     var->CalculateSymbolContext(&var_sc);
 
     if (!var_sc.module_sp)
       return false;
 
-    Address so_addr(var_location.GetScalar().ULongLong(),
+    Address so_addr(var_location.GetScalar().ZExtOrTruncInt(),
                     var_sc.module_sp->GetSectionList());
 
     lldb::addr_t load_addr = so_addr.GetLoadAddress(target);
 
     if (load_addr != LLDB_INVALID_ADDRESS) {
       var_location.GetScalar() = load_addr;
       var_location.SetValueType(Value::eValueTypeLoadAddress);
     }

lldb/source/Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.cpp

ValueObjectSP ItaniumABILanguageRuntime::GetExceptionObjectForThread(
   Value results;
   func_call_ret = function_caller->ExecuteFunction(exe_ctx, nullptr, options,
                                                    diagnostics, results);
   if (func_call_ret != eExpressionCompleted || !error.Success()) {
     return ValueObjectSP();
   }
 
   size_t ptr_size = m_process->GetAddressByteSize();
-  addr_t result_ptr = results.GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
+  addr_t result_ptr = results.GetScalar().ZExtOrTruncInt(LLDB_INVALID_ADDRESS);
   addr_t exception_addr =
       m_process->ReadPointerFromMemory(result_ptr - ptr_size, error);
 
   if (!error.Success()) {
     return ValueObjectSP();
   }
 
   lldb_private::formatters::InferiorSizedWord exception_isw(exception_addr,

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

if (ivar_type) {
       Scalar offset_scalar;
       Status error;
       const int offset_ptr_size = 4;
       const bool is_signed = false;
       size_t read = process->ReadScalarIntegerFromMemory(
           offset_ptr, offset_ptr_size, is_signed, offset_scalar, error);
       if (error.Success() && 4 == read) {
         LLDB_LOGV(log, "offset_ptr = {0:x} --> {1}", offset_ptr,
-                  offset_scalar.SInt());
-        m_ivars.push_back(
-            {ConstString(name), ivar_type, size, offset_scalar.SInt()});
+                  offset_scalar.SExtOrTruncInt());
+        m_ivars.push_back({ConstString(name), ivar_type, size,
+                           int32_t(offset_scalar.SExtOrTruncInt())});
       } else
         LLDB_LOGV(log, "offset_ptr = {0:x} --> read fail, read = %{1}",
                   offset_ptr, read);
     }
     return stop_loop;
   });
 }
 
 void ClassDescriptorV2::GetIVarInformation() {
   m_ivars_storage.fill(m_runtime, *this);
 }

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

bool AppleObjCRuntime::GetObjectDescription(Stream &strm, Value &value,
 
   ExpressionResults results = m_print_object_caller_up->ExecuteFunction(
       exe_ctx, &wrapper_struct_addr, options, diagnostics, ret);
   if (results != eExpressionCompleted) {
     strm.Printf("Error evaluating Print Object function: %d.\n", results);
     return false;
   }
 
-  addr_t result_ptr = ret.GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
+  addr_t result_ptr = ret.GetScalar().ZExtOrTruncInt(LLDB_INVALID_ADDRESS);
 
   char buf[512];
   size_t cstr_len = 0;
   size_t full_buffer_len = sizeof(buf) - 1;
   size_t curr_len = full_buffer_len;
   while (curr_len == full_buffer_len) {
     Status error;
     curr_len = process->ReadCStringFromMemory(result_ptr + cstr_len, buf,

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

 //===-- AppleObjCRuntimeV2.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 <stdint.h>
 
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/DeclObjC.h"
 
 #include "lldb/Host/OptionParser.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/lldb-enumerations.h"
 
 #include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
 #include "lldb/Core/Debugger.h"
if (get_class_info_function->WriteFunctionArguments(
     diagnostics.Clear();
 
     // Run the function
     ExpressionResults results = get_class_info_function->ExecuteFunction(
         exe_ctx, &m_get_class_info_args, options, diagnostics, return_value);
 
     if (results == eExpressionCompleted) {
       // The result is the number of ClassInfo structures that were filled in
-      num_class_infos = return_value.GetScalar().ULong();
+      num_class_infos = return_value.GetScalar().ZExtOrTruncInt();
       LLDB_LOGF(log, "Discovered %u ObjC classes\n", num_class_infos);
       if (num_class_infos > 0) {
         // Read the ClassInfo structures
         DataBufferHeap buffer(num_class_infos * class_info_byte_size, 0);
         if (process->ReadMemory(class_infos_addr, buffer.GetBytes(),
                                 buffer.GetByteSize(),
                                 err) == buffer.GetByteSize()) {
           DataExtractor class_infos_data(buffer.GetBytes(),
if (get_shared_cache_class_info_function->WriteFunctionArguments(
     // Run the function
     ExpressionResults results =
         get_shared_cache_class_info_function->ExecuteFunction(
             exe_ctx, &m_get_shared_cache_class_info_args, options, diagnostics,
             return_value);
 
     if (results == eExpressionCompleted) {
       // The result is the number of ClassInfo structures that were filled in
-      num_class_infos = return_value.GetScalar().ULong();
+      num_class_infos = return_value.GetScalar().ZExtOrTruncInt();
       LLDB_LOGF(log, "Discovered %u ObjC classes in shared cache\n",
                 num_class_infos);
       assert(num_class_infos <= num_classes);
       if (num_class_infos > 0) {
         if (num_class_infos > num_classes) {
           num_class_infos = num_classes;
 
           success = false;
ObjCExceptionRecognizedStackFrame(StackFrameSP frame_sp) {
 
     ValueList args;
     Value input_value;
     input_value.SetCompilerType(voidstar);
     args.PushValue(input_value);
 
     if (!abi->GetArgumentValues(*thread_sp, args)) return;
 
-    addr_t exception_addr = args.GetValueAtIndex(0)->GetScalar().ULongLong();
+    addr_t exception_addr =
+        args.GetValueAtIndex(0)->GetScalar().ZExtOrTruncInt();
 
     Value value(exception_addr);
     value.SetCompilerType(voidstar);
     exception = ValueObjectConstResult::Create(frame_sp.get(), value,
                                                ConstString("exception"));
     exception = ValueObjectRecognizerSynthesizedValue::Create(
         *exception, eValueTypeVariableArgument);
     exception = exception->GetDynamicValue(eDynamicDontRunTarget);

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

if (this_dispatch->stret_return) {
       argument_values.PushValue(void_ptr_value);
       argument_values.PushValue(void_ptr_value);
     }
 
     bool success = abi->GetArgumentValues(thread, argument_values);
     if (!success)
       return ret_plan_sp;
 
-    lldb::addr_t obj_addr =
-        argument_values.GetValueAtIndex(obj_index)->GetScalar().ULongLong();
+    lldb::addr_t obj_addr = argument_values.GetValueAtIndex(obj_index)
+                                ->GetScalar()
+                                .ZExtOrTruncInt();
     if (obj_addr == 0x0) {
       LLDB_LOGF(
           log,
           "Asked to step to dispatch to nil object, returning empty plan.");
       return ret_plan_sp;
     }
 
     ExecutionContext exe_ctx(thread.shared_from_this());
     Process *process = exe_ctx.GetProcessPtr();
     // isa_addr will store the class pointer that the method is being
     // dispatched to - so either the class directly or the super class
     // if this is one of the objc_msgSendSuper flavors.  That's mostly
     // used to look up the class/selector pair in our cache.
 
     lldb::addr_t isa_addr = LLDB_INVALID_ADDRESS;
-    lldb::addr_t sel_addr =
-        argument_values.GetValueAtIndex(sel_index)->GetScalar().ULongLong();
+    lldb::addr_t sel_addr = argument_values.GetValueAtIndex(sel_index)
+                                ->GetScalar()
+                                .ZExtOrTruncInt();
 
     // Figure out the class this is being dispatched to and see if
     // we've already cached this method call, If so we can push a
     // run-to-address plan directly.  Otherwise we have to figure out
     // where the implementation lives.
 
     if (this_dispatch->is_super) {
       if (this_dispatch->is_super2) {
         // In the objc_msgSendSuper2 case, we don't get the object
         // directly, we get a structure containing the object and the
         // class to which the super message is being sent.  So we need
         // to dig the super out of the class and use that.
 
         Value super_value(*(argument_values.GetValueAtIndex(obj_index)));
         super_value.GetScalar() += process->GetAddressByteSize();
         super_value.ResolveValue(&exe_ctx);
 
         if (super_value.GetScalar().IsValid()) {
 
           // isa_value now holds the class pointer.  The second word of the
           // class pointer is the super-class pointer:
           super_value.GetScalar() += process->GetAddressByteSize();
           super_value.ResolveValue(&exe_ctx);
           if (super_value.GetScalar().IsValid())
-            isa_addr = super_value.GetScalar().ULongLong();
+            isa_addr = super_value.GetScalar().ZExtOrTruncInt();
           else {
             LLDB_LOGF(log, "Failed to extract the super class value from the "
                            "class in objc_super.");
           }
         } else {
           LLDB_LOGF(log, "Failed to extract the class value from objc_super.");
         }
       } else {
         // In the objc_msgSendSuper case, we don't get the object
         // directly, we get a two element structure containing the
         // object and the super class to which the super message is
         // being sent.  So the class we want is the second element of
         // this structure.
 
         Value super_value(*(argument_values.GetValueAtIndex(obj_index)));
         super_value.GetScalar() += process->GetAddressByteSize();
         super_value.ResolveValue(&exe_ctx);
 
         if (super_value.GetScalar().IsValid()) {
-          isa_addr = super_value.GetScalar().ULongLong();
+          isa_addr = super_value.GetScalar().ZExtOrTruncInt();
         } else {
           LLDB_LOGF(log, "Failed to extract the class value from objc_super.");
         }
       }
     } else {
       // In the direct dispatch case, the object->isa is the class pointer we
       // want.
 
       // This is a little cheesy, but since object->isa is the first field,
       // making the object value a load address value and resolving it will get
       // the pointer sized data pointed to by that value...
 
       // Note, it isn't a fatal error not to be able to get the
       // address from the object, since this might be a "tagged
       // pointer" which isn't a real object, but rather some word
       // length encoded dingus.
 
       Value isa_value(*(argument_values.GetValueAtIndex(obj_index)));
 
       isa_value.SetValueType(Value::eValueTypeLoadAddress);
       isa_value.ResolveValue(&exe_ctx);
       if (isa_value.GetScalar().IsValid()) {
-        isa_addr = isa_value.GetScalar().ULongLong();
+        isa_addr = isa_value.GetScalar().ZExtOrTruncInt();
       } else {
         LLDB_LOGF(log, "Failed to extract the isa value from object.");
       }
     }
 
     // Okay, we've got the address of the class for which we're resolving this,
     // let's see if it's in our cache:
     lldb::addr_t impl_addr = LLDB_INVALID_ADDRESS;

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

bool AppleThreadPlanStepThroughObjCTrampoline::
   return myself->InitializeFunctionCaller();
 }
 
 void AppleThreadPlanStepThroughObjCTrampoline::GetDescription(
     Stream *s, lldb::DescriptionLevel level) {
   if (level == lldb::eDescriptionLevelBrief)
     s->Printf("Step through ObjC trampoline");
   else {
-    s->Printf("Stepping to implementation of ObjC method - obj: 0x%llx, isa: "
-              "0x%" PRIx64 ", sel: 0x%" PRIx64,
-              m_input_values.GetValueAtIndex(0)->GetScalar().ULongLong(),
+    s->Format("Stepping to implementation of ObjC method - obj: {0:x}, isa: "
+              "{1:x}, sel: {2:x}",
+              m_input_values.GetValueAtIndex(0)->GetScalar().ZExtOrTruncInt(),
               m_isa_addr, m_sel_addr);
   }
 }
 
 bool AppleThreadPlanStepThroughObjCTrampoline::ValidatePlan(Stream *error) {
   return true;
 }
 
bool AppleThreadPlanStepThroughObjCTrampoline::ShouldStop(Event *event_ptr) {
   // target address, and queue up a "run to that address" plan.
   if (!m_run_to_sp) {
     Value target_addr_value;
     ExecutionContext exc_ctx;
     GetThread().CalculateExecutionContext(exc_ctx);
     m_impl_function->FetchFunctionResults(exc_ctx, m_args_addr,
                                           target_addr_value);
     m_impl_function->DeallocateFunctionResults(exc_ctx, m_args_addr);
-    lldb::addr_t target_addr = target_addr_value.GetScalar().ULongLong();
+    lldb::addr_t target_addr = target_addr_value.GetScalar().ZExtOrTruncInt();
     Address target_so_addr;
     target_so_addr.SetOpcodeLoadAddress(target_addr, exc_ctx.GetTargetPtr());
     Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
     if (target_addr == 0) {
       LLDB_LOGF(log, "Got target implementation of 0x0, stopping.");
       SetPlanComplete();
       return true;
     }

lldb/source/Plugins/Platform/POSIX/PlatformPOSIX.cpp

Status PlatformPOSIX::UnloadImage(lldb_private::Process *process,
   if (error.Fail())
     return error;
 
   if (result_valobj_sp->GetError().Fail())
     return result_valobj_sp->GetError();
 
   Scalar scalar;
   if (result_valobj_sp->ResolveValue(scalar)) {
-    if (scalar.UInt(1))
+    if (scalar.ZExtOrTruncInt(1))
       return Status("expression failed: \"%s\"", expr.GetData());
     process->ResetImageToken(image_token);
   }
   return Status();
 }
 
 llvm::StringRef
 PlatformPOSIX::GetLibdlFunctionDeclarations(lldb_private::Process *process) {

lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

for (i = 0; i < num_attributes && !is_artificial; ++i) {
                 form_value.BlockData() - debug_info_data.GetDataStart();
             if (DWARFExpression::Evaluate(
                     nullptr, // ExecutionContext *
                     nullptr, // RegisterContext *
                     module_sp,
                     DataExtractor(debug_info_data, block_offset, block_length),
                     die.GetCU(), eRegisterKindDWARF, &initialValue, nullptr,
                     memberOffset, nullptr)) {
-              member_byte_offset = memberOffset.ResolveValue(nullptr).UInt();
+              member_byte_offset =
+                  memberOffset.ResolveValue(nullptr).ZExtOrTruncInt();
             }
           } else {
             // With DWARF 3 and later, if the value is an integer constant,
             // this form value is the offset in bytes from the beginning of
             // the containing entity.
             member_byte_offset = form_value.Unsigned();
           }
           break;
case DW_TAG_inheritance: {
                     form_value.BlockData() - debug_info_data.GetDataStart();
                 if (DWARFExpression::Evaluate(
                         nullptr, nullptr, module_sp,
                         DataExtractor(debug_info_data, block_offset,
                                       block_length),
                         die.GetCU(), eRegisterKindDWARF, &initialValue, nullptr,
                         memberOffset, nullptr)) {
                   member_byte_offset =
-                      memberOffset.ResolveValue(nullptr).UInt();
+                      memberOffset.ResolveValue(nullptr).ZExtOrTruncInt();
                 }
               } else {
                 // With DWARF 3 and later, if the value is an integer constant,
                 // this form value is the offset in bytes from the beginning of
                 // the containing entity.
                 member_byte_offset = form_value.Unsigned();
               }
               break;

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

if (module_sp) {
                 const DWARFExpression &location = var_sp->LocationExpression();
                 Value location_result;
                 Status error;
                 if (location.Evaluate(nullptr, LLDB_INVALID_ADDRESS, nullptr,
                                       nullptr, location_result, &error)) {
                   if (location_result.GetValueType() ==
                       Value::eValueTypeFileAddress) {
                     lldb::addr_t file_addr =
-                        location_result.GetScalar().ULongLong();
+                        location_result.GetScalar().ZExtOrTruncInt();
                     lldb::addr_t byte_size = 1;
                     if (var_sp->GetType())
                       byte_size =
                           var_sp->GetType()->GetByteSize().getValueOr(0);
                     m_global_aranges_up->Append(GlobalVariableMap::Entry(
                         file_addr, byte_size, var_sp.get()));
                   }
                 }

lldb/source/Symbol/Function.cpp

 //===-- Function.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/Symbol/Function.h"
 #include "lldb/Core/Disassembler.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/LineTable.h"
if (!call_target.Evaluate(&exe_ctx, exe_ctx.GetRegisterContext(),
                             /*initial_value_ptr=*/nullptr,
                             /*object_address_ptr=*/nullptr, callee_addr_val,
                             &error)) {
     LLDB_LOGF(log, "IndirectCallEdge: Could not evaluate expression: %s",
               error.AsCString());
     return nullptr;
   }
 
-  addr_t raw_addr = callee_addr_val.GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
+  addr_t raw_addr =
+      callee_addr_val.GetScalar().ZExtOrTruncInt(LLDB_INVALID_ADDRESS);
   if (raw_addr == LLDB_INVALID_ADDRESS) {
     LLDB_LOG(log, "IndirectCallEdge: Could not extract address from scalar");
     return nullptr;
   }
 
   Address callee_addr;
   if (!exe_ctx.GetTargetPtr()->ResolveLoadAddress(raw_addr, callee_addr)) {
     LLDB_LOG(log, "IndirectCallEdge: Could not resolve callee's load address");

lldb/source/Target/Process.cpp

 //===-- Process.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 <atomic>
 #include <memory>
 #include <mutex>
 
 #include "llvm/Support/ScopedPrinter.h"
 #include "llvm/Support/Threading.h"
 
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Breakpoint/StoppointCallbackContext.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Expression/DiagnosticManager.h"
 #include "lldb/Expression/DynamicCheckerFunctions.h"

 
 uint64_t Process::ReadUnsignedIntegerFromMemory(lldb::addr_t vm_addr,
                                                 size_t integer_byte_size,
                                                 uint64_t fail_value,
                                                 Status &error) {
   Scalar scalar;
   if (ReadScalarIntegerFromMemory(vm_addr, integer_byte_size, false, scalar,
                                   error))
-    return scalar.ULongLong(fail_value);
+    return scalar.ZExtOrTruncInt(fail_value);
   return fail_value;
 }
 
 int64_t Process::ReadSignedIntegerFromMemory(lldb::addr_t vm_addr,
                                              size_t integer_byte_size,
                                              int64_t fail_value,
                                              Status &error) {
   Scalar scalar;
   if (ReadScalarIntegerFromMemory(vm_addr, integer_byte_size, true, scalar,
                                   error))
-    return scalar.SLongLong(fail_value);
+    return scalar.SExtOrTruncInt(fail_value);
   return fail_value;
 }
 
 addr_t Process::ReadPointerFromMemory(lldb::addr_t vm_addr, Status &error) {
   Scalar scalar;
   if (ReadScalarIntegerFromMemory(vm_addr, GetAddressByteSize(), false, scalar,
                                   error))
-    return scalar.ULongLong(LLDB_INVALID_ADDRESS);
+    return scalar.ZExtOrTruncInt(LLDB_INVALID_ADDRESS);
   return LLDB_INVALID_ADDRESS;
 }
 
 bool Process::WritePointerToMemory(lldb::addr_t vm_addr, lldb::addr_t ptr_value,
                                    Status &error) {
   Scalar scalar;
   const uint32_t addr_byte_size = GetAddressByteSize();
   if (addr_byte_size <= 4)

lldb/source/Target/RegisterContext.cpp

 //===-- RegisterContext.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/Target/RegisterContext.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/Value.h"
 #include "lldb/Expression/DWARFExpression.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
DataExtractor dwarf_data(dwarf_opcode_ptr, dwarf_opcode_len,
                            arch.GetByteOrder(), addr_size);
   ModuleSP opcode_ctx;
   DWARFExpression dwarf_expr(opcode_ctx, dwarf_data, nullptr);
   Value result;
   Status error;
   if (dwarf_expr.Evaluate(&exe_ctx, this, opcode_ctx, dwarf_data, nullptr,
                           eRegisterKindDWARF, nullptr, nullptr, result,
                           &error)) {
-    expr_result = result.GetScalar().SInt(-1);
+    expr_result = result.GetScalar().SExtOrTruncInt(-1);
     switch (expr_result) {
     case 0:
       return 4;
     case 1:
       return 8;
     default:
       return reg_info->byte_size;
     }

lldb/source/Target/RegisterContextUnwind.cpp

 //===-- RegisterContextUnwind.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/Target/RegisterContextUnwind.h"
 #include "lldb/Core/Address.h"
 #include "lldb/Core/AddressRange.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/Value.h"
 #include "lldb/Expression/DWARFExpression.h"
 #include "lldb/Symbol/ArmUnwindInfo.h"
 #include "lldb/Symbol/CallFrameInfo.h"
 #include "lldb/Symbol/DWARFCallFrameInfo.h"
if (unwindplan_regloc.IsDWARFExpression() ||
     dwarfexpr.SetRegisterKind(unwindplan_registerkind);
     Value cfa_val = Scalar(m_cfa);
     cfa_val.SetValueType(Value::eValueTypeLoadAddress);
     Value result;
     Status error;
     if (dwarfexpr.Evaluate(&exe_ctx, this, 0, &cfa_val, nullptr, result,
                            &error)) {
       addr_t val;
-      val = result.GetScalar().ULongLong();
+      val = result.GetScalar().ZExtOrTruncInt();
       if (unwindplan_regloc.IsDWARFExpression()) {
         regloc.type = UnwindLLDB::RegisterLocation::eRegisterValueInferred;
         regloc.location.inferred_value = val;
         m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = regloc;
         UnwindLogMsg("supplying caller's register %s (%d) via DWARF expression "
                      "(IsDWARFExpression)",
                      regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
         return UnwindLLDB::RegisterSearchResult::eRegisterFound;
DataExtractor dwarfdata(fa.GetDWARFExpressionBytes(),
                             process->GetAddressByteSize());
     ModuleSP opcode_ctx;
     DWARFExpression dwarfexpr(opcode_ctx, dwarfdata, nullptr);
     dwarfexpr.SetRegisterKind(row_register_kind);
     Value result;
     Status error;
     if (dwarfexpr.Evaluate(&exe_ctx, this, 0, nullptr, nullptr, result,
                            &error)) {
-      address = result.GetScalar().ULongLong();
+      address = result.GetScalar().ZExtOrTruncInt();
 
       UnwindLogMsg("CFA value set by DWARF expression is 0x%" PRIx64,
                    address);
       return true;
     }
     UnwindLogMsg("Failed to set CFA value via DWARF expression: %s",
                  error.AsCString());
     break;

lldb/source/Target/StopInfo.cpp

 //===-- StopInfo.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 <string>
 
 #include "lldb/Breakpoint/Breakpoint.h"
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Breakpoint/StoppointCallbackContext.h"
 #include "lldb/Breakpoint/Watchpoint.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Expression/UserExpression.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/StopInfo.h"
if (thread_sp) {
           result_code = UserExpression::Evaluate(
               exe_ctx, expr_options, wp_sp->GetConditionText(),
               llvm::StringRef(), result_value_sp, error);
 
           if (result_code == eExpressionCompleted) {
             if (result_value_sp) {
               Scalar scalar_value;
               if (result_value_sp->ResolveValue(scalar_value)) {
-                if (scalar_value.ULongLong(1) == 0) {
+                if (scalar_value.ZExtOrTruncInt(1) == 0) {
                   // We have been vetoed.  This takes precedence over querying
                   // the watchpoint whether it should stop (aka ignore count
                   // and friends).  See also StopInfoWatchpoint::ShouldStop()
                   // as well as Process::ProcessEventData::DoOnRemoval().
                   m_should_stop = false;
                 } else
                   m_should_stop = true;
                 LLDB_LOGF(log,

lldb/source/Target/Target.cpp

 //===-- Target.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/Target/Target.h"
 #include "Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.h"
 #include "lldb/Breakpoint/BreakpointIDList.h"
 #include "lldb/Breakpoint/BreakpointPrecondition.h"
 #include "lldb/Breakpoint/BreakpointResolver.h"
 #include "lldb/Breakpoint/BreakpointResolverAddress.h"
 #include "lldb/Breakpoint/BreakpointResolverFileLine.h"
 #include "lldb/Breakpoint/BreakpointResolverFileRegex.h"
 #include "lldb/Breakpoint/BreakpointResolverName.h"

 uint64_t Target::ReadUnsignedIntegerFromMemory(const Address &addr,
                                                bool prefer_file_cache,
                                                size_t integer_byte_size,
                                                uint64_t fail_value,
                                                Status &error) {
   Scalar scalar;
   if (ReadScalarIntegerFromMemory(addr, prefer_file_cache, integer_byte_size,
                                   false, scalar, error))
-    return scalar.ULongLong(fail_value);
+    return scalar.ZExtOrTruncInt(fail_value);
   return fail_value;
 }
 
 bool Target::ReadPointerFromMemory(const Address &addr, bool prefer_file_cache,
                                    Status &error, Address &pointer_addr) {
   Scalar scalar;
   if (ReadScalarIntegerFromMemory(addr, prefer_file_cache,
                                   m_arch.GetSpec().GetAddressByteSize(), false,
                                   scalar, error)) {
-    addr_t pointer_vm_addr = scalar.ULongLong(LLDB_INVALID_ADDRESS);
+    addr_t pointer_vm_addr = scalar.ZExtOrTruncInt(LLDB_INVALID_ADDRESS);
     if (pointer_vm_addr != LLDB_INVALID_ADDRESS) {
       SectionLoadList &section_load_list = GetSectionLoadList();
       if (section_load_list.IsEmpty()) {
         // No sections are loaded, so we must assume we are not running yet and
         // anything we are given is a file address.
         m_images.ResolveFileAddress(pointer_vm_addr, pointer_addr);
       } else {
         // We have at least one section loaded. This can be because we have

lldb/source/Target/ThreadPlanTracer.cpp

 //===-- ThreadPlanTracer.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 <cstring>
 
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Disassembler.h"
 #include "lldb/Core/DumpRegisterValue.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/Value.h"
 #include "lldb/Symbol/TypeList.h"
 #include "lldb/Symbol/TypeSystem.h"
 #include "lldb/Target/ABI.h"
for (int arg_index = 0; arg_index < num_args; ++arg_index) {
       Value value;
       value.SetValueType(Value::eValueTypeScalar);
       value.SetCompilerType(intptr_type);
       value_list.PushValue(value);
     }
 
     if (abi->GetArgumentValues(GetThread(), value_list)) {
       for (int arg_index = 0; arg_index < num_args; ++arg_index) {
-        stream->Printf(
-            "\n\targ[%d]=%llx", arg_index,
-            value_list.GetValueAtIndex(arg_index)->GetScalar().ULongLong());
+        stream->Format("\n\targ[{0}]={1:x}", arg_index,
+                       value_list.GetValueAtIndex(arg_index)
+                           ->GetScalar()
+                           .ZExtOrTruncInt());
 
         if (arg_index + 1 < num_args)
           stream->PutCString(", ");
       }
     }
   }
 
   if (m_register_values.empty()) {

lldb/source/Utility/RegisterValue.cpp

 //===-- RegisterValue.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/RegisterValue.h"
 
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Scalar.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/lldb-defines.h"
 #include "lldb/lldb-private-types.h"
uint16_t RegisterValue::GetAsUInt16(uint16_t fail_value,
   if (success_ptr)
     *success_ptr = true;
 
   switch (m_type) {
   default:
     break;
   case eTypeUInt8:
   case eTypeUInt16:
-    return m_scalar.UShort(fail_value);
+    return m_scalar.ZExtOrTruncInt(fail_value);
   case eTypeBytes: {
     switch (buffer.length) {
     default:
       break;
     case 1:
     case 2:
       return *reinterpret_cast<const uint16_t *>(buffer.bytes);
     }
uint32_t RegisterValue::GetAsUInt32(uint32_t fail_value,
   default:
     break;
   case eTypeUInt8:
   case eTypeUInt16:
   case eTypeUInt32:
   case eTypeFloat:
   case eTypeDouble:
   case eTypeLongDouble:
-    return m_scalar.UInt(fail_value);
+    return m_scalar.ZExtOrTruncInt(fail_value);
   case eTypeBytes: {
     switch (buffer.length) {
     default:
       break;
     case 1:
     case 2:
     case 4:
       return *reinterpret_cast<const uint32_t *>(buffer.bytes);
default:
     break;
   case eTypeUInt8:
   case eTypeUInt16:
   case eTypeUInt32:
   case eTypeUInt64:
   case eTypeFloat:
   case eTypeDouble:
   case eTypeLongDouble:
-    return m_scalar.ULongLong(fail_value);
+    return m_scalar.ZExtOrTruncInt(fail_value);
   case eTypeBytes: {
     switch (buffer.length) {
     default:
       break;
     case 1:
       return *(const uint8_t *)buffer.bytes;
     case 2:
       return *reinterpret_cast<const uint16_t *>(buffer.bytes);

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"
 
bool Scalar::MakeUnsigned() {
   case e_long_double:
     success = true;
     break;
   }
 
   return success;
 }
 
-template <typename T> T Scalar::GetAsSigned(T fail_value) const {
+uint64_t Scalar::ZExtOrTruncInt(uint64_t fail_value) 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.sextOrTrunc(sizeof(T) * 8).getSExtValue();
+    return m_integer.zextOrTrunc(sizeof(uint64_t) * 8).getZExtValue();
 
   case e_float:
-    return static_cast<T>(m_float.convertToFloat());
+    return static_cast<uint64_t>(m_float.convertToFloat());
   case e_double:
-    return static_cast<T>(m_float.convertToDouble());
+    return static_cast<uint64_t>(m_float.convertToDouble());
   case e_long_double:
     llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-    return static_cast<T>(
-        (ldbl_val.sextOrTrunc(sizeof(schar_t) * 8)).getSExtValue());
+    return static_cast<uint64_t>(
+        ldbl_val.zextOrTrunc(sizeof(uint64_t) * 8).getZExtValue());
   }
   return fail_value;
 }
 
-template <typename T> T Scalar::GetAsUnsigned(T fail_value) const {
+int64_t Scalar::SExtOrTruncInt(int64_t fail_value) 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.zextOrTrunc(sizeof(T) * 8).getZExtValue();
+    return m_integer.sextOrTrunc(sizeof(int64_t) * 8).getSExtValue();
 
   case e_float:
-    return static_cast<T>(m_float.convertToFloat());
+    return static_cast<int64_t>(m_float.convertToFloat());
   case e_double:
-    return static_cast<T>(m_float.convertToDouble());
+    return static_cast<int64_t>(m_float.convertToDouble());
   case e_long_double:
     llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-    return static_cast<T>((ldbl_val.zextOrTrunc(sizeof(T) * 8)).getZExtValue());
+    return static_cast<int64_t>(
+        ldbl_val.sextOrTrunc(sizeof(int64_t) * 8).getSExtValue());
   }
   return fail_value;
 }
 
-signed char Scalar::SChar(signed char fail_value) const {
-  return GetAsSigned<signed char>(fail_value);
-}
-
-unsigned char Scalar::UChar(unsigned char fail_value) const {
-  return GetAsUnsigned<unsigned char>(fail_value);
-}
-
-short Scalar::SShort(short fail_value) const {
-  return GetAsSigned<short>(fail_value);
-}
-
-unsigned short Scalar::UShort(unsigned short fail_value) const {
-  return GetAsUnsigned<unsigned short>(fail_value);
-}
-
-int Scalar::SInt(int fail_value) const { return GetAsSigned<int>(fail_value); }
-
-unsigned int Scalar::UInt(unsigned int fail_value) const {
-  return GetAsUnsigned<unsigned int>(fail_value);
-}
-
-long Scalar::SLong(long fail_value) const { return GetAsSigned<long>(fail_value); }
-
-unsigned long Scalar::ULong(unsigned long fail_value) const {
-  return GetAsUnsigned<unsigned long>(fail_value);
-}
-
-long long Scalar::SLongLong(long long fail_value) const {
-  return GetAsSigned<long long>(fail_value);
-}
-
-unsigned long long Scalar::ULongLong(unsigned long long fail_value) const {
-  return GetAsUnsigned<unsigned long long>(fail_value);
-}
-
 llvm::APInt Scalar::SInt128(const llvm::APInt &fail_value) const {
   switch (m_type) {
   case e_void:
     break;
   case e_sint:
   case e_uint:
   case e_slong:
   case e_ulong:

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;
 using llvm::Failed;
 using llvm::Succeeded;
 
+template <typename T> static T (*max)() = std::numeric_limits<T>::max;
+template <typename T> static T (*min)() = std::numeric_limits<T>::min;
+
 template <typename T>
 bool checkInequality(T c1, T c2) {
   return (Scalar(c1) != Scalar(c2));
 }
 
 template <typename T>
 bool checkEquality(T c1, T c2) {
   return (Scalar(c1) == Scalar(c2));
TEST(ScalarTest, GetBytes) {
   ASSERT_EQ(0, e_error.Fail());
   e_scalar.GetBytes(Storage);
   ASSERT_EQ(0, memcmp(e, Storage, sizeof(e)));
   ASSERT_EQ(0, f_error.Fail());
   f_scalar.GetBytes(Storage);
   ASSERT_EQ(0, memcmp(f, Storage, sizeof(f)));
 }
 
-TEST(ScalarTest, CastOperations) {
-  long long a = 0xf1f2f3f4f5f6f7f8LL;
-  Scalar a_scalar(a);
-  ASSERT_EQ((signed char)a, a_scalar.SChar());
-  ASSERT_EQ((unsigned char)a, a_scalar.UChar());
-  ASSERT_EQ((signed short)a, a_scalar.SShort());
-  ASSERT_EQ((unsigned short)a, a_scalar.UShort());
-  ASSERT_EQ((signed int)a, a_scalar.SInt());
-  ASSERT_EQ((unsigned int)a, a_scalar.UInt());
-  ASSERT_EQ((signed long)a, a_scalar.SLong());
-  ASSERT_EQ((unsigned long)a, a_scalar.ULong());
-  ASSERT_EQ((signed long long)a, a_scalar.SLongLong());
-  ASSERT_EQ((unsigned long long)a, a_scalar.ULongLong());
+TEST(ScalarTest, ZExtOrTruncInt) {
+  EXPECT_EQ(uint64_t(max<int>()), Scalar(max<int>()).ZExtOrTruncInt());
+  EXPECT_EQ(uint64_t(max<unsigned>()),
+            Scalar(max<unsigned>()).ZExtOrTruncInt());
+  EXPECT_EQ(uint64_t(max<long>()), Scalar(max<long>()).ZExtOrTruncInt());
+  EXPECT_EQ(uint64_t(max<unsigned long>()),
+            Scalar(max<unsigned long>()).ZExtOrTruncInt());
+}
+
+TEST(ScalarTest, SExtOrTruncInt) {
+  EXPECT_EQ(int64_t(max<int>()), Scalar(max<int>()).SExtOrTruncInt());
+  EXPECT_EQ(int64_t(max<uint64_t>()), Scalar(max<unsigned>()).SExtOrTruncInt());
+  EXPECT_EQ(int64_t(max<long>()), Scalar(max<long>()).SExtOrTruncInt());
+  EXPECT_EQ(int64_t(max<uint64_t>()),
+            Scalar(max<unsigned long>()).SExtOrTruncInt());
+}
 
+TEST(ScalarTest, FloatCasts) {
   int a2 = 23;
   Scalar a2_scalar(a2);
   ASSERT_EQ((float)a2, a2_scalar.Float());
   ASSERT_EQ((double)a2, a2_scalar.Double());
   ASSERT_EQ((long double)a2, a2_scalar.LongDouble());
 }
 
 TEST(ScalarTest, ExtractBitfield) {
template <typename T> static std::string ScalarGetValue(T value) {
   Scalar(value).GetValue(&stream, false);
   return std::string(stream.GetString());
 }
 
 TEST(ScalarTest, GetValue) {
   EXPECT_EQ("12345", ScalarGetValue<signed short>(12345));
   EXPECT_EQ("-12345", ScalarGetValue<signed short>(-12345));
   EXPECT_EQ("12345", ScalarGetValue<unsigned short>(12345));
-  EXPECT_EQ(std::to_string(std::numeric_limits<unsigned short>::max()),
-            ScalarGetValue(std::numeric_limits<unsigned short>::max()));
+  EXPECT_EQ(std::to_string(max<unsigned short>()),
+            ScalarGetValue(max<unsigned short>()));
 
   EXPECT_EQ("12345", ScalarGetValue<signed int>(12345));
   EXPECT_EQ("-12345", ScalarGetValue<signed int>(-12345));
   EXPECT_EQ("12345", ScalarGetValue<unsigned int>(12345));
-  EXPECT_EQ(std::to_string(std::numeric_limits<unsigned int>::max()),
-            ScalarGetValue(std::numeric_limits<unsigned int>::max()));
+  EXPECT_EQ(std::to_string(max<unsigned int>()),
+            ScalarGetValue(max<unsigned int>()));
 
   EXPECT_EQ("12345678", ScalarGetValue<signed long>(12345678L));
   EXPECT_EQ("-12345678", ScalarGetValue<signed long>(-12345678L));
   EXPECT_EQ("12345678", ScalarGetValue<unsigned long>(12345678UL));
-  EXPECT_EQ(std::to_string(std::numeric_limits<unsigned long>::max()),
-            ScalarGetValue(std::numeric_limits<unsigned long>::max()));
+  EXPECT_EQ(std::to_string(max<unsigned long>()),
+            ScalarGetValue(max<unsigned long>()));
 
   EXPECT_EQ("1234567890123", ScalarGetValue<signed long long>(1234567890123LL));
   EXPECT_EQ("-1234567890123",
             ScalarGetValue<signed long long>(-1234567890123LL));
   EXPECT_EQ("1234567890123",
             ScalarGetValue<unsigned long long>(1234567890123ULL));
-  EXPECT_EQ(std::to_string(std::numeric_limits<unsigned long long>::max()),
-            ScalarGetValue(std::numeric_limits<unsigned long long>::max()));
+  EXPECT_EQ(std::to_string(max<unsigned long long>()),
+            ScalarGetValue(max<unsigned long long>()));
 }
 
 TEST(ScalarTest, LongLongAssigmentOperator) {
   Scalar ull;
-  ull = std::numeric_limits<unsigned long long>::max();
-  EXPECT_EQ(std::numeric_limits<unsigned long long>::max(), ull.ULongLong());
+  ull = max<unsigned long long>();
+  EXPECT_EQ(max<unsigned long long>(), ull);
 
   Scalar sll;
-  sll = std::numeric_limits<signed long long>::max();
-  EXPECT_EQ(std::numeric_limits<signed long long>::max(), sll.SLongLong());
+  sll = max<signed long long>();
+  EXPECT_EQ(max<signed long long>(), sll);
 }
 
 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, Scalar_512) {
   ASSERT_TRUE(S.MakeSigned());
   EXPECT_EQ(S.GetType(), Scalar::e_sint512);
   EXPECT_EQ(S.GetByteSize(), 64U);
 }
 
 TEST(ScalarTest, TruncOrExtendTo) {
   Scalar S(0xffff);
   S.TruncOrExtendTo(12, true);
-  EXPECT_EQ(S.ULong(), 0xfffu);
+  EXPECT_EQ(S.ZExtOrTruncInt(), 0xfffu);
   S.TruncOrExtendTo(20, true);
-  EXPECT_EQ(S.ULong(), 0xfffffu);
+  EXPECT_EQ(S.ZExtOrTruncInt(), 0xfffffu);
   S.TruncOrExtendTo(24, false);
-  EXPECT_EQ(S.ULong(), 0x0fffffu);
+  EXPECT_EQ(S.ZExtOrTruncInt(), 0x0fffffu);
   S.TruncOrExtendTo(16, false);
-  EXPECT_EQ(S.ULong(), 0xffffu);
+  EXPECT_EQ(S.ZExtOrTruncInt(), 0xffffu);
 }