Merge pull request #11044 from augusto2112/fix-addr-rebranch

[stable/21.x][lldb] Adapt lldb to upstream changes

Author: augusto2112

lldb/source/Plugins/Language/Swift/SwiftFormatters.cpp

@@ -577,7 +577,7 @@ bool lldb_private::formatters::swift::SwiftSharedString_SummaryProvider_2(
   Status error;
   auto ptr_size = process->GetAddressByteSize();
 
-  lldb::addr_t raw1 = valobj.GetPointerValue();
+  lldb::addr_t raw1 = valobj.GetPointerValue().address;
   lldb::addr_t address = (raw1 & 0x00FFFFFFFFFFFFFF);
   uint64_t startOffset = (ptr_size == 8 ? 24 : 12);
 
@@ -604,7 +604,7 @@ bool lldb_private::formatters::swift::SwiftStringStorage_SummaryProvider(
   auto ptrSize = process->GetAddressByteSize();
   uint64_t bias = (ptrSize == 8 ? 32 : 20);
   uint64_t raw0_offset = (ptrSize == 8 ? 24 : 12);
-  lldb::addr_t raw1 = valobj.GetPointerValue();
+  lldb::addr_t raw1 = valobj.GetPointerValue().address;
   lldb::addr_t address = (raw1 & 0x00FFFFFFFFFFFFFF) + bias;
 
   Status error;

lldb/source/Plugins/Language/Swift/SwiftHashedContainer.cpp

@@ -495,14 +495,14 @@ NativeHashedStorageHandler::NativeHashedStorageHandler(
     return;
   m_keys_ptr = keys_sp->GetValueAsUnsigned(LLDB_INVALID_ADDRESS);
 
-  auto last_field_ptr = keys_sp->GetAddressOf();
+  lldb::addr_t last_field_ptr = keys_sp->GetAddressOf().address;
 
   if (value_type) {
     auto values_sp = m_storage->GetChildAtNamePath({g__rawValues, g__rawValue});
     if (!values_sp)
       return;
     m_values_ptr = values_sp->GetValueAsUnsigned(LLDB_INVALID_ADDRESS);
-    last_field_ptr = values_sp->GetAddressOf();
+    last_field_ptr = values_sp->GetAddressOf().address;
   }
 
   m_metadata_ptr = last_field_ptr + m_ptr_size;
@@ -635,7 +635,7 @@ HashedCollectionConfig::CreateHandler(ValueObject &valobj) const {
   ValueObjectSP valobj_sp = valobj.GetSP();
   if (valobj_sp->GetObjectRuntimeLanguage() != eLanguageTypeSwift &&
       valobj_sp->IsPointerType()) {
-    lldb::addr_t address = valobj_sp->GetPointerValue();
+    lldb::addr_t address = valobj_sp->GetPointerValue().address;
     if (auto swiftval_sp = StorageObjectAtAddress(exe_ctx, address))
       valobj_sp = swiftval_sp;
   }
@@ -656,7 +656,7 @@ HashedCollectionConfig::CreateHandler(ValueObject &valobj) const {
 
   lldb::addr_t storage_location = LLDB_INVALID_ADDRESS;
   if (type_name_cs == m_nativeStorageRoot_demangled)
-    storage_location = valobj_sp->GetPointerValue();
+    storage_location = valobj_sp->GetPointerValue().address;
   else {
     ValueObjectSP variant_sp =
         valobj_sp->GetChildMemberWithName(g__variant, true);

lldb/source/Plugins/Language/Swift/SwiftLanguage.cpp

@@ -1047,8 +1047,7 @@ SwiftLanguage::GetHardcodedSynthetics() {
             // If this is a Swift tagged pointer, the Objective-C data
             // formatters may incorrectly classify it as an
             // Objective-C tagged pointer.
-            AddressType address_type;
-            lldb::addr_t ptr = valobj.GetPointerValue(&address_type);
+            auto [ptr, address_type] = valobj.GetPointerValue();
             auto *swift_runtime = SwiftLanguageRuntime::Get(process_sp);
             if (!swift_runtime)
               return nullptr;

lldb/source/Plugins/Language/Swift/SwiftMetatype.cpp

@@ -22,7 +22,7 @@ using namespace lldb_private::formatters::swift;
 bool lldb_private::formatters::swift::SwiftMetatype_SummaryProvider(
     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
   ConstString name;
-  lldb::addr_t metadata_ptr = valobj.GetPointerValue();
+  lldb::addr_t metadata_ptr = valobj.GetPointerValue().address;
   if (metadata_ptr == LLDB_INVALID_ADDRESS || metadata_ptr == 0) {
     CompilerType compiler_metatype_type(valobj.GetCompilerType());
     ExecutionContext exe_ctx = valobj.GetExecutionContextRef();

lldb/source/Plugins/Language/Swift/SwiftOptional.cpp

@@ -86,16 +86,18 @@ ExtractSomeIfAny(ValueObject *optional,
     if (kind == TypeSystemSwift::NonTriviallyManagedReferenceKind::eWeak &&
         runtime->IsObjCInstance(valobj))
       return ValueObjectCast::Create(
-          valobj, valobj.GetPointerValue() ? g_some : g_none, projected_type);
+          valobj, valobj.GetPointerValue().address ? g_some : g_none,
+          projected_type);
 
     // Unowned/strong reference.
     if (kind != TypeSystemSwift::NonTriviallyManagedReferenceKind::eWeak)
       return ValueObjectCast::Create(
-          valobj, valobj.GetPointerValue() ? g_some : g_none, projected_type);
+          valobj, valobj.GetPointerValue().address ? g_some : g_none,
+          projected_type);
 
     Status error;
-    lldb::addr_t ptr =
-        runtime->FixupAddress(valobj.GetPointerValue(), projected_type, error);
+    lldb::addr_t ptr = runtime->FixupAddress(valobj.GetPointerValue().address,
+                                             projected_type, error);
     // Needed for resilience.
     ptr = runtime->MaskMaybeBridgedPointer(ptr);
     auto exe_ctx = valobj.GetExecutionContextRef().Lock(true);
@@ -155,7 +157,7 @@ ExtractSomeIfAny(ValueObject *optional,
     if (!projected_type)
       return {};
     return ValueObjectCast::Create(
-        *optional, optional->GetPointerValue() ? g_some : g_none,
+        *optional, optional->GetPointerValue().address ? g_some : g_none,
         projected_type);
   }
   if (!*projected)

lldb/source/Plugins/LanguageRuntime/Swift/SwiftLanguageRuntimeDynamicTypeResolution.cpp

@@ -1206,7 +1206,7 @@ SwiftRuntimeTypeVisitor::VisitImpl(std::optional<unsigned> visit_only,
 
     LLDBTypeInfoProvider tip(m_runtime, ts);
     lldb::addr_t instance = ::MaskMaybeBridgedPointer(
-        m_runtime.GetProcess(), m_valobj->GetPointerValue());
+        m_runtime.GetProcess(), m_valobj->GetPointerValue().address);
 
     // Try out the instance pointer based super class traversal first, as its
     // usually faster.
@@ -1486,8 +1486,8 @@ SwiftLanguageRuntime::ProjectEnum(ValueObject &valobj) {
 
   auto project_indirect_enum =
       [&](uint64_t offset, std::string name) -> llvm::Expected<ValueObjectSP> {
-    lldb::addr_t pointer =
-        ::MaskMaybeBridgedPointer(GetProcess(), valobj.GetPointerValue());
+    lldb::addr_t pointer = ::MaskMaybeBridgedPointer(
+        GetProcess(), valobj.GetPointerValue().address);
     lldb::addr_t payload = pointer + offset;
 
     ThreadSafeReflectionContext reflection_ctx = GetReflectionContext();
@@ -1538,8 +1538,7 @@ SwiftLanguageRuntime::ProjectEnum(ValueObject &valobj) {
 
   // Prepare to project the enum to get the active case.
   MemoryReaderLocalBufferHolder holder;
-  AddressType address_type;
-  lldb::addr_t addr = valobj.GetAddressOf(false, &address_type);
+  auto [addr, address_type] = valobj.GetAddressOf(false);
   if (addr == LLDB_INVALID_ADDRESS || addr == 0) {
     Value &value = valobj.GetValue();
     switch (value.GetValueType()) {
@@ -1710,7 +1709,7 @@ bool SwiftLanguageRuntime::ForEachSuperClassType(
 
   ExecutionContext exe_ctx(instance.GetExecutionContextRef());
   LLDBTypeInfoProvider tip(*this, ts);
-  lldb::addr_t pointer = instance.GetPointerValue();
+  lldb::addr_t pointer = instance.GetPointerValue().address;
   return reflection_ctx->ForEachSuperClassType(&tip, ts.GetDescriptorFinder(),
                                                pointer, fn);
 }
@@ -2018,8 +2017,7 @@ bool SwiftLanguageRuntime::GetDynamicTypeAndAddress_Pack(
   }
   pack_type_or_name.SetCompilerType(*expanded_type);
 
-  AddressType address_type;
-  lldb::addr_t addr = in_value.GetAddressOf(true, &address_type);
+  auto [addr, address_type] = in_value.GetAddressOf(true);
   value_type = Value::GetValueTypeFromAddressType(address_type);
   if (indirect) {
     Status status;
@@ -2075,8 +2073,7 @@ bool SwiftLanguageRuntime::GetDynamicTypeAndAddress_Class(
     lldb::DynamicValueType use_dynamic, TypeAndOrName &class_type_or_name,
     Address &address, Value::ValueType &value_type,
     llvm::ArrayRef<uint8_t> &local_buffer) {
-  AddressType address_type;
-  lldb::addr_t instance_ptr = in_value.GetPointerValue(&address_type);
+  auto [instance_ptr, address_type] = in_value.GetPointerValue();
   value_type = Value::GetValueTypeFromAddressType(address_type);
 
   if (instance_ptr == LLDB_INVALID_ADDRESS || instance_ptr == 0)
@@ -2283,7 +2280,7 @@ bool SwiftLanguageRuntime::GetDynamicTypeAndAddress_Existential(
     existential_address = in_value.GetValue().GetScalar().ULongLong();
     use_local_buffer = true;
   } else {
-    existential_address = in_value.GetAddressOf();
+    existential_address = in_value.GetAddressOf().address;
   }
 
   if (log)
@@ -2405,8 +2402,7 @@ bool SwiftLanguageRuntime::GetDynamicTypeAndAddress_ExistentialMetatype(
     lldb::DynamicValueType use_dynamic, TypeAndOrName &class_type_or_name,
     Address &address) {
   // Resolve the dynamic type of the metatype.
-  AddressType address_type;
-  lldb::addr_t ptr = in_value.GetPointerValue(&address_type);
+  auto [ptr, address_type] = in_value.GetPointerValue();
   if (ptr == LLDB_INVALID_ADDRESS || ptr == 0)
     return false;
 
@@ -2761,8 +2757,7 @@ bool SwiftLanguageRuntime::GetDynamicTypeAndAddress_Value(
       bound_type.GetByteSize(exe_ctx.GetBestExecutionContextScope()));
   if (!size)
     return false;
-  AddressType address_type;
-  lldb::addr_t val_address = in_value.GetAddressOf(true, &address_type);
+  auto [val_address, address_type] = in_value.GetAddressOf(true);
   // If we couldn't find a load address, but the value object has a local
   // buffer, use that.
   if (val_address == LLDB_INVALID_ADDRESS && address_type == eAddressTypeHost) {
@@ -2832,7 +2827,7 @@ Value::ValueType SwiftLanguageRuntime::GetValueType(
         existential_address = in_value.GetValue().GetScalar().ULongLong();
         use_local_buffer = true;
       } else {
-        existential_address = in_value.GetAddressOf();
+        existential_address = in_value.GetAddressOf().address;
       }
 
       MemoryReaderLocalBufferHolder holder;
@@ -3008,7 +3003,7 @@ bool SwiftLanguageRuntime::GetDynamicTypeAndAddress_ClangType(
     std::string type_name =
         (llvm::Twine(swift_class.module) + "." + swift_class.identifier).str();
     dyn_class_type_or_name.SetName(type_name.data());
-    address.SetRawAddress(in_value.GetPointerValue());
+    address.SetRawAddress(in_value.GetPointerValue().address);
   } else {
     swift_class.module = swift::MANGLING_MODULE_OBJC;
     swift_class.identifier = dyn_name;

lldb/source/Plugins/LanguageRuntime/Swift/SwiftLanguageRuntimeRemoteAST.cpp

@@ -115,7 +115,7 @@ std::optional<uint64_t> SwiftLanguageRuntime::GetMemberVariableOffsetRemoteAST(
               "get metadata for valueobject %s",
               (instance ? instance->GetName().AsCString() : "<null>"));
     if (instance) {
-      lldb::addr_t pointer = instance->GetPointerValue();
+      lldb::addr_t pointer = instance->GetPointerValue().address;
       if (!pointer || pointer == LLDB_INVALID_ADDRESS)
         break;
       auto address = swift::remote::RemoteAddress(

lldb/source/Plugins/TypeSystem/Swift/SwiftASTContext.cpp

@@ -1781,7 +1781,8 @@ static void applyOverrideOptions(std::vector<std::string> &args,
   }};
 
   clang::driver::applyOverrideOptions(raw_args, overrideOpts.data(),
-                                      savedStrings, &log_stream);
+                                      savedStrings, "CCC_OVERRIDE_OPTIONS",
+                                      &log_stream);
 
   // Delete the placeholder "clang" executable argument.
   raw_args.erase(raw_args.begin());
@@ -2946,7 +2947,7 @@ lldb::TypeSystemSP SwiftASTContext::CreateInstance(
             os << llvm::Triple::getOSTypeName(preferred_triple.getOS());
             os << platform_version.getAsString();
           }
-          computed_triple = llvm::Triple(buffer);
+          computed_triple = llvm::Triple(buffer.data());
         } else if (preferred_triple.getObjectFormat() == llvm::Triple::MachO) {
           LOG_PRINTF(GetLog(LLDBLog::Types),
                      "Completing triple based on main binary load commands.");