Track .dwo/.dwp loading errors and notify user when viewing variables.

[clayborg]

Summary

When debugging using Fission (-gsplit-dwarf), we can sometimes have issues loading .dwo files if they are missing or if the path was relative and we were unable to locate the file. We can also skip loading due to DWO ID mismatch or if a .dwp file doesn't contain a matching .dwo file. Also .dwo files could be updated due to a recompile and if the user debugs an executable that was linked against the old .dwo file, it could fail to load the information.

This patch adds a m_dwo_error to DWARFUnit that can be get/set and will cause "frame variable" to show errors when there are .dwo/.dwp issues informing the user about the error.

[yinghuitan]

Do you plan to detect missing dwp file from SymbolFileDWARF::GetDwpSymbolFile() as well?

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

1754–1762

We should detect and emit this error as well, like can't locate <dwo_file> relative to working dir or DW_AT_comp_dir

lldb/test/API/commands/frame/var/TestFrameVar.py

199

Delete?

[clayborg]

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

1754–1762

I can add this to the error message below yes, good idea.

lldb/test/API/commands/frame/var/TestFrameVar.py

199

yep!

[GeorgeHuyubo]

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

82

Do we want to SetDwoError here? Since there is no DWO file.

[clayborg]

• Remove commented out dead code from TestFrameVar.py
• Add DWO error for when compilation directory isn't available for a relative path .dwo file
• Use full path when emitting the "unable to locate .dwo debug file" error message

[yinghuitan]

Technical wise this patch looks good. One concern is that these error messages are user facing but we are making it favoring debugging, like skeleton DIE, showing the DIE offset etc... which is not very useful/actionable for end users.
Ideally, the user facing messages should focus on two things: 1. what is wrong in plain english. 2. any suggestion to fix it (e.g. ensure running lldb from build repo root). The more technical messages (with DIE offset) can be printed to log channel instead.

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

public:
   ///
   /// \param[in] tags
   ///   An array of dw_tag_t values to check all abbrevitions for.
   ///
   /// \returns
   ///   True if any DIEs match any tag in \a tags, false otherwise.
   bool HasAny(llvm::ArrayRef<dw_tag_t> tags);
 
