[RFC/WIP] Only look at the symbol table when resolving JIT symbols

[JDevlieghere]

Summary

When resolving missing symbols for the JIT, only look at the symbol table and skip the debug info. I can't think of a situation where we want to resolve a missing symbol foo to a symbol with a different symbol name, but named foo in the debug info. Because this isn't specified in the symbol context, we can't discriminate based on that, and IRExecutionUnit::FindInSymbols will pick the first matching symbol context with an external load address.

rdar://81241350

[JDevlieghere]

Jim reminded me of static functions, which won't have a symbol, so this is actually pretty common.

[clayborg]

Yeah, any symbol that isn't exported might not be in the symbol table, but it might have a mangled name in the debug info that we can easily lookup. Static function, non-exported classes/functions, static variables, etc.

That being said, in the IRExecutionUnit do we currently try and lookup using symbols only first? If we find something do we avoid touching debug info completely? If not, we should make a patch to do this.

lldb/include/lldb/Core/Module.h

 class TypeMap;
 class VariableList;
 
 /// Options used by Module::FindFunctions. This cannot be a nested class
 /// because it must be forward-declared in ModuleList.h.
 struct ModuleFunctionOptions {
   /// Include the symbol table.
   bool include_symbols = false;
+  /// Skip the debug info and only look at the symbol table.
+  bool symbols_only = false;
   /// Include inlined functions.
   bool include_inlines = false;
 };
 
 /// \class Module Module.h "lldb/Core/Module.h"
 /// A class that describes an executable image and its associated
 ///        object and symbol files.
 ///

lldb/source/Core/Module.cpp

void Module::FindFunctions(ConstString name,
 
   // Find all the functions (not symbols, but debug information functions...
   SymbolFile *symbols = GetSymbolFile();
 
   if (name_type_mask & eFunctionNameTypeAuto) {
     LookupInfo lookup_info(name, name_type_mask, eLanguageTypeUnknown);
 
     if (symbols) {
+      if (!options.symbols_only)
         symbols->FindFunctions(lookup_info.GetLookupName(), parent_decl_ctx,
                                lookup_info.GetNameTypeMask(),
                                options.include_inlines, sc_list);
 
       // Now check our symbol table for symbols that are code symbols if
       // requested
       if (options.include_symbols) {
         Symtab *symtab = symbols->GetSymtab();
         if (symtab)
           symtab->FindFunctionSymbols(lookup_info.GetLookupName(),
                                       lookup_info.GetNameTypeMask(), sc_list);
       }
     }
 
     const size_t new_size = sc_list.GetSize();
 
     if (old_size < new_size)
       lookup_info.Prune(sc_list, old_size);
   } else {
     if (symbols) {
+      if (!options.symbols_only)
         symbols->FindFunctions(name, parent_decl_ctx, name_type_mask,
                                options.include_inlines, sc_list);
 
       // Now check our symbol table for symbols that are code symbols if
       // requested
       if (options.include_symbols) {
         Symtab *symtab = symbols->GetSymtab();
         if (symtab)
           symtab->FindFunctionSymbols(name, name_type_mask, sc_list);
       }
     }
   }
 }
 
 void Module::FindFunctions(const RegularExpression &regex,
                            const ModuleFunctionOptions &options,
                            SymbolContextList &sc_list) {
   const size_t start_size = sc_list.GetSize();
 
   if (SymbolFile *symbols = GetSymbolFile()) {
+
+    if (!options.symbols_only)
       symbols->FindFunctions(regex, options.include_inlines, sc_list);
 
     // Now check our symbol table for symbols that are code symbols if
     // requested
     if (options.include_symbols) {
       Symtab *symtab = symbols->GetSymtab();
       if (symtab) {
         std::vector<uint32_t> symbol_indexes;
         symtab->AppendSymbolIndexesMatchingRegExAndType(

lldb/source/Expression/IRExecutionUnit.cpp

auto get_external_load_address =
     if (symbol_was_missing_weak) {
       load_address = 0;
       return true;
     }
 
     return false;
   };
 
+  // Skip the debug info and only look at the symbol table.
   ModuleFunctionOptions function_options;
   function_options.include_symbols = true;
+  function_options.symbols_only = true;
   function_options.include_inlines = false;
 
   for (const SearchSpec &spec : specs) {
     lldb::addr_t best_internal_load_address = LLDB_INVALID_ADDRESS;
     lldb::addr_t load_address = LLDB_INVALID_ADDRESS;
 
     if (sc.module_sp) {
       SymbolContextList sc_list;