[lldb] Add count for errors of DWO files in statistics and combine DWO file count functions

lldb/include/lldb/Symbol/SymbolFile.h

@@ -488,22 +488,26 @@ class SymbolFile : public PluginInterface {
     return false;
   };
 
-  /// Get number of loaded/parsed DWO files. This is emitted in "statistics
-  /// dump"
+  /// Retrieves statistics about DWO files associated with this symbol file.
+  /// This function returns a DWOStats struct containing:
+  ///   - The number of successfully loaded/parsed DWO files.
+  ///   - The total number of DWO files encountered.
+  ///   - The number of DWO CUs that failed to load due to errors.
+  /// If this symbol file does not support DWO files, all counts will be zero.
   ///
   /// \returns
-  ///     A pair containing (loaded_dwo_count, total_dwo_count). If this
-  ///     symbol file doesn't support DWO files, both counts will be 0.
-  virtual std::pair<uint32_t, uint32_t> GetDwoFileCounts() { return {0, 0}; }
-
-  virtual lldb::TypeSP
-  MakeType(lldb::user_id_t uid, ConstString name,
-           std::optional<uint64_t> byte_size, SymbolContextScope *context,
-           lldb::user_id_t encoding_uid,
-           Type::EncodingDataType encoding_uid_type, const Declaration &decl,
-           const CompilerType &compiler_qual_type,
-           Type::ResolveState compiler_type_resolve_state,
-           uint32_t opaque_payload = 0) = 0;
+  ///   A DWOStats struct with loaded, total, and error counts for DWO files.
+  virtual DWOStats GetDwoStats() { return {}; }
+
+  virtual lldb::TypeSP MakeType(lldb::user_id_t uid, ConstString name,
+                                std::optional<uint64_t> byte_size,
+                                SymbolContextScope *context,
+                                lldb::user_id_t encoding_uid,
+                                Type::EncodingDataType encoding_uid_type,
+                                const Declaration &decl,
+                                const CompilerType &compiler_qual_type,
+                                Type::ResolveState compiler_type_resolve_state,
+                                uint32_t opaque_payload = 0) = 0;
 
   virtual lldb::TypeSP CopyType(const lldb::TypeSP &other_type) = 0;
 
@@ -597,7 +601,7 @@ class SymbolFileCommon : public SymbolFile {
     return m_debug_info_had_variable_errors;
   }
   void SetDebugInfoHadFrameVariableErrors() override {
-     m_debug_info_had_variable_errors = true;
+    m_debug_info_had_variable_errors = true;
   }
 
   /// This function is used to create types that belong to a SymbolFile. The
@@ -612,21 +616,20 @@ class SymbolFileCommon : public SymbolFile {
                         const CompilerType &compiler_qual_type,
                         Type::ResolveState compiler_type_resolve_state,
                         uint32_t opaque_payload = 0) override {
-     lldb::TypeSP type_sp (new Type(
-         uid, this, name, byte_size, context, encoding_uid,
-         encoding_uid_type, decl, compiler_qual_type,
-         compiler_type_resolve_state, opaque_payload));
-     m_type_list.Insert(type_sp);
-     return type_sp;
+    lldb::TypeSP type_sp(new Type(
+        uid, this, name, byte_size, context, encoding_uid, encoding_uid_type,
+        decl, compiler_qual_type, compiler_type_resolve_state, opaque_payload));
+    m_type_list.Insert(type_sp);
+    return type_sp;
   }
 
   lldb::TypeSP CopyType(const lldb::TypeSP &other_type) override {
-     // Make sure the real symbol file matches when copying types.
-     if (GetBackingSymbolFile() != other_type->GetSymbolFile())
+    // Make sure the real symbol file matches when copying types.
+    if (GetBackingSymbolFile() != other_type->GetSymbolFile())
       return lldb::TypeSP();
-     lldb::TypeSP type_sp(new Type(*other_type));
-     m_type_list.Insert(type_sp);
-     return type_sp;
+    lldb::TypeSP type_sp(new Type(*other_type));
+    m_type_list.Insert(type_sp);
+    return type_sp;
   }
 
 protected:

lldb/include/lldb/Target/Statistics.h

