[lldb] Delete IRExecutionUnit::SearchSpec

[bulbazord]

Summary

IRExecutionUnit::SearchSpec is a struct that encapsulates information
needed to look for a symbol. Specifically, it is comprised of a name
represented with a ConstString and a FunctionNameType mask.
Because the mask is unused (effectively always set to
eFunctionNameTypeFull), we can remove the mask and replace all uses with
eFunctionNameTypeFull. After doing that, SearchSpec is effectively a
wrapper around a ConstString.

As an aside, SearchSpec is similar in purpose to Module::LookupInfo. I
briefly considered replacing uses of SearchSpec with LookupInfo, but
the current code only cares about symbol names (treating them as
eFunctionNameTypeFull). This code does care about language type, so
LookupInfo may be appropriate for IRExecutionUnit in the future.

[clayborg]

Looks fine to me. I will let others that specialize more in the expression evaluator accept this., though it would be good to verify this code looks the same in the Swift branches

[JDevlieghere]

LGTM

lldb/include/lldb/Expression/IRExecutionUnit.h

private:
   ///     The process containing the allocations.
   ///
   /// \return
   ///     True <=> all allocations were performed successfully.
   bool WriteData(lldb::ProcessSP &process_sp);
 
   Status DisassembleFunction(Stream &stream, lldb::ProcessSP &process_sp);
 