+
+  /// Get the fission .dwo file specific error for this compile unit.
+  ///
+  /// The skeleton compile unit only can have a DWO error. Any other type
+  /// of DWARFUnit will not have a valid DWO error.
+  ///
+  /// \returns
+  ///   A valid DWO error if there is a problem with anything in the
+  ///   locating or parsing inforamtion in the .dwo file
+  const lldb_private::Status &GetDwoError() const { return m_dwo_error; }
+
+  /// Set the fission .dwo file specific error for this compile unit.
+  ///
+  /// This helps tracks issues that arise when trying to locate or parse a
+  /// .dwo file. Things like a missing .dwo file, DWO ID mismatch, and other
+  /// .dwo errors can be stored in each compile unit so the issues can be
+  /// communicated to the user.
+  void SetDwoError(const lldb_private::Status &error) { m_dwo_error = error; }
+
 protected:
   DWARFUnit(SymbolFileDWARF &dwarf, lldb::user_id_t uid,
             const DWARFUnitHeader &header,
             const DWARFAbbreviationDeclarationSet &abbrevs,
             DIERef::Section section, bool is_dwo);
 
   llvm::Error ExtractHeader(SymbolFileDWARF &dwarf,
                             const lldb_private::DWARFDataExtractor &data,
protected:
   bool m_rnglist_table_done = false;
   llvm::Optional<llvm::DWARFListTableHeader> m_loclist_table_header;
 
   const DIERef::Section m_section;
   bool m_is_dwo;
   bool m_has_parsed_non_skeleton_unit;
   /// Value of DW_AT_GNU_dwo_id (v4) or dwo_id from CU header (v5).
   llvm::Optional<uint64_t> m_dwo_id;
+  /// If we get an error when trying to load a .dwo file, save that error here.
+  /// Errors include .dwo/.dwp file not found, or the .dwp/.dwp file was found
+  /// but DWO ID doesn't match, etc.
+  lldb_private::Status m_dwo_error;
 
 private:
   void ParseProducerInfo();
   void ExtractDIEsRWLocked();
   void ClearDIEsRWLocked();
 
   void AddUnitDIE(const DWARFDebugInfoEntry &cu_die);
   void SetDwoStrOffsetsBase();

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

 // Parses first DIE of a compile unit including DWO.
 void DWARFUnit::ExtractUnitDIEIfNeeded() {
   ExtractUnitDIENoDwoIfNeeded();
 
   if (m_has_parsed_non_skeleton_unit)
     return;
 
   m_has_parsed_non_skeleton_unit = true;
+  m_dwo_error.Clear();
 
   if (!m_dwo_id)
     return; // No DWO file.
 
   std::shared_ptr<SymbolFileDWARFDwo> dwo_symbol_file =
       m_dwarf.GetDwoSymbolFileForCompileUnit(*this, m_first_die);
   if (!dwo_symbol_file)
     return;
 
   DWARFUnit *dwo_cu = dwo_symbol_file->GetDWOCompileUnitForHash(*m_dwo_id);
 
-  if (!dwo_cu)
+  if (!dwo_cu) {
+    SetDwoError(
+        Status("unable to load .dwo file from \"%s\" due to ID (0x%16.16" PRIx64
+               ") mismatch for skeleton DIE at 0x%8.8" PRIx32,
+               dwo_symbol_file->GetObjectFile()->GetFileSpec().GetPath().c_str(),
+               *m_dwo_id, m_first_die.GetOffset()));
     return; // Can't fetch the compile unit from the dwo file.
+  }
   dwo_cu->SetUserData(this);
 
   DWARFBaseDIE dwo_cu_die = dwo_cu->GetUnitDIEOnly();
-  if (!dwo_cu_die.IsValid())
-    return; // Can't fetch the compile unit DIE from the dwo file.
+  if (!dwo_cu_die.IsValid()) {
+    // Can't fetch the compile unit DIE from the dwo file.
+    SetDwoError(
+        Status("unable to extract compile unit DIE from .dwo file for skeleton "
+               "DIE at 0x%8.8" PRIx32, m_first_die.GetOffset()));
+    return;
+  }
 
   // Here for DWO CU we want to use the address base set in the skeleton unit
   // (DW_AT_addr_base) if it is available and use the DW_AT_GNU_addr_base
   // otherwise. We do that because pre-DWARF v5 could use the DW_AT_GNU_*
   // attributes which were applicable to the DWO units. The corresponding
   // DW_AT_* attributes standardized in DWARF v5 are also applicable to the
   // main unit in contrast.
   if (m_addr_base)

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

SymbolFileDWARF::GetDwoSymbolFileForCompileUnit(
   // never attempt to load ELF-style DWO files since the -gmodules
   // support uses the same DWO mechanism to specify full debug info
   // files for modules. This is handled in
   // UpdateExternalModuleListIfNeeded().
   if (GetDebugMapSymfile())
     return nullptr;
 
   DWARFCompileUnit *dwarf_cu = llvm::dyn_cast<DWARFCompileUnit>(&unit);
-  // Only compile units can be split into two parts.
-  if (!dwarf_cu)
+  // Only compile units can be split into two parts and we should only
+  // look for a DWO file if there is a valid DWO ID.
+  if (!dwarf_cu || !dwarf_cu->GetDWOId().has_value())
     return nullptr;
 
   const char *dwo_name = GetDWOName(*dwarf_cu, cu_die);
-  if (!dwo_name)
+  if (!dwo_name) {
+    unit.SetDwoError(Status("missing DWO name in skeleton DIE 0x%8.8" PRIx32,
+                            cu_die.GetOffset()));
     return nullptr;
+  }
 
   if (std::shared_ptr<SymbolFileDWARFDwo> dwp_sp = GetDwpSymbolFile())
     return dwp_sp;
 
+  const char *comp_dir = nullptr;
   FileSpec dwo_file(dwo_name);
   FileSystem::Instance().Resolve(dwo_file);
   if (dwo_file.IsRelative()) {
-    const char *comp_dir =
-        cu_die.GetAttributeValueAsString(dwarf_cu, DW_AT_comp_dir, nullptr);
-    if (!comp_dir)
+    comp_dir = cu_die.GetAttributeValueAsString(dwarf_cu, DW_AT_comp_dir,
+                                                nullptr);
+    if (!comp_dir) {
+      unit.SetDwoError(
+          Status("unable to locate relative .dwo debug file \"%s\" for "
+                 "skeleton DIE 0x%8.8" PRIx32 " without valid DW_AT_comp_dir "
+                 "attribute", dwo_name, cu_die.GetOffset()));
       return nullptr;
+    }
 
     dwo_file.SetFile(comp_dir, FileSpec::Style::native);
     if (dwo_file.IsRelative()) {
       // if DW_AT_comp_dir is relative, it should be relative to the location
       // of the executable, not to the location from which the debugger was
       // launched.
       dwo_file.PrependPathComponent(
           m_objfile_sp->GetFileSpec().GetDirectory().GetStringRef());
     }
     FileSystem::Instance().Resolve(dwo_file);
     dwo_file.AppendPathComponent(dwo_name);
   }
 
   if (!FileSystem::Instance().Exists(dwo_file)) {
+    unit.SetDwoError(
+        Status("unable to locate .dwo debug file \"%s\" for skeleton DIE "
+               "0x%8.8" PRIx32, dwo_file.GetPath().c_str(),
+               cu_die.GetOffset()));
+
     if (m_dwo_warning_issued.test_and_set(std::memory_order_relaxed) == false) {
       GetObjectFile()->GetModule()->ReportWarning(
           "unable to locate separate debug file (dwo, dwp). Debugging will be "
           "degraded.");
     }
     return nullptr;
   }
 
   const lldb::offset_t file_offset = 0;
   DataBufferSP dwo_file_data_sp;
   lldb::offset_t dwo_file_data_offset = 0;
   ObjectFileSP dwo_obj_file = ObjectFile::FindPlugin(
       GetObjectFile()->GetModule(), &dwo_file, file_offset,
       FileSystem::Instance().GetByteSize(dwo_file), dwo_file_data_sp,
       dwo_file_data_offset);
-  if (dwo_obj_file == nullptr)
+  if (dwo_obj_file == nullptr) {
+    unit.SetDwoError(
+          Status("unable to load object file for .dwo debug file \"%s\" for "
+                 "unit DIE 0x%8.8" PRIx32, dwo_name, cu_die.GetOffset()));
     return nullptr;
+  }
 
   return std::make_shared<SymbolFileDWARFDwo>(*this, dwo_obj_file,
                                               dwarf_cu->GetID());
 }
 
 void SymbolFileDWARF::UpdateExternalModuleListIfNeeded() {
   if (m_fetched_external_modules)
     return;
Status SymbolFileDWARF::GetFrameVariableError(StackFrame &frame) {
   CompileUnit *cu = frame.GetSymbolContext(eSymbolContextCompUnit).comp_unit;
   if (!cu)
     return Status();
 
   DWARFCompileUnit *dwarf_cu = GetDWARFCompileUnit(cu);
   if (!dwarf_cu)
     return Status();
 
+  // Check if we have a skeleton compile unit that had issues trying to load
+  // its .dwo/.dwp file. First pares the Unit DIE to make sure we see any .dwo
+  // related errors.
+  dwarf_cu->ExtractUnitDIEIfNeeded();
+  const Status &dwo_error = dwarf_cu->GetDwoError();
+  if (dwo_error.Fail())
+    return dwo_error;
+
   // Don't return an error for assembly files as they typically don't have
   // varaible information.
   if (dwarf_cu->GetDWARFLanguageType() == DW_LANG_Mips_Assembler)
     return Status();
 
   // Check if this compile unit has any variable DIEs. If it doesn't then there
   // is not variable information for the entire compile unit.
   if (dwarf_cu->HasAny({DW_TAG_variable, DW_TAG_formal_parameter}))
     return Status();
 
   return Status("no variable information is available in debug info for this "
                 "compile unit");
 }

lldb/test/API/commands/frame/var/TestFrameVar.py

 """
 Make sure the frame variable -g, -a, and -l flags work.
 """
 
 
 
 import lldb
 import lldbsuite.test.lldbutil as lldbutil
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 import os
+import shutil
 import time
 
 class TestFrameVar(TestBase):
 
     # If your test case doesn't stress debug info, then
     # set this to true.  That way it won't be run once for
     # each debug info format.
     NO_DEBUG_INFO_TESTCASE = True
def test_gline_tables_only(self):
         # We have to set a named breakpoint because we don't have any debug info
         # because we deleted the main.o file since the mod times don't match
         # and debug info won't be loaded
         (target, process, thread, bkpt) = lldbutil.run_to_name_breakpoint(self, 'main')
         error_strings = [
             'no variable information is available in debug info for this compile unit'
         ]
         self.check_frame_variable_errors(thread, error_strings)
+
+    @skipUnlessPlatform(["linux", "freebsd"])
+    @add_test_categories(["dwo"])
+    def test_fission_missing_dwo(self):
+        '''
+            Test that if we build a binary with "-gsplit-dwarf" that we can
+            set a file and line breakpoint successfully, and get an error
+            letting us know we were unable to load the .dwo file.
+        '''
+        self.build(dictionary={'CFLAGS_EXTRAS': '-gsplit-dwarf'})
+        exe = self.getBuildArtifact("a.out")
+        main_dwo = self.getBuildArtifact("main.dwo")
+
+        self.assertTrue(os.path.exists(main_dwo), 'Make sure "%s" file exists' % (main_dwo))
+        # Delete the main.dwo file that contains the debug info so we force an
+        # error when we run to main and try to get variables.
+        os.unlink(main_dwo)
+
+        # We have to set a named breakpoint because we don't have any debug info
+        # because we deleted the main.o file since the mod times don't match
+        # and debug info won't be loaded
+        (target, process, thread, bkpt) = lldbutil.run_to_name_breakpoint(self, 'main')
+        error_strings = [
+            'unable to locate .dwo debug file "',
+            'main.dwo" for skeleton DIE 0x'
+        ]
+        self.check_frame_variable_errors(thread, error_strings)
+
+    @skipUnlessPlatform(["linux", "freebsd"])
+    @add_test_categories(["dwo"])
+    def test_fission_invalid_dwo_objectfile(self):
+        '''
+            Test that if we build a binary with "-gsplit-dwarf" that we can
+            set a file and line breakpoint successfully, and get an error
+            letting us know we were unable to load the .dwo file because it
+            existed, but it wasn't a valid object file.
+        '''
+        self.build(dictionary={'CFLAGS_EXTRAS': '-gsplit-dwarf'})
+        exe = self.getBuildArtifact("a.out")
+        main_dwo = self.getBuildArtifact("main.dwo")
+
+        self.assertTrue(os.path.exists(main_dwo), 'Make sure "%s" file exists' % (main_dwo))
+        # Overwrite the main.dwo with the main.c source file so that the .dwo
+        # file exists, but it isn't a valid object file as there is an error
+        # for this case.
+        shutil.copyfile(self.getSourcePath('main.c'), main_dwo)
+
+        # We have to set a named breakpoint because we don't have any debug info
+        # because we deleted the main.o file since the mod times don't match
+        # and debug info won't be loaded
+        (target, process, thread, bkpt) = lldbutil.run_to_name_breakpoint(self, 'main')
+        error_strings = [
+            'unable to load object file for .dwo debug file "'
+            'main.dwo" for unit DIE 0x',
+        ]
+        self.check_frame_variable_errors(thread, error_strings)