@@ -123,6 +123,19 @@ struct StatsSuccessFail {
   uint32_t failures = 0;
 };
 
+/// Holds statistics about DWO (Debug With Object) files.
+struct DWOStats {
+  uint32_t loaded_dwo_file_count = 0;
+  uint32_t dwo_file_count = 0;
+  uint32_t dwo_error_count = 0;
+
+  DWOStats operator+(const DWOStats &rhs) const {
+    return DWOStats{loaded_dwo_file_count + rhs.loaded_dwo_file_count,
+                    dwo_file_count + rhs.dwo_file_count,
+                    dwo_error_count + rhs.dwo_error_count};
+  }
+};
+
 /// A class that represents statistics for a since lldb_private::Module.
 struct ModuleStats {
   llvm::json::Value ToJSON() const;
@@ -153,8 +166,7 @@ struct ModuleStats {
   bool symtab_stripped = false;
   bool debug_info_had_variable_errors = false;
   bool debug_info_had_incomplete_types = false;
-  uint32_t dwo_file_count = 0;
-  uint32_t loaded_dwo_file_count = 0;
+  DWOStats dwo_stats;
 };
 
 struct ConstStringStats {

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

@@ -90,7 +90,7 @@
 #include <cctype>
 #include <cstring>
 
-//#define ENABLE_DEBUG_PRINTF // COMMENT OUT THIS LINE PRIOR TO CHECKIN
+// #define ENABLE_DEBUG_PRINTF // COMMENT OUT THIS LINE PRIOR TO CHECKIN
 
 #ifdef ENABLE_DEBUG_PRINTF
 #include <cstdio>
@@ -1716,7 +1716,7 @@ SymbolFileDWARF *SymbolFileDWARF::GetDIERefSymbolFile(const DIERef &die_ref) {
     return this;
 
   if (file_index) {
-      // We have a SymbolFileDWARFDebugMap, so let it find the right file
+    // We have a SymbolFileDWARFDebugMap, so let it find the right file
     if (SymbolFileDWARFDebugMap *debug_map = GetDebugMapSymfile())
       return debug_map->GetSymbolFileByOSOIndex(*file_index);
 
@@ -1725,7 +1725,8 @@ SymbolFileDWARF *SymbolFileDWARF::GetDIERefSymbolFile(const DIERef &die_ref) {
       return GetDwpSymbolFile().get(); // DWP case
 
     // Handle the .dwo file case correctly
-    return DebugInfo().GetUnitAtIndex(*die_ref.file_index())
+    return DebugInfo()
+        .GetUnitAtIndex(*die_ref.file_index())
         ->GetDwoSymbolFile(); // DWO case
   }
   return this;
@@ -4502,9 +4503,8 @@ void SymbolFileDWARF::GetCompileOptions(
   }
 }
 
-std::pair<uint32_t, uint32_t> SymbolFileDWARF::GetDwoFileCounts() {
-  uint32_t total_dwo_count = 0;
-  uint32_t loaded_dwo_count = 0;
+DWOStats SymbolFileDWARF::GetDwoStats() {
+  DWOStats stats;
 
   DWARFDebugInfo &info = DebugInfo();
   const size_t num_cus = info.GetNumUnits();
@@ -4517,16 +4517,21 @@ std::pair<uint32_t, uint32_t> SymbolFileDWARF::GetDwoFileCounts() {
     if (!dwarf_cu->GetDWOId().has_value())
       continue;
 
-    total_dwo_count++;
+    stats.dwo_file_count++;
 
     // If we have a DWO symbol file, that means we were able to successfully
     // load it.
     SymbolFile *dwo_symfile =
         dwarf_cu->GetDwoSymbolFile(/*load_all_debug_info=*/false);
     if (dwo_symfile) {
-      loaded_dwo_count++;
+      stats.loaded_dwo_file_count++;
     }
+
+    // Check if this unit has a DWO load error, false by default.
+    const Status &dwo_error = dwarf_cu->GetDwoError();
+    if (dwo_error.Fail())
+      stats.dwo_error_count++;
   }
 
-  return {loaded_dwo_count, total_dwo_count};
+  return stats;
 }

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

@@ -283,10 +283,11 @@ class SymbolFileDWARF : public SymbolFileCommon {
   bool GetSeparateDebugInfo(StructuredData::Dictionary &d, bool errors_only,
                             bool load_all_debug_info = false) override;
 
-  // Gets a pair of loaded and total dwo file counts.
-  // For split-dwarf files, this reports the counts for successfully loaded DWO
-  // CUs and total DWO CUs. For non-split-dwarf files, this reports 0 for both.
-  std::pair<uint32_t, uint32_t> GetDwoFileCounts() override;
+  /// Gets statistics about dwo files associated with this symbol file.
+  /// For split-dwarf files, this reports the counts for successfully loaded DWO
+  /// CUs, total DWO CUs, and the number of DWO CUs with loading errors.
+  /// For non-split-dwarf files, this reports 0 for all.
+  DWOStats GetDwoStats() override;
 
   DWARFContext &GetDWARFContext() { return m_context; }
 

lldb/source/Target/Statistics.cpp

@@ -73,8 +73,9 @@ json::Value ModuleStats::ToJSON() const {
                      debug_info_had_incomplete_types);
   module.try_emplace("symbolTableStripped", symtab_stripped);
   module.try_emplace("symbolTableSymbolCount", symtab_symbol_count);
-  module.try_emplace("dwoFileCount", dwo_file_count);
-  module.try_emplace("loadedDwoFileCount", loaded_dwo_file_count);
+  module.try_emplace("dwoFileCount", dwo_stats.dwo_file_count);
+  module.try_emplace("loadedDwoFileCount", dwo_stats.loaded_dwo_file_count);
+  module.try_emplace("dwoErrorCount", dwo_stats.dwo_error_count);
 
   if (!symbol_locator_time.map.empty()) {
     json::Object obj;
@@ -324,8 +325,7 @@ llvm::json::Value DebuggerStats::ReportStatistics(
   uint32_t num_modules_with_incomplete_types = 0;
   uint32_t num_stripped_modules = 0;
   uint32_t symtab_symbol_count = 0;
-  uint32_t total_loaded_dwo_file_count = 0;
-  uint32_t total_dwo_file_count = 0;
+  DWOStats total_dwo_stats;
   for (size_t image_idx = 0; image_idx < num_modules; ++image_idx) {
     Module *module = target != nullptr
                          ? target->GetImages().GetModuleAtIndex(image_idx).get()
@@ -357,10 +357,9 @@ llvm::json::Value DebuggerStats::ReportStatistics(
         for (const auto &symbol_module : symbol_modules.Modules())
           module_stat.symfile_modules.push_back((intptr_t)symbol_module.get());
       }
-      std::tie(module_stat.loaded_dwo_file_count, module_stat.dwo_file_count) =
-          sym_file->GetDwoFileCounts();
-      total_dwo_file_count += module_stat.dwo_file_count;
-      total_loaded_dwo_file_count += module_stat.loaded_dwo_file_count;
+      DWOStats current_dwo_stats = sym_file->GetDwoStats();
+      module_stat.dwo_stats = module_stat.dwo_stats + current_dwo_stats;
+      total_dwo_stats = total_dwo_stats + current_dwo_stats;
       module_stat.debug_info_index_loaded_from_cache =
           sym_file->GetDebugInfoIndexWasLoadedFromCache();
       if (module_stat.debug_info_index_loaded_from_cache)
@@ -435,8 +434,9 @@ llvm::json::Value DebuggerStats::ReportStatistics(
       {"totalDebugInfoEnabled", num_debug_info_enabled_modules},
       {"totalSymbolTableStripped", num_stripped_modules},
       {"totalSymbolTableSymbolCount", symtab_symbol_count},
-      {"totalLoadedDwoFileCount", total_loaded_dwo_file_count},
-      {"totalDwoFileCount", total_dwo_file_count},
+      {"totalLoadedDwoFileCount", total_dwo_stats.loaded_dwo_file_count},
+      {"totalDwoFileCount", total_dwo_stats.dwo_file_count},
+      {"totalDwoErrorCount", total_dwo_stats.dwo_error_count},
   };
 
   if (include_targets) {