[lldb][Target] Refactor Target::FindLoadAddr

`Target::FindLoadAddrForNameInSymbolsAndPersistentVariables` has been
split into `Target::FindLoadAddrForNameInSymbols` and
`Target::FindLoadAddrForNameInPersistentVariables`. Instead of
performing both searches in one function,
`Target::FindLoadAddrForNameInSymbolsAndPersistentVariables` will call
its constituent functions.

This allows `SwiftLanguageRuntime::FindSymbolForSwiftObject` to look for symbols
with `Target::FindLoadAddrForNameInSymbols` instead of performing this
search on its own.

rdar://32228544

Author: chelcassanova

lldb/include/lldb/Target/Target.h

@@ -1355,6 +1355,12 @@ class Target : public std::enable_shared_from_this<Target>,
       const EvaluateExpressionOptions &options = EvaluateExpressionOptions(),
       std::string *fixed_expression = nullptr, ValueObject *ctx_obj = nullptr);
 
+  lldb::addr_t FindLoadAddrForNameInSymbols(
+      ConstString name_const_str, lldb::SymbolType symbol_type);
+
+  lldb::addr_t FindLoadAddrForNameInPersistentVariables(
+    ConstString name_const_str, lldb::SymbolType symbol_type);
+
   // Look up a symbol by name and type in both the target's symbols and the
   // persistent symbols from the
   // expression parser.  The symbol_type is ignored in that case, for now we

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

@@ -180,19 +180,9 @@ FindSymbolForSwiftObject(Process &process, RuntimeKind runtime_kind,
     return {};
   }
 
-  SymbolContextList sc_list;
-  image->FindSymbolsWithNameAndType(ConstString(object), sym_type, sc_list);
-  if (sc_list.GetSize() != 1)
-    return {};
-
-  SymbolContext SwiftObject_Class;
-  if (!sc_list.GetContextAtIndex(0, SwiftObject_Class))
-    return {};
-  if (!SwiftObject_Class.symbol)
-    return {};
   lldb::addr_t addr =
-      SwiftObject_Class.symbol->GetAddress().GetLoadAddress(&target);
-  if (addr && addr != LLDB_INVALID_ADDRESS)
+      target.FindLoadAddrForNameInSymbols(ConstString(object), sym_type);
+  if (addr != LLDB_INVALID_ADDRESS)
     return addr;
 
   return {};

lldb/source/Target/Target.cpp

@@ -3693,8 +3693,8 @@ bool Target::SetSectionUnloaded(const lldb::SectionSP &section_sp,
 
 void Target::ClearAllLoadedSections() { m_section_load_history.Clear(); }
 
-lldb::addr_t Target::FindLoadAddrForNameInSymbolsAndPersistentVariables(
-    ConstString name_const_str, SymbolType symbol_type) {
+lldb::addr_t Target::FindLoadAddrForNameInSymbols(ConstString name_const_str,
+                                                  SymbolType symbol_type) {
   lldb::addr_t symbol_addr = LLDB_INVALID_ADDRESS;
   SymbolContextList sc_list;
 
@@ -3720,25 +3720,43 @@ lldb::addr_t Target::FindLoadAddrForNameInSymbolsAndPersistentVariables(
       }
     }
   }
+  return symbol_addr;
+}
 
-  if (symbol_addr == LLDB_INVALID_ADDRESS) {
-    // If we didn't find it in the symbols, check the ClangPersistentVariables,
-    // 'cause we may have
-    // made it by hand.
-    ConstString mangled_const_str;
-    if (name_const_str.GetMangledCounterpart(mangled_const_str))
-      symbol_addr = GetPersistentSymbol(mangled_const_str);
+lldb::addr_t
+Target::FindLoadAddrForNameInPersistentVariables(ConstString name_const_str,
+                                                 lldb::SymbolType symbol_type) {
+  lldb::addr_t symbol_addr = LLDB_INVALID_ADDRESS;
+  ConstString mangled_const_str;
+
+  if (name_const_str.GetMangledCounterpart(mangled_const_str)) {
+    symbol_addr = GetPersistentSymbol(mangled_const_str);
   }
 
+  // Check in persistent variables using the name that was passed in
   if (symbol_addr == LLDB_INVALID_ADDRESS) {
-    // Let's try looking for the name passed-in itself, as it might be a mangled
-    // name
     symbol_addr = GetPersistentSymbol(name_const_str);
   }
 
   return symbol_addr;
 }
 
+lldb::addr_t Target::FindLoadAddrForNameInSymbolsAndPersistentVariables(
+    ConstString name_const_str, SymbolType symbol_type) {
+  lldb::addr_t symbol_addr = LLDB_INVALID_ADDRESS;
+
+  // Try to find the name in the symbol list
+  symbol_addr =
+      Target::FindLoadAddrForNameInSymbols(name_const_str, symbol_type);
+
+  // If that doesn't work, look for it in persistent variables
+  if (symbol_addr == LLDB_INVALID_ADDRESS)
+    Target::FindLoadAddrForNameInPersistentVariables(name_const_str,
+                                                     symbol_type);
+
+  return symbol_addr;
+}
+
 void Target::SaveScriptedLaunchInfo(lldb_private::ProcessInfo &process_info) {
   if (process_info.IsScriptedProcess()) {
     // Only copy scripted process launch options.