fixup! only do name lookup for declaration DIE cases

Author: Michael137

lldb/include/lldb/Symbol/SymbolFile.h

@@ -329,16 +329,18 @@ class SymbolFile : public PluginInterface {
   GetMangledNamesForFunction(const std::string &scope_qualified_name,
                              std::vector<ConstString> &mangled_names);
 
-  /// Resolves the function DIE identified by \c lookup_name within
-  /// this SymbolFile.
+  /// Resolves the function corresponding to the specified LLDB function
+  /// call \c label.
   ///
   /// \param[in,out] sc_list The resolved functions will be appended to this
   /// list.
   ///
-  /// \param[in] lookup_name The UID of the function DIE to resolve.
+  /// \param[in] label The FunctionCallLabel to be resolved.
   ///
-  virtual llvm::Error FindAndResolveFunction(SymbolContextList &sc_list,
-                                             llvm::StringRef lookup_name) {
+  /// \returns An llvm::Error if the specified \c label couldn't be resolved.
+  ///          Returns \c llvm::ErrorSuccess otherwise.
+  virtual llvm::Error ResolveFunctionCallLabel(SymbolContextList &sc_list,
+                                               const FunctionCallLabel &label) {
     return llvm::createStringError("Not implemented");
   }
 

lldb/source/Expression/IRExecutionUnit.cpp

@@ -811,8 +811,7 @@ ResolveFunctionCallLabel(llvm::StringRef name,
         llvm::formatv("no SymbolFile found on module {0:x}.", module_sp.get()));
 
   SymbolContextList sc_list;
-  if (auto err =
-          symbol_file->FindAndResolveFunction(sc_list, label.lookup_name))
+  if (auto err = symbol_file->ResolveFunctionCallLabel(sc_list, label))
     return llvm::joinErrors(
         llvm::createStringError("failed to resolve function by UID"),
         std::move(err));

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

@@ -2476,42 +2476,53 @@ bool SymbolFileDWARF::ResolveFunction(const DWARFDIE &orig_die,
 }
 
 llvm::Error
-SymbolFileDWARF::FindAndResolveFunction(SymbolContextList &sc_list,
-                                        llvm::StringRef lookup_name) {
+SymbolFileDWARF::ResolveFunctionCallLabel(SymbolContextList &sc_list,
+                                          const FunctionCallLabel &label) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
 
-  DWARFDIE die;
-  Module::LookupInfo info(ConstString(lookup_name), lldb::eFunctionNameTypeFull,
-                          lldb::eLanguageTypeUnknown);
+  DWARFDIE die = GetDIE(label.symbol_id);
+  if (!die.IsValid())
+    return llvm::createStringError(
+        llvm::formatv("invalid DIE ID in {0}", label));
 
-  m_index->GetFunctions(info, *this, {}, [&](DWARFDIE entry) {
-    if (entry.GetAttributeValueAsUnsigned(llvm::dwarf::DW_AT_declaration, 0))
-      return true;
+  // Label was created using a declaration DIE. Need to fetch the definition
+  // to resolve the function call.
+  if (die.GetAttributeValueAsUnsigned(llvm::dwarf::DW_AT_declaration, 0)) {
+    Module::LookupInfo info(ConstString(label.lookup_name),
+                            lldb::eFunctionNameTypeFull,
+                            lldb::eLanguageTypeUnknown);
 
-    // We don't check whether the specification DIE for this function
-    // corresponds to the declaration DIE because the declaration might be in
-    // a type-unit but the definition in the compile-unit (and it's
-    // specifcation would point to the declaration in the compile-unit). We
-    // rely on the mangled name within the module to be enough to find us the
-    // unique definition.
-    die = entry;
-    return false;
-  });
+    m_index->GetFunctions(info, *this, {}, [&](DWARFDIE entry) {
+      if (entry.GetAttributeValueAsUnsigned(llvm::dwarf::DW_AT_declaration, 0))
+        return true;
 
-  if (!die.IsValid())
-    return llvm::createStringError(
-        llvm::formatv("failed to find definition DIE for '{0}'", lookup_name));
+      // We don't check whether the specification DIE for this function
+      // corresponds to the declaration DIE because the declaration might be in
+      // a type-unit but the definition in the compile-unit (and it's
+      // specifcation would point to the declaration in the compile-unit). We
+      // rely on the mangled name within the module to be enough to find us the
+      // unique definition.
+      die = entry;
+      return false;
+    });
 
-  if (!ResolveFunction(die, false, sc_list))
-    return llvm::createStringError("failed to resolve function DIE");
+    if (die.GetAttributeValueAsUnsigned(llvm::dwarf::DW_AT_declaration, 0))
+      return llvm::createStringError(
+          llvm::formatv("failed to find definition DIE for {0}", label));
+  }
+
+  if (!ResolveFunction(die, /*include_inlines=*/false, sc_list))
+    return llvm::createStringError(
+        llvm::formatv("failed to resolve function for {0}", label));
 
   if (sc_list.IsEmpty())
-    return llvm::createStringError("no definition DIE found");
+    return llvm::createStringError(
+        llvm::formatv("failed to find function for {0}", label));
 
   if (sc_list.GetSize() > 1)
     return llvm::createStringError(
-        "found %d functions for %s but expected only 1", sc_list.GetSize(),
-        lookup_name.data());
+        llvm::formatv("found {0} functions for {1} but expected only 1",
+                      sc_list.GetSize(), label));
 
   return llvm::Error::success();
 }

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

@@ -436,8 +436,8 @@ class SymbolFileDWARF : public SymbolFileCommon {
   DIEArray MergeBlockAbstractParameters(const DWARFDIE &block_die,
                                         DIEArray &&variable_dies);
 
-  llvm::Error FindAndResolveFunction(SymbolContextList &sc_list,
-                                     llvm::StringRef lookup_name) override;
+  llvm::Error ResolveFunctionCallLabel(SymbolContextList &sc_list,
+                                       const FunctionCallLabel &label) override;
 
   // Given a die_offset, figure out the symbol context representing that die.
   bool ResolveFunction(const DWARFDIE &die, bool include_inlines,