-  struct SearchSpec;
-
-  void CollectCandidateCNames(std::vector<SearchSpec> &C_specs,
+  void CollectCandidateCNames(std::vector<ConstString> &C_names,
                               ConstString name);
 
-  void CollectCandidateCPlusPlusNames(std::vector<SearchSpec> &CPP_specs,
-                                      const std::vector<SearchSpec> &C_specs,
+  void CollectCandidateCPlusPlusNames(std::vector<ConstString> &CPP_names,
+                                      const std::vector<ConstString> &C_names,
                                       const SymbolContext &sc);
 
-  void CollectFallbackNames(std::vector<SearchSpec> &fallback_specs,
-                            const std::vector<SearchSpec> &C_specs);
+  void CollectFallbackNames(std::vector<ConstString> &fallback_names,
+                            const std::vector<ConstString> &C_names);
 
-  lldb::addr_t FindInSymbols(const std::vector<SearchSpec> &specs,
+  lldb::addr_t FindInSymbols(const std::vector<ConstString> &names,
                              const lldb_private::SymbolContext &sc,
                              bool &symbol_was_missing_weak);
 
-  lldb::addr_t FindInRuntimes(const std::vector<SearchSpec> &specs,
+  lldb::addr_t FindInRuntimes(const std::vector<ConstString> &names,
                               const lldb_private::SymbolContext &sc);
 
-  lldb::addr_t FindInUserDefinedSymbols(const std::vector<SearchSpec> &specs,
+  lldb::addr_t FindInUserDefinedSymbols(const std::vector<ConstString> &names,
                                         const lldb_private::SymbolContext &sc);
 
   void ReportSymbolLookupError(ConstString name);
 
   class MemoryManager : public llvm::SectionMemoryManager {
   public:
     MemoryManager(IRExecutionUnit &parent);
 

lldb/source/Expression/IRExecutionUnit.cpp

if (param_and_qual_matches.size())
     return param_and_qual_matches[0]; // It is assumed that there will be only
                                       // one!
   else if (param_matches.size())
     return param_matches[0]; // Return one of them as a best match
   else
     return ConstString();
 }
 
-struct IRExecutionUnit::SearchSpec {
-  ConstString name;
-  lldb::FunctionNameType mask;
-
-  SearchSpec(ConstString n,
-             lldb::FunctionNameType m = lldb::eFunctionNameTypeFull)
-      : name(n), mask(m) {}
-};
-
-void IRExecutionUnit::CollectCandidateCNames(
-    std::vector<IRExecutionUnit::SearchSpec> &C_specs,
+void IRExecutionUnit::CollectCandidateCNames(std::vector<ConstString> &C_names,
                                              ConstString name) {
   if (m_strip_underscore && name.AsCString()[0] == '_')
-    C_specs.insert(C_specs.begin(), ConstString(&name.AsCString()[1]));
-  C_specs.push_back(SearchSpec(name));
+    C_names.insert(C_names.begin(), ConstString(&name.AsCString()[1]));
+  C_names.push_back(name);
 }
 
 void IRExecutionUnit::CollectCandidateCPlusPlusNames(
-    std::vector<IRExecutionUnit::SearchSpec> &CPP_specs,
-    const std::vector<SearchSpec> &C_specs, const SymbolContext &sc) {
-  for (const SearchSpec &C_spec : C_specs) {
-    ConstString name = C_spec.name;
-
+    std::vector<ConstString> &CPP_names,
+    const std::vector<ConstString> &C_names, const SymbolContext &sc) {
+  for (const ConstString &name : C_names) {
     if (CPlusPlusLanguage::IsCPPMangledName(name.GetCString())) {
       Mangled mangled(name);
       ConstString demangled = mangled.GetDemangledName();
 
       if (demangled) {
         ConstString best_alternate_mangled_name =
             FindBestAlternateMangledName(demangled, sc);
 
         if (best_alternate_mangled_name) {
-          CPP_specs.push_back(best_alternate_mangled_name);
+          CPP_names.push_back(best_alternate_mangled_name);
         }
       }
     }
 
     std::set<ConstString> alternates;
     CPlusPlusLanguage::FindAlternateFunctionManglings(name, alternates);
-    CPP_specs.insert(CPP_specs.end(), alternates.begin(), alternates.end());
+    CPP_names.insert(CPP_names.end(), alternates.begin(), alternates.end());
   }
 }
 
 void IRExecutionUnit::CollectFallbackNames(
-    std::vector<SearchSpec> &fallback_specs,
-    const std::vector<SearchSpec> &C_specs) {
+    std::vector<ConstString> &fallback_names,
+    const std::vector<ConstString> &C_names) {
   // As a last-ditch fallback, try the base name for C++ names.  It's terrible,
   // but the DWARF doesn't always encode "extern C" correctly.
 
-  for (const SearchSpec &C_spec : C_specs) {
-    ConstString name = C_spec.name;
-
+  for (const ConstString &name : C_names) {
     if (!CPlusPlusLanguage::IsCPPMangledName(name.GetCString()))
       continue;
 
     Mangled mangled_name(name);
     ConstString demangled_name = mangled_name.GetDemangledName();
     if (demangled_name.IsEmpty())
       continue;
 
     const char *demangled_cstr = demangled_name.AsCString();
     const char *lparen_loc = strchr(demangled_cstr, '(');
     if (!lparen_loc)
       continue;
 
-    llvm::StringRef base_name(demangled_cstr,
-                              lparen_loc - demangled_cstr);
-    fallback_specs.push_back(ConstString(base_name));
+    llvm::StringRef base_name(demangled_cstr, lparen_loc - demangled_cstr);
+    fallback_names.push_back(ConstString(base_name));
   }
 }
 
 class LoadAddressResolver {
 public:
   LoadAddressResolver(Target *target, bool &symbol_was_missing_weak)
       : m_target(target), m_symbol_was_missing_weak(symbol_was_missing_weak) {}
 
public:
   }
 
 private:
   Target *m_target;
   bool &m_symbol_was_missing_weak;
   lldb::addr_t m_best_internal_load_address = LLDB_INVALID_ADDRESS;
 };
 
-lldb::addr_t IRExecutionUnit::FindInSymbols(
-    const std::vector<IRExecutionUnit::SearchSpec> &specs,
-    const lldb_private::SymbolContext &sc, bool &symbol_was_missing_weak) {
+lldb::addr_t
+IRExecutionUnit::FindInSymbols(const std::vector<ConstString> &names,
+                               const lldb_private::SymbolContext &sc,
+                               bool &symbol_was_missing_weak) {
   symbol_was_missing_weak = false;
 
   Target *target = sc.target_sp.get();
   if (!target) {
     // We shouldn't be doing any symbol lookup at all without a target.
     return LLDB_INVALID_ADDRESS;
   }
 
   LoadAddressResolver resolver(target, symbol_was_missing_weak);
 
   ModuleFunctionSearchOptions function_options;
   function_options.include_symbols = true;
   function_options.include_inlines = false;
 
-  for (const SearchSpec &spec : specs) {
+  for (const ConstString &name : names) {
     if (sc.module_sp) {
       SymbolContextList sc_list;
-      sc.module_sp->FindFunctions(spec.name, CompilerDeclContext(), spec.mask,
-                                  function_options, sc_list);
+      sc.module_sp->FindFunctions(name, CompilerDeclContext(),
+                                  lldb::eFunctionNameTypeFull, function_options,
+                                  sc_list);
       if (auto load_addr = resolver.Resolve(sc_list))
         return *load_addr;
     }
 
     if (sc.target_sp) {
       SymbolContextList sc_list;
-      sc.target_sp->GetImages().FindFunctions(spec.name, spec.mask,
+      sc.target_sp->GetImages().FindFunctions(name, lldb::eFunctionNameTypeFull,
                                               function_options, sc_list);
       if (auto load_addr = resolver.Resolve(sc_list))
         return *load_addr;
     }
 
     if (sc.target_sp) {
       SymbolContextList sc_list;
       sc.target_sp->GetImages().FindSymbolsWithNameAndType(
-          spec.name, lldb::eSymbolTypeAny, sc_list);
+          name, lldb::eSymbolTypeAny, sc_list);
       if (auto load_addr = resolver.Resolve(sc_list))
         return *load_addr;
     }
 
     lldb::addr_t best_internal_load_address =
         resolver.GetBestInternalLoadAddress();
     if (best_internal_load_address != LLDB_INVALID_ADDRESS)
       return best_internal_load_address;
   }
 
   return LLDB_INVALID_ADDRESS;
 }
 
 lldb::addr_t
-IRExecutionUnit::FindInRuntimes(const std::vector<SearchSpec> &specs,
+IRExecutionUnit::FindInRuntimes(const std::vector<ConstString> &names,
                                 const lldb_private::SymbolContext &sc) {
   lldb::TargetSP target_sp = sc.target_sp;
 
   if (!target_sp) {
     return LLDB_INVALID_ADDRESS;
   }
 
   lldb::ProcessSP process_sp = sc.target_sp->GetProcessSP();
 
   if (!process_sp) {
     return LLDB_INVALID_ADDRESS;
   }
 
-  for (const SearchSpec &spec : specs) {
+  for (const ConstString &name : names) {
     for (LanguageRuntime *runtime : process_sp->GetLanguageRuntimes()) {
-      lldb::addr_t symbol_load_addr = runtime->LookupRuntimeSymbol(spec.name);
+      lldb::addr_t symbol_load_addr = runtime->LookupRuntimeSymbol(name);
 
       if (symbol_load_addr != LLDB_INVALID_ADDRESS)
         return symbol_load_addr;
     }
   }
 
   return LLDB_INVALID_ADDRESS;
 }
 
 lldb::addr_t IRExecutionUnit::FindInUserDefinedSymbols(
-    const std::vector<SearchSpec> &specs,
+    const std::vector<ConstString> &names,
     const lldb_private::SymbolContext &sc) {
   lldb::TargetSP target_sp = sc.target_sp;
 
-  for (const SearchSpec &spec : specs) {
-    lldb::addr_t symbol_load_addr = target_sp->GetPersistentSymbol(spec.name);
+  for (const ConstString &name : names) {
+    lldb::addr_t symbol_load_addr = target_sp->GetPersistentSymbol(name);
 
     if (symbol_load_addr != LLDB_INVALID_ADDRESS)
       return symbol_load_addr;
   }
 
   return LLDB_INVALID_ADDRESS;
 }
 
-lldb::addr_t
-IRExecutionUnit::FindSymbol(lldb_private::ConstString name, bool &missing_weak) {
-  std::vector<SearchSpec> candidate_C_names;
-  std::vector<SearchSpec> candidate_CPlusPlus_names;
+lldb::addr_t IRExecutionUnit::FindSymbol(lldb_private::ConstString name,
+                                         bool &missing_weak) {
+  std::vector<ConstString> candidate_C_names;
+  std::vector<ConstString> candidate_CPlusPlus_names;
 
   CollectCandidateCNames(candidate_C_names, name);
-  
   lldb::addr_t ret = FindInSymbols(candidate_C_names, m_sym_ctx, missing_weak);
   if (ret != LLDB_INVALID_ADDRESS)
     return ret;
-  
-  // If we find the symbol in runtimes or user defined symbols it can't be 
+  // If we find the symbol in runtimes or user defined symbols it can't be
   // a missing weak symbol.
   missing_weak = false;
   ret = FindInRuntimes(candidate_C_names, m_sym_ctx);
   if (ret != LLDB_INVALID_ADDRESS)
     return ret;
 
   ret = FindInUserDefinedSymbols(candidate_C_names, m_sym_ctx);
   if (ret != LLDB_INVALID_ADDRESS)
     return ret;
 
   CollectCandidateCPlusPlusNames(candidate_CPlusPlus_names, candidate_C_names,
                                  m_sym_ctx);
   ret = FindInSymbols(candidate_CPlusPlus_names, m_sym_ctx, missing_weak);
   if (ret != LLDB_INVALID_ADDRESS)
     return ret;
 
-  std::vector<SearchSpec> candidate_fallback_names;
+  std::vector<ConstString> candidate_fallback_names;
 
   CollectFallbackNames(candidate_fallback_names, candidate_C_names);
   ret = FindInSymbols(candidate_fallback_names, m_sym_ctx, missing_weak);
 
   return ret;
 }
 
 void IRExecutionUnit::GetStaticInitializers(