Merge pull request #10961 from AnthonyLatsis/stable/20250601

[stable/20250601][Swift] lldb: Fix some build errors

Author: AnthonyLatsis

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

@@ -675,13 +675,16 @@ class URLComponentsSyntheticChildrenFrontEnd
       m_synth_frontend_up->Update();
 
 #define COMPONENT(Name, PrettyName, ID)                                        \
-  auto index_or_err = m_synth_frontend_up->GetIndexOfChildWithName(g__##Name); \
-  if (!index_or_err) {                                                         \
-    LLDB_LOG_ERROR(GetLog(LLDBLog::DataFormatters), index_or_err.takeError(),  \
-                   "{0}");                                                     \
-    return ChildCacheState::eRefetch;                                          \
+  {                                                                            \
+    auto index_or_err =                                                        \
+        m_synth_frontend_up->GetIndexOfChildWithName(g__##Name);               \
+    if (!index_or_err) {                                                       \
+      LLDB_LOG_ERROR(GetLog(LLDBLog::DataFormatters),                          \
+                     index_or_err.takeError(), "{0}");                         \
+      return ChildCacheState::eRefetch;                                        \
+    }                                                                          \
+    m_##Name = m_synth_frontend_up->GetChildAtIndex(*index_or_err).get();      \
   }                                                                            \
-  m_##Name = m_synth_frontend_up->GetChildAtIndex(*index_or_err).get();        \
   if (m_##Name)                                                                \
     m_##Name->SetName(GetNameFor##Name());
 #include "URLComponents.def"

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

@@ -559,11 +559,12 @@ llvm::Expected<size_t> lldb_private::formatters::swift::ArraySyntheticFrontEnd::
     return llvm::createStringError("Type has no child named '%s'",
                                    name.AsCString());
   const char *item_name = name.GetCString();
-  uint32_t idx = ExtractIndexFromString(item_name);
-  if (idx == UINT32_MAX || idx >= CalculateNumChildrenIgnoringErrors())
+  auto optional_idx = ExtractIndexFromString(item_name);
+  if (!optional_idx ||
+      optional_idx.value() >= CalculateNumChildrenIgnoringErrors())
     return llvm::createStringError("Type has no child named '%s'",
                                    name.AsCString());
-  return idx;
+  return optional_idx.value();
 }
 
 SyntheticChildrenFrontEnd *

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

@@ -747,9 +747,10 @@ HashedSyntheticChildrenFrontEnd::GetIndexOfChildWithName(ConstString name) {
     return llvm::createStringError("Type has no child named '%s'",
                                    name.AsCString());
   const char *item_name = name.GetCString();
-  uint32_t idx = ExtractIndexFromString(item_name);
-  if (idx == UINT32_MAX || idx >= CalculateNumChildrenIgnoringErrors())
+  auto optional_idx = ExtractIndexFromString(item_name);
+  if (!optional_idx ||
+      optional_idx.value() >= CalculateNumChildrenIgnoringErrors())
     return llvm::createStringError("Type has no child named '%s'",
                                    name.AsCString());
-  return idx;
+  return optional_idx.value();
 }

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

@@ -1703,54 +1703,54 @@ bool SwiftLanguage::IsUninitializedReference(ValueObject &valobj) {
 }
 
 bool SwiftLanguage::GetFunctionDisplayName(
-    const SymbolContext *sc, const ExecutionContext *exe_ctx,
+    const SymbolContext &sc, const ExecutionContext *exe_ctx,
     FunctionNameRepresentation representation, Stream &s) {
   switch (representation) {
   case Language::FunctionNameRepresentation::eName:
     // No need to customize this.
     return false;
   case Language::FunctionNameRepresentation::eNameWithNoArgs: {
-    if (!sc->function)
+    if (!sc.function)
       return false;
-    if (sc->function->GetLanguage() != eLanguageTypeSwift)
+    if (sc.function->GetLanguage() != eLanguageTypeSwift)
       return false;
     std::string display_name = SwiftLanguageRuntime::DemangleSymbolAsString(
-        sc->function->GetMangled().GetMangledName().GetStringRef(),
-        SwiftLanguageRuntime::eSimplified, sc, exe_ctx);
+        sc.function->GetMangled().GetMangledName().GetStringRef(),
+        SwiftLanguageRuntime::eSimplified, &sc, exe_ctx);
     if (display_name.empty())
       return false;
     s << display_name;
     return true;
   }
   case Language::FunctionNameRepresentation::eNameWithArgs: {
-    if (!sc->function)
+    if (!sc.function)
       return false;
-    if (sc->function->GetLanguage() != eLanguageTypeSwift)
+    if (sc.function->GetLanguage() != eLanguageTypeSwift)
       return false;
     std::string display_name = SwiftLanguageRuntime::DemangleSymbolAsString(
-        sc->function->GetMangled().GetMangledName().GetStringRef(),
-        SwiftLanguageRuntime::eSimplified, sc, exe_ctx);
+        sc.function->GetMangled().GetMangledName().GetStringRef(),
+        SwiftLanguageRuntime::eSimplified, &sc, exe_ctx);
     if (display_name.empty())
       return false;
     ExecutionContextScope *exe_scope =
         exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL;
     const InlineFunctionInfo *inline_info = NULL;
     VariableListSP variable_list_sp;
     bool get_function_vars = true;
-    if (sc->block) {
-      Block *inline_block = sc->block->GetContainingInlinedBlock();
+    if (sc.block) {
+      Block *inline_block = sc.block->GetContainingInlinedBlock();
 
       if (inline_block) {
         get_function_vars = false;
-        inline_info = sc->block->GetInlinedFunctionInfo();
+        inline_info = sc.block->GetInlinedFunctionInfo();
         if (inline_info)
           variable_list_sp = inline_block->GetBlockVariableList(true);
       }
     }
 
     if (get_function_vars) {
       variable_list_sp =
-          sc->function->GetBlock(true).GetBlockVariableList(true);
+          sc.function->GetBlock(true).GetBlockVariableList(true);
     }
 
     if (inline_info) {

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

@@ -64,7 +64,7 @@ class SwiftLanguage : public Language {
 
   bool IsUninitializedReference(ValueObject &valobj) override;
 
-  bool GetFunctionDisplayName(const SymbolContext *sc,
+  bool GetFunctionDisplayName(const SymbolContext &sc,
                               const ExecutionContext *exe_ctx,
                               FunctionNameRepresentation representation,
                               Stream &s) override;

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

@@ -214,7 +214,7 @@ LLDBMemoryReader::resolvePointerAsSymbol(swift::remote::RemoteAddress address) {
     // aware of local symbols, so avoid returning those.
     using namespace swift::Demangle;
     if (isSwiftSymbol(mangledName) && !isOldFunctionTypeMangling(mangledName))
-      return {{mangledName, 0}};
+      return swift::remote::RemoteAbsolutePointer{mangledName, 0, address};
   }
 
   return {};
@@ -228,15 +228,16 @@ LLDBMemoryReader::resolvePointer(swift::remote::RemoteAddress address,
   // We may have gotten a pointer to a process address, try to map it back
   // to a tagged address so further memory reads originating from it benefit
   // from the file-cache optimization.
-  swift::remote::RemoteAbsolutePointer process_pointer("", readValue);
+  swift::remote::RemoteAbsolutePointer process_pointer{
+      swift::remote::RemoteAddress{readValue}};
 
   if (!readMetadataFromFileCacheEnabled())
     return process_pointer;
 
   // Try to strip the pointer before checking if we have it mapped.
   auto strippedPointer = signedPointerStripper(process_pointer);
-  if (strippedPointer.isResolved())
-    readValue = strippedPointer.getOffset();
+  if (auto resolved = strippedPointer.getResolvedAddress())
+    readValue = resolved.getAddressData();
 
   auto &target = m_process.GetTarget();
   Address addr;
@@ -294,9 +295,12 @@ LLDBMemoryReader::resolvePointer(swift::remote::RemoteAddress address,
     return process_pointer;
   }
 
-  swift::remote::RemoteAbsolutePointer tagged_pointer("", tagged_address);
-  if (tagged_address !=
-      (uint64_t)signedPointerStripper(tagged_pointer).getOffset()) {
+  swift::remote::RemoteAbsolutePointer tagged_pointer{
+      swift::remote::RemoteAddress{tagged_address}};
+
+  if (tagged_address != (uint64_t)signedPointerStripper(tagged_pointer)
+                            .getResolvedAddress()
+                            .getAddressData()) {
     lldbassert(false &&
                "Tagged pointer runs into pointer authentication mask!");
     return process_pointer;
@@ -528,9 +532,11 @@ LLDBMemoryReader::addModuleToAddressMap(ModuleSP module,
   auto module_end_address = module_start_address + size;
 
   if (module_end_address !=
-      (uint64_t)signedPointerStripper(
-          swift::remote::RemoteAbsolutePointer("", module_end_address))
-          .getOffset()) {
+      signedPointerStripper(
+          swift::remote::RemoteAbsolutePointer{
+              swift::remote::RemoteAddress{module_end_address}})
+          .getResolvedAddress()
+          .getAddressData()) {
     LLDB_LOG(GetLog(LLDBLog::Types),
              "[MemoryReader] module to address map ran into pointer "
              "authentication mask!");

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

@@ -1176,8 +1176,7 @@ void SwiftLanguageRuntime::FindFunctionPointersInCall(
             if (target_context.symbol)
               fn_ptr_address = target_context.symbol->GetAddress();
             else if (target_context.function)
-              fn_ptr_address =
-                  target_context.function->GetAddressRange().GetBaseAddress();
+              fn_ptr_address = target_context.function->GetAddress();
           }
         }
       }
@@ -1602,13 +1601,14 @@ class ProjectionSyntheticChildren : public SyntheticChildren {
       return nullptr;
     }
 
-    size_t GetIndexOfChildWithName(ConstString name) override {
+    llvm::Expected<size_t> GetIndexOfChildWithName(ConstString name) override {
       for (size_t idx = 0; idx < m_projection->field_projections.size();
            idx++) {
         if (m_projection->field_projections.at(idx).name == name)
           return idx;
       }
-      return UINT32_MAX;
+      return llvm::createStringError("Type has no child named '%s'",
+                                     name.AsCString());
     }
 
     lldb::ChildCacheState Update() override {
@@ -2486,7 +2486,7 @@ static llvm::Expected<addr_t> ReadPtrFromAddr(Process &process, addr_t addr,
 /// access to those here would be challenging.
 static llvm::Expected<addr_t> GetCFA(Process &process, RegisterContext &regctx,
                                      addr_t pc_offset,
-                                     UnwindPlan &unwind_plan) {
+                                     const UnwindPlan &unwind_plan) {
   auto *row = unwind_plan.GetRowForFunctionOffset(pc_offset);
   if (!row)
     return llvm::createStringError(
@@ -2516,22 +2516,22 @@ static llvm::Expected<addr_t> GetCFA(Process &process, RegisterContext &regctx,
       cfa_loc.GetValueType());
 }
 
-static UnwindPlanSP GetUnwindPlanForAsyncRegister(FuncUnwinders &unwinders,
-                                                  Target &target,
-                                                  Thread &thread) {
+static std::shared_ptr<const UnwindPlan>
+GetUnwindPlanForAsyncRegister(FuncUnwinders &unwinders, Target &target,
+                              Thread &thread) {
   // We cannot trust compiler emitted unwind plans, as they respect the
   // swifttail calling convention, which assumes the async register is _not_
   // restored and therefore it is not tracked by compiler plans. If LLDB uses
   // those plans, it may take "no info" to mean "register not clobbered". For
   // those reasons, always favour the assembly plan first, it will try to track
   // the async register by assuming the usual arm calling conventions.
-  if (UnwindPlanSP asm_plan = unwinders.GetAssemblyUnwindPlan(target, thread))
+  if (auto asm_plan = unwinders.GetAssemblyUnwindPlan(target, thread))
     return asm_plan;
   // In the unlikely case the assembly plan is not available, try all others.
   return unwinders.GetUnwindPlanAtNonCallSite(target, thread);
 }
 
-static llvm::Expected<UnwindPlanSP>
+static llvm::Expected<std::shared_ptr<const UnwindPlan>>
 GetAsmUnwindPlan(Address pc, SymbolContext &sc, Thread &thread) {
   FuncUnwindersSP unwinders =
       pc.GetModule()->GetUnwindTable().GetFuncUnwindersContainingAddress(pc,
@@ -2541,7 +2541,7 @@ GetAsmUnwindPlan(Address pc, SymbolContext &sc, Thread &thread) {
                                    "function unwinder at address 0x%8.8" PRIx64,
                                    pc.GetFileAddress());
 
-  UnwindPlanSP unwind_plan = GetUnwindPlanForAsyncRegister(
+  auto unwind_plan = GetUnwindPlanForAsyncRegister(
       *unwinders, thread.GetProcess()->GetTarget(), thread);
   if (!unwind_plan)
     return llvm::createStringError(
@@ -2551,8 +2551,8 @@ GetAsmUnwindPlan(Address pc, SymbolContext &sc, Thread &thread) {
   return unwind_plan;
 }
 
-static llvm::Expected<uint32_t> GetFpRegisterNumber(UnwindPlan &unwind_plan,
-                                                    RegisterContext &regctx) {
+static llvm::Expected<uint32_t>
+GetFpRegisterNumber(const UnwindPlan &unwind_plan, RegisterContext &regctx) {
   uint32_t fp_unwind_regdomain;
   if (!regctx.ConvertBetweenRegisterKinds(
           lldb::eRegisterKindGeneric, LLDB_REGNUM_GENERIC_FP,
@@ -2569,7 +2569,7 @@ static llvm::Expected<uint32_t> GetFpRegisterNumber(UnwindPlan &unwind_plan,
 }
 
 struct FrameSetupInfo {
-  addr_t frame_setup_func_offset;
+  int64_t frame_setup_func_offset;
   int fp_cfa_offset;
 };
 
@@ -2580,7 +2580,7 @@ struct FrameSetupInfo {
 /// compared against it.
 /// 2. The CFA offset at which FP is stored, meaningless in the frameless case.
 static llvm::Expected<FrameSetupInfo>
-GetFrameSetupInfo(UnwindPlan &unwind_plan, RegisterContext &regctx) {
+GetFrameSetupInfo(const UnwindPlan &unwind_plan, RegisterContext &regctx) {
   using AbstractRegisterLocation = UnwindPlan::Row::AbstractRegisterLocation;
 
   llvm::Expected<uint32_t> fp_unwind_regdomain =
@@ -2610,7 +2610,7 @@ GetFrameSetupInfo(UnwindPlan &unwind_plan, RegisterContext &regctx) {
   // This is a frameless function, use large positive offset so that a PC can
   // still be compared against it.
   if (it == fp_locs.end())
-    return FrameSetupInfo{std::numeric_limits<addr_t>::max(), 0};
+    return FrameSetupInfo{std::numeric_limits<int64_t>::max(), 0};
 
   // This is an async function with a frame. The prologue roughly follows this
   // sequence of instructions:
@@ -2645,7 +2645,7 @@ GetFrameSetupInfo(UnwindPlan &unwind_plan, RegisterContext &regctx) {
 static llvm::Expected<addr_t> ReadAsyncContextRegisterFromUnwind(
     SymbolContext &sc, Process &process, Address pc, Address func_start_addr,
     RegisterContext &regctx, AsyncUnwindRegisterNumbers regnums) {
-  llvm::Expected<UnwindPlanSP> unwind_plan =
+  llvm::Expected<std::shared_ptr<const UnwindPlan>> unwind_plan =
       GetAsmUnwindPlan(pc, sc, regctx.GetThread());
   if (!unwind_plan)
     return unwind_plan.takeError();
@@ -2657,7 +2657,7 @@ static llvm::Expected<addr_t> ReadAsyncContextRegisterFromUnwind(
   // Is PC before the frame formation? If so, use async register directly.
   // This handles frameless functions, as frame_setup_func_offset is INT_MAX.
   addr_t pc_offset = pc.GetFileAddress() - func_start_addr.GetFileAddress();
-  if (pc_offset < frame_setup->frame_setup_func_offset)
+  if ((int64_t)pc_offset < frame_setup->frame_setup_func_offset)
     return ReadRegisterAsAddress(regctx, regnums.GetRegisterKind(),
                                  regnums.async_ctx_regnum);
 
@@ -2688,9 +2688,11 @@ DoesContinuationPointToSameFunction(addr_t async_reg, SymbolContext &sc,
   Address continuation_addr;
   continuation_addr.SetLoadAddress(process.FixCodeAddress(*continuation_ptr),
                                    &process.GetTarget());
-  if (sc.function)
-    return sc.function->GetAddressRange().ContainsLoadAddress(
-        continuation_addr, &process.GetTarget());
+  if (sc.function) {
+    AddressRange unused_range;
+    return sc.function->GetRangeContainingLoadAddress(
+        continuation_addr.GetOffset(), process.GetTarget(), unused_range);
+  }
   assert(sc.symbol);
   return sc.symbol->ContainsFileAddress(continuation_addr.GetFileAddress());
 }
@@ -2724,8 +2726,7 @@ static llvm::Expected<bool> IsIndirectContext(Process &process,
   uint32_t prologue_size = sc.function ? sc.function->GetPrologueByteSize()
                                        : sc.symbol->GetPrologueByteSize();
   Address func_start_addr =
-      sc.function ? sc.function->GetAddressRange().GetBaseAddress()
-                  : sc.symbol->GetAddress();
+      sc.function ? sc.function->GetAddress() : sc.symbol->GetAddress();
   // Include one instruction after the prologue. This is where breakpoints
   // by function name are set, so it's important to get this point right. This
   // instruction is exactly at address "base + prologue", so adding 1
@@ -2776,7 +2777,7 @@ SwiftLanguageRuntime::GetRuntimeUnwindPlan(ProcessSP process_sp,
   Address func_start_addr;
   ConstString mangled_name;
   if (sc.function) {
-    func_start_addr = sc.function->GetAddressRange().GetBaseAddress();
+    func_start_addr = sc.function->GetAddress();
     mangled_name = sc.function->GetMangled().GetMangledName();
   } else if (sc.symbol) {
     func_start_addr = sc.symbol->GetAddress();

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

@@ -2077,10 +2077,11 @@ CompilerType SwiftLanguageRuntime::GetDynamicTypeAndAddress_EmbeddedClass(
   if (!pointer)
     return {};
   llvm::StringRef symbol_name;
-  if (pointer->isResolved()) {
+  if (pointer->getSymbol().empty() || pointer->getOffset()) {
     // Find the symbol name at this address.
     Address address;
-    address.SetLoadAddress(pointer->getOffset(), &GetProcess().GetTarget());
+    address.SetLoadAddress(pointer->getResolvedAddress().getAddressData(),
+                           &GetProcess().GetTarget());
     Symbol *symbol = address.CalculateSymbolContextSymbol();
     if (!symbol)
       return {};
@@ -2377,8 +2378,9 @@ bool SwiftLanguageRuntime::GetDynamicTypeAndAddress_Existential(
       return false;
 
     uint64_t address = 0;
-    if (maybe_addr_or_symbol->isResolved()) {
-      address = maybe_addr_or_symbol->getOffset();
+    if (maybe_addr_or_symbol->getSymbol().empty() &&
+        maybe_addr_or_symbol->getOffset() == 0) {
+      address = maybe_addr_or_symbol->getResolvedAddress().getAddressData();
     } else {
       SymbolContextList sc_list;
       auto &module_list = GetProcess().GetTarget().GetImages();
@@ -2397,7 +2399,7 @@ bool SwiftLanguageRuntime::GetDynamicTypeAndAddress_Existential(
         GetDynamicTypeAndAddress_EmbeddedClass(address, existential_type);
     if (!dynamic_type)
       return false;
-    dynamic_address = maybe_addr_or_symbol->getOffset();
+    dynamic_address = maybe_addr_or_symbol->getResolvedAddress().getAddressData();
   }
   if (use_local_buffer)
     PopLocalBuffer();