Add new key/value pairs to the module statistics for "statistics dump".

[clayborg]

Summary

The new key/value pairs that are added to each module's stats are:
"debugInfoByteSize": The size in bytes of debug info for each module.
"debugInfoIndexTime": The time in seconds that it took to index the debug info.
"debugInfoParseTime": The time in seconds that debug info had to be parsed.

At the top level we add up all of the debug info size, parse time and index time with the following keys:
"totalDebugInfoByteSize": The size in bytes of all debug info in all modules.
"totalDebugInfoIndexTime": The time in seconds that it took to index all debug info if it was indexed for all modules.
"totalDebugInfoParseTime": The time in seconds that debug info was parsed for all modules.

[clayborg]

New output looks like:

(lldb) statistics dump
{
  "modules": [
    {
      "debugInfoByteSize": 876,
      "debugInfoIndexTime": 0,
      "debugInfoParseTime": 0.00011866800000000002,
      "identifier": 5224745544,
      "path": "/Users/gclayton/Documents/src/args/build/a.out",
      "symbolTableIndexTime": 1.4334e-05,
      "symbolTableParseTime": 0.00019666700000000001,
      "triple": "arm64-apple-macosx11.0.0",
      "uuid": "B7F60DCD-68BF-3F2D-AE27-85253725636A"
    },
    ...
  ],
  "targets": [
    {
      "expressionEvaluation": {
        "failures": 0,
        "successes": 0
      },
      "firstStopTime": 0.34491650000000001,
      "frameVariable": {
        "failures": 0,
        "successes": 0
      },
      "launchOrAttachTime": 0.32443250000000001,
      "moduleIdentifiers": [
        5224745544,
        ...
      ],
      "targetCreateTime": 0.16623558299999999
    }
  ],
  "totalDebugInfoByteSize": 16989,
  "totalDebugInfoIndexTime": 0,
  "totalDebugInfoParseTime": 0.00023733600000000005,
  "totalSymbolTableIndexTime": 0.047756334999999997,
  "totalSymbolTableParseTime": 0.075083796999999994
}

[clayborg]

Fix headerdoc that mentioned llvm::None.

[clayborg]

Added newlines to files that needed them at the end of the file.

[wallace]

looks good

lldb/include/lldb/Symbol/SymbolFile.h

309

Symbols the symbol tables -> fix that :)

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

1463–1464

missing braces

lldb/include/lldb/Core/Section.h

public:
   bool DeleteSection(size_t idx);
 
   lldb::SectionSP GetSectionAtIndex(size_t idx) const;
 
   size_t Slide(lldb::addr_t slide_amount, bool slide_children);
 
   void Clear() { m_sections.clear(); }
 
+  /// Get the debug information size from all sections that contain debug
+  /// information. Symbol tables are not considered part of the debug
+  /// information for this call, just known sections that contain debug
+  /// information.
+  uint64_t GetDebugInfoSize() const;
+
 protected:
   collection m_sections;
 };
 
 class Section : public std::enable_shared_from_this<Section>,
                 public ModuleChild,
                 public UserID,
                 public Flags {
public:
 
   // Get the number of host bytes required to hold a target byte
   uint32_t GetTargetByteSize() const { return m_target_byte_size; }
 
   bool IsRelocated() const { return m_relocated; }
 
   void SetIsRelocated(bool b) { m_relocated = b; }
 
+  /// Returns true if this section contains debug information. Symbol tables
+  /// are not considered debug information since some symbols might contain
+  /// debug information (STABS, COFF) but not all symbols do, so to keep this
+  /// fast and simple only sections that contains only debug information should
+  /// return true.
+  bool ContainsOnlyDebugInfo() const;
+
 protected:
   ObjectFile *m_obj_file;   // The object file that data for this section should
                             // be read from
   lldb::SectionType m_type; // The type of this section
   lldb::SectionWP m_parent_wp; // Weak pointer to parent section
   ConstString m_name;          // Name of this section
   lldb::addr_t m_file_addr; // The absolute file virtual address range of this
                             // section if m_parent == NULL,

lldb/include/lldb/Symbol/SymbolFile.h

 #include "lldb/Symbol/CompilerDecl.h"
 #include "lldb/Symbol/CompilerDeclContext.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/SourceModule.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Symbol/TypeList.h"
 #include "lldb/Symbol/TypeSystem.h"
+#include "lldb/Target/Statistics.h"
 #include "lldb/Utility/XcodeSDK.h"
 #include "lldb/lldb-private.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/Support/Errc.h"
 
 #include <mutex>
 
 #if defined(LLDB_CONFIGURATION_DEBUG)
public:
   /// function.
   virtual llvm::Expected<lldb::addr_t> GetParameterStackSize(Symbol &symbol) {
     return llvm::createStringError(make_error_code(llvm::errc::not_supported),
                                    "Operation not supported.");
   }
 
   virtual void Dump(Stream &s);
 
+  /// Metrics gathering functions
+
+  /// Return the size in bytes of all debug information in the symbol file.
+  ///
+  /// If the debug information is contained in sections of an ObjectFile, then
+  /// this call should add the size of all sections that contain debug
+  /// information. Symbols the symbol tables are not considered debug
+  /// information for this call to make it easy and quick for this number to be
+  /// calculated. If the symbol file is all debug information, the size of the
+  /// entire file should be returned. The default implementation of this
+  /// function will iterate over all sections in a module and add up their
+  /// debug info only section byte sizes.
+  virtual uint64_t GetDebugInfoSize();
+
+  /// Return the time taken to parse the debug information.
+  ///
+  /// \returns 0.0 if no information has been parsed or if there is
+  /// no computational cost to parsing the debug information.
+  virtual StatsDuration GetDebugInfoParseTime() {
+    return StatsDuration(0.0);
+  }
+
+  /// Return the time it took to index the debug information in the object
+  /// file.
+  ///
+  /// \returns 0.0 if the file doesn't need to be indexed or if it
+  /// hasn't been indexed yet, or a valid duration if it has.
+  virtual StatsDuration GetDebugInfoIndexTime() {
+    return StatsDuration(0.0);
+  }
+
+
 protected:
   void AssertModuleLock();
   virtual uint32_t CalculateNumCompileUnits() = 0;
   virtual lldb::CompUnitSP ParseCompileUnitAtIndex(uint32_t idx) = 0;
   virtual TypeList &GetTypeList() { return m_type_list; }
 
   void SetCompileUnitAtIndex(uint32_t idx, const lldb::CompUnitSP &cu_sp);
 

lldb/include/lldb/Target/Statistics.h

 struct ModuleStats {
   llvm::json::Value ToJSON() const;
   intptr_t identifier;
   std::string path;
   std::string uuid;
   std::string triple;
   double symtab_parse_time = 0.0;
   double symtab_index_time = 0.0;
+  double debug_parse_time = 0.0;
+  double debug_index_time = 0.0;
+  uint64_t debug_info_size = 0;
 };
 
 /// A class that represents statistics for a since lldb_private::Target.
 class TargetStats {
 public:
   llvm::json::Value ToJSON(Target &target);
 
   void SetLaunchOrAttachTime();

lldb/source/Core/Section.cpp

 }
 
 lldb::offset_t Section::GetSectionData(DataExtractor &section_data) {
   if (m_obj_file)
     return m_obj_file->ReadSectionData(this, section_data);
   return 0;
 }
 
+bool Section::ContainsOnlyDebugInfo() const {
+  switch (m_type) {
+  case eSectionTypeInvalid:
+  case eSectionTypeCode:
+  case eSectionTypeContainer:
+  case eSectionTypeData:
+  case eSectionTypeDataCString:
+  case eSectionTypeDataCStringPointers:
+  case eSectionTypeDataSymbolAddress:
+  case eSectionTypeData4:
+  case eSectionTypeData8:
+  case eSectionTypeData16:
+  case eSectionTypeDataPointers:
+  case eSectionTypeZeroFill:
+  case eSectionTypeDataObjCMessageRefs:
+  case eSectionTypeDataObjCCFStrings:
+  case eSectionTypeELFSymbolTable:
+  case eSectionTypeELFDynamicSymbols:
+  case eSectionTypeELFRelocationEntries:
+  case eSectionTypeELFDynamicLinkInfo:
+  case eSectionTypeEHFrame:
+  case eSectionTypeARMexidx:
+  case eSectionTypeARMextab:
+  case eSectionTypeCompactUnwind:
+  case eSectionTypeGoSymtab:
+  case eSectionTypeAbsoluteAddress:
+  case eSectionTypeOther:
+    return false;
+
+  case eSectionTypeDebug:
+  case eSectionTypeDWARFDebugAbbrev:
+  case eSectionTypeDWARFDebugAbbrevDwo:
+  case eSectionTypeDWARFDebugAddr:
+  case eSectionTypeDWARFDebugAranges:
+  case eSectionTypeDWARFDebugCuIndex:
+  case eSectionTypeDWARFDebugTuIndex:
+  case eSectionTypeDWARFDebugFrame:
+  case eSectionTypeDWARFDebugInfo:
+  case eSectionTypeDWARFDebugInfoDwo:
+  case eSectionTypeDWARFDebugLine:
+  case eSectionTypeDWARFDebugLineStr:
+  case eSectionTypeDWARFDebugLoc:
+  case eSectionTypeDWARFDebugLocDwo:
+  case eSectionTypeDWARFDebugLocLists:
+  case eSectionTypeDWARFDebugLocListsDwo:
+  case eSectionTypeDWARFDebugMacInfo:
+  case eSectionTypeDWARFDebugMacro:
+  case eSectionTypeDWARFDebugPubNames:
+  case eSectionTypeDWARFDebugPubTypes:
+  case eSectionTypeDWARFDebugRanges:
+  case eSectionTypeDWARFDebugRngLists:
+  case eSectionTypeDWARFDebugRngListsDwo:
+  case eSectionTypeDWARFDebugStr:
+  case eSectionTypeDWARFDebugStrDwo:
+  case eSectionTypeDWARFDebugStrOffsets:
+  case eSectionTypeDWARFDebugStrOffsetsDwo:
+  case eSectionTypeDWARFDebugTypes:
+  case eSectionTypeDWARFDebugTypesDwo:
+  case eSectionTypeDWARFDebugNames:
+  case eSectionTypeDWARFAppleNames:
+  case eSectionTypeDWARFAppleTypes:
+  case eSectionTypeDWARFAppleNamespaces:
+  case eSectionTypeDWARFAppleObjC:
+  case eSectionTypeDWARFGNUDebugAltLink:
+    return true;
+  }
+  return false;
+}
+
+
 #pragma mark SectionList
 
 SectionList &SectionList::operator=(const SectionList &rhs) {
   if (this != &rhs)
     m_sections = rhs.m_sections;
   return *this;
 }
 
size_t SectionList::Slide(addr_t slide_amount, bool slide_children) {
   size_t count = 0;
   const_iterator pos, end = m_sections.end();
   for (pos = m_sections.begin(); pos != end; ++pos) {
     if ((*pos)->Slide(slide_amount, slide_children))
       ++count;
   }
   return count;
 }
+
+uint64_t SectionList::GetDebugInfoSize() const {
+  uint64_t debug_info_size = 0;
+  for (const auto &section : m_sections) {
+    const SectionList &sub_sections = section->GetChildren();
+    if (sub_sections.GetSize() > 0)
+      debug_info_size += sub_sections.GetDebugInfoSize();
+    else if (section->ContainsOnlyDebugInfo())
+      debug_info_size += section->GetFileSize();
+  }
+  return debug_info_size;
+}

lldb/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.h

public:
   lldb::UnwindPlanSP
   GetUnwindPlan(const Address &address,
                 const RegisterInfoResolver &resolver) override;
 
   llvm::StringRef GetPluginName() override {
     return GetPluginNameStatic().GetStringRef();
   }
 
+  uint64_t GetDebugInfoSize() override;
+
 private:
   // A class representing a position in the breakpad file. Useful for
   // remembering the position so we can go back to it later and parse more data.
   // Can be converted to/from a LineIterator, but it has a much smaller memory
   // footprint.
   struct Bookmark {
     uint32_t section;
     size_t offset;

lldb/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.cpp

for (LineIterator It(*m_objfile_sp, Record::StackWin), End(*m_objfile_sp);
     if (auto record = StackWinRecord::parse(*It)) {
       m_unwind_data->win.Append(UnwindMap::Entry(
           base + record->RVA, record->CodeSize, It.GetBookmark()));
     } else
       LLDB_LOG(log, "Failed to parse: {0}. Skipping record.", *It);
   }
   m_unwind_data->win.Sort();
 }
+
+uint64_t SymbolFileBreakpad::GetDebugInfoSize() {
+  // Breakpad files are all debug info.
+  return m_objfile_sp->GetByteSize();
+}
+

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

 //===-- DWARFIndex.h -------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFINDEX_H
 #define LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFINDEX_H
 
 #include "Plugins/SymbolFile/DWARF/DIERef.h"
 #include "Plugins/SymbolFile/DWARF/DWARFDIE.h"
 #include "Plugins/SymbolFile/DWARF/DWARFFormValue.h"
 
+#include "lldb/Target/Statistics.h"
+
 class DWARFDeclContext;
 class DWARFDIE;
 
 namespace lldb_private {
 class DWARFIndex {
 public:
   DWARFIndex(Module &module) : m_module(module) {}
   virtual ~DWARFIndex();
GetFunctions(ConstString name, SymbolFileDWARF &dwarf,
                uint32_t name_type_mask,
                llvm::function_ref<bool(DWARFDIE die)> callback) = 0;
   virtual void
   GetFunctions(const RegularExpression &regex,
                llvm::function_ref<bool(DWARFDIE die)> callback) = 0;
 
   virtual void Dump(Stream &s) = 0;
 
+  StatsDuration GetIndexTime() { return m_index_time; }
+
 protected:
   Module &m_module;
+  StatsDuration m_index_time{0.0};
 
   /// Helper function implementing common logic for processing function dies. If
   /// the function given by "ref" matches search criteria given by
   /// "parent_decl_ctx" and "name_type_mask", it is inserted into the "dies"
   /// vector.
   bool ProcessFunctionDIE(llvm::StringRef name, DIERef ref,
                           SymbolFileDWARF &dwarf,
                           const CompilerDeclContext &parent_decl_ctx,

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

void DWARFUnit::ExtractUnitDIENoDwoIfNeeded() {
     llvm::sys::ScopedReader lock(m_first_die_mutex);
     if (m_first_die)
       return; // Already parsed
   }
   llvm::sys::ScopedWriter lock(m_first_die_mutex);
   if (m_first_die)
     return; // Already parsed
 
+  ElapsedTime elapsed(m_dwarf.GetDebugInfoParseTimeRef());
   LLDB_SCOPED_TIMERF("%8.8x: DWARFUnit::ExtractUnitDIENoDwoIfNeeded()",
                      GetOffset());
 
   // Set the offset to that of the first DIE and calculate the start of the
   // next compilation unit header.
   lldb::offset_t offset = GetFirstDIEOffset();
 
   // We are in our compile unit, parse starting at the offset we were told to
DWARFUnit::ScopedExtractDIEs &DWARFUnit::ScopedExtractDIEs::operator=(
   return *this;
 }
 
 // Parses a compile unit and indexes its DIEs, m_die_array_mutex must be
 // held R/W and m_die_array must be empty.
 void DWARFUnit::ExtractDIEsRWLocked() {
   llvm::sys::ScopedWriter first_die_lock(m_first_die_mutex);
 
+  ElapsedTime elapsed(m_dwarf.GetDebugInfoParseTimeRef());
   LLDB_SCOPED_TIMERF("%8.8x: DWARFUnit::ExtractDIEsIfNeeded()", GetOffset());
 
   // Set the offset to that of the first DIE and calculate the start of the
   // next compilation unit header.
   lldb::offset_t offset = GetFirstDIEOffset();
   lldb::offset_t next_cu_offset = GetNextUnitOffset();
 
   DWARFDebugInfoEntry die;

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

 
 void ManualDWARFIndex::Index() {
   if (!m_dwarf)
     return;
 
   SymbolFileDWARF &main_dwarf = *m_dwarf;
   m_dwarf = nullptr;
 
+  ElapsedTime elapsed(m_index_time);
   LLDB_SCOPED_TIMERF("%p", static_cast<void *>(&main_dwarf));
 
   DWARFDebugInfo &main_info = main_dwarf.DebugInfo();
   SymbolFileDWARFDwo *dwp_dwarf = main_dwarf.GetDwpSymbolFile().get();
   DWARFDebugInfo *dwp_info = dwp_dwarf ? &dwp_dwarf->DebugInfo() : nullptr;
 
   std::vector<DWARFUnit *> units_to_index;
   units_to_index.reserve(main_info.GetNumUnits() +

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

 #include "llvm/ADT/SetVector.h"
 #include "llvm/Support/Threading.h"
 
 #include "lldb/Core/UniqueCStringMap.h"
 #include "lldb/Core/dwarf.h"
 #include "lldb/Symbol/DebugMacros.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Symbol/SymbolFile.h"
+#include "lldb/Target/Statistics.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Flags.h"
 #include "lldb/Utility/RangeMap.h"
 #include "lldb/lldb-private.h"
 
 #include "DWARFContext.h"
 #include "DWARFDataExtractor.h"
 #include "DWARFDefines.h"
public:
   static DWARFDeclContext GetDWARFDeclContext(const DWARFDIE &die);
 
   static lldb::LanguageType LanguageTypeFromDWARF(uint64_t val);
 
   static lldb::LanguageType GetLanguage(DWARFUnit &unit);
   /// Same as GetLanguage() but reports all C++ versions as C++ (no version).
   static lldb::LanguageType GetLanguageFamily(DWARFUnit &unit);
 
+  lldb_private::StatsDuration GetDebugInfoParseTime() override {
+    return m_parse_time;
+  }
+  lldb_private::StatsDuration GetDebugInfoIndexTime() override;
+
+  lldb_private::StatsDuration &GetDebugInfoParseTimeRef() {
+    return m_parse_time;
+  }
+
+
 protected:
   typedef llvm::DenseMap<const DWARFDebugInfoEntry *, lldb_private::Type *>
       DIEToTypePtr;
   typedef llvm::DenseMap<const DWARFDebugInfoEntry *, lldb::VariableSP>
       DIEToVariableSP;
   typedef llvm::DenseMap<const DWARFDebugInfoEntry *,
                          lldb::opaque_compiler_type_t>
       DIEToClangType;
protected:
   std::vector<uint32_t> m_lldb_cu_to_dwarf_unit;
   /// DWARF does not provide a good way for traditional (concatenating) linkers
   /// to invalidate debug info describing dead-stripped code. These linkers will
   /// keep the debug info but resolve any addresses referring to such code as
   /// zero (BFD) or a small positive integer (zero + relocation addend -- GOLD).
   /// Try to filter out this debug info by comparing it to the lowest code
   /// address in the module.
   lldb::addr_t m_first_code_address = LLDB_INVALID_ADDRESS;
+  lldb_private::StatsDuration m_parse_time{0.0};
 };
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_SYMBOLFILEDWARF_H

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

 bool SymbolFileDWARF::ParseSupportFiles(DWARFUnit &dwarf_cu,
                                         const ModuleSP &module,
                                         FileSpecList &support_files) {
 
   dw_offset_t offset = dwarf_cu.GetLineTableOffset();
   if (offset == DW_INVALID_OFFSET)
     return false;
 
+  ElapsedTime elapsed(m_parse_time);
   llvm::DWARFDebugLine::Prologue prologue;
   if (!ParseLLVMLineTablePrologue(m_context, prologue, offset,
                                   dwarf_cu.GetOffset()))
     return false;
 
   support_files = ParseSupportFilesFromPrologue(
       module, prologue, dwarf_cu.GetPathStyle(),
       dwarf_cu.GetCompilationDirectory().GetCString());
if (iter_bool.second) {
     llvm::DWARFContext &ctx = m_context.GetAsLLVM();
     llvm::DWARFDebugLine::Prologue prologue;
     auto report = [](llvm::Error error) {
       Log *log = LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO);
       LLDB_LOG_ERROR(log, std::move(error),
                      "SymbolFileDWARF::GetTypeUnitSupportFiles failed to parse "
                      "the line table prologue");
     };
+    ElapsedTime elapsed(m_parse_time);
     llvm::Error error = prologue.parse(data, &line_table_offset, report, ctx);
     if (error) {
       report(std::move(error));
     } else {
       list = ParseSupportFilesFromPrologue(GetObjectFile()->GetModule(),
                                            prologue, tu.GetPathStyle());
     }
   }
bool SymbolFileDWARF::ParseLineTable(CompileUnit &comp_unit) {
   DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
   if (!dwarf_cu)
     return false;
 
   dw_offset_t offset = dwarf_cu->GetLineTableOffset();
   if (offset == DW_INVALID_OFFSET)
     return false;
 
+  ElapsedTime elapsed(m_parse_time);
   llvm::DWARFDebugLine line;
   const llvm::DWARFDebugLine::LineTable *line_table =
       ParseLLVMLineTable(m_context, line, offset, dwarf_cu->GetOffset());
 
   if (!line_table)
     return false;
 
   // FIXME: Rather than parsing the whole line table and then copying it over

 }
 
 lldb_private::DebugMacrosSP
 SymbolFileDWARF::ParseDebugMacros(lldb::offset_t *offset) {
   auto iter = m_debug_macros_map.find(*offset);
   if (iter != m_debug_macros_map.end())
     return iter->second;
 
+  ElapsedTime elapsed(m_parse_time);
   const DWARFDataExtractor &debug_macro_data = m_context.getOrLoadMacroData();
   if (debug_macro_data.GetByteSize() == 0)
     return DebugMacrosSP();
 
   lldb_private::DebugMacrosSP debug_macros_sp(new lldb_private::DebugMacros());
   m_debug_macros_map[*offset] = debug_macros_sp;
 
   const DWARFDebugMacroHeader &header =

 }
 
 LanguageType SymbolFileDWARF::GetLanguageFamily(DWARFUnit &unit) {
   auto lang = (llvm::dwarf::SourceLanguage)unit.GetDWARFLanguageType();
   if (llvm::dwarf::isCPlusPlus(lang))
     lang = DW_LANG_C_plus_plus;
   return LanguageTypeFromDWARF(lang);
 }
+
+StatsDuration SymbolFileDWARF::GetDebugInfoIndexTime() {
+  if (m_index)
+    return m_index->GetIndexTime();
+  return StatsDuration(0.0);
+}

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

public:
 
   void DumpClangAST(lldb_private::Stream &s) override;
 
   // PluginInterface protocol
   llvm::StringRef GetPluginName() override {
     return GetPluginNameStatic().GetStringRef();
   }
 
+  uint64_t GetDebugInfoSize() override;
+  lldb_private::StatsDuration GetDebugInfoParseTime() override;
+  lldb_private::StatsDuration GetDebugInfoIndexTime() override;
+
 protected:
   enum { kHaveInitializedOSOs = (1 << 0), kNumFlags };
 
   friend class DebugMapModule;
   friend class DWARFASTParserClang;
   friend class DWARFCompileUnit;
   friend class SymbolFileDWARF;
   struct OSOInfo {

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

if (compile_unit_info) {
                                      entry->GetRangeEnd());
           num_line_entries_added++;
         }
       }
     }
   }
   return num_line_entries_added;
 }
+
+uint64_t SymbolFileDWARFDebugMap::GetDebugInfoSize() {
+  uint64_t debug_info_size = 0;
+  ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool {
+    ObjectFile *oso_objfile = oso_dwarf->GetObjectFile();
+    if (!oso_objfile)
+      return false; // Keep iterating
+    ModuleSP module_sp = oso_objfile->GetModule();
+    if (!module_sp)
+      return false; // Keep iterating
+    SectionList *section_list = module_sp->GetSectionList();
+    if (section_list)
+      debug_info_size += section_list->GetDebugInfoSize();
+    return false; // Keep iterating
+  });
+  return debug_info_size;
+}
+
+StatsDuration SymbolFileDWARFDebugMap::GetDebugInfoParseTime() {
+  StatsDuration elapsed(0.0);
+  ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool {
+    ObjectFile *oso_objfile = oso_dwarf->GetObjectFile();
+    if (oso_objfile) {
+      ModuleSP module_sp = oso_objfile->GetModule();
+      if (module_sp) {
+        SymbolFile *symfile = module_sp->GetSymbolFile();
+        if (symfile)
+          elapsed += symfile->GetDebugInfoParseTime();
+      }
+    }
+    return false; // Keep iterating
+  });
+  return elapsed;
+}
+
+StatsDuration SymbolFileDWARFDebugMap::GetDebugInfoIndexTime() {
+  StatsDuration elapsed(0.0);
+  ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool {
+    ObjectFile *oso_objfile = oso_dwarf->GetObjectFile();
+    if (oso_objfile) {
+      ModuleSP module_sp = oso_objfile->GetModule();
+      if (module_sp) {
+        SymbolFile *symfile = module_sp->GetSymbolFile();
+        if (symfile)
+          elapsed += symfile->GetDebugInfoIndexTime();
+      }
+    }
+    return false; // Keep iterating
+  });
+  return elapsed;
+}

lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.h

public:
   SymbolFileNativePDB(lldb::ObjectFileSP objfile_sp);
 
   ~SymbolFileNativePDB() override;
 
   uint32_t CalculateAbilities() override;
 
   void InitializeObject() override;
 
+  uint64_t GetDebugInfoSize() override;
+
   // Compile Unit function calls
 
   void
   ParseDeclsForContext(lldb_private::CompilerDeclContext decl_ctx) override;
 
   lldb::LanguageType
   ParseLanguage(lldb_private::CompileUnit &comp_unit) override;
 

lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp

 SymbolFileNativePDB::GetTypeSystemForLanguage(lldb::LanguageType language) {
   auto type_system_or_err =
       m_objfile_sp->GetModule()->GetTypeSystemForLanguage(language);
   if (type_system_or_err) {
     type_system_or_err->SetSymbolFile(this);
   }
   return type_system_or_err;
 }
+
+uint64_t SymbolFileNativePDB::GetDebugInfoSize() {
+  // PDB files are a separate file that contains all debug info.
+  return m_index->pdb().getFileSize();
+}
+

lldb/source/Symbol/SymbolFile.cpp

void SymbolFile::Dump(Stream &s) {
   }
   s.PutChar('\n');
 
   if (Symtab *symtab = GetSymtab())
     symtab->Dump(&s, nullptr, eSortOrderNone);
 }
 
 SymbolFile::RegisterInfoResolver::~RegisterInfoResolver() = default;
+
+uint64_t SymbolFile::GetDebugInfoSize() {
+  if (!m_objfile_sp)
+    return 0;
+  ModuleSP module_sp(m_objfile_sp->GetModule());
+  if (!module_sp)
+    return 0;
+  const SectionList *section_list = module_sp->GetSectionList();
+  if (section_list)
+    return section_list->GetDebugInfoSize();
+  return 0;
+}

lldb/source/Target/Statistics.cpp

 json::Value ModuleStats::ToJSON() const {
   json::Object module;
   EmplaceSafeString(module, "path", path);
   EmplaceSafeString(module, "uuid", uuid);
   EmplaceSafeString(module, "triple", triple);
   module.try_emplace("identifier", identifier);
   module.try_emplace("symbolTableParseTime", symtab_parse_time);
   module.try_emplace("symbolTableIndexTime", symtab_index_time);
+  module.try_emplace("debugInfoParseTime", debug_parse_time);
+  module.try_emplace("debugInfoIndexTime", debug_index_time);
+  module.try_emplace("debugInfoByteSize", (int64_t)debug_info_size);
   return module;
 }
 
 json::Value TargetStats::ToJSON(Target &target) {
   CollectStats(target);
 
   json::Array json_module_uuid_array;
   for (auto module_identifier : m_module_identifiers)

 bool DebuggerStats::g_collecting_stats = false;
 
 llvm::json::Value DebuggerStats::ReportStatistics(Debugger &debugger,
                                                   Target *target) {
   json::Array json_targets;
   json::Array json_modules;
   double symtab_parse_time = 0.0;
   double symtab_index_time = 0.0;
+  double debug_parse_time = 0.0;
+  double debug_index_time = 0.0;
+  uint64_t debug_info_size = 0;
   if (target) {
     json_targets.emplace_back(target->ReportStatistics());
   } else {
     for (const auto &target : debugger.GetTargetList().Targets())
       json_targets.emplace_back(target->ReportStatistics());
   }
   std::vector<ModuleStats> modules;
   std::lock_guard<std::recursive_mutex> guard(
       Module::GetAllocationModuleCollectionMutex());
   const size_t num_modules = Module::GetNumberAllocatedModules();
-  ModuleSP module_sp;
   for (size_t image_idx = 0; image_idx < num_modules; ++image_idx) {
     Module *module = Module::GetAllocatedModuleAtIndex(image_idx);
     ModuleStats module_stat;
     module_stat.identifier = (intptr_t)module;
     module_stat.path = module->GetFileSpec().GetPath();
+    if (ConstString object_name = module->GetObjectName()) {
+      module_stat.path.append(1, '(');
+      module_stat.path.append(object_name.GetStringRef().str());
+      module_stat.path.append(1, ')');
+    }
     module_stat.uuid = module->GetUUID().GetAsString();
     module_stat.triple = module->GetArchitecture().GetTriple().str();
     module_stat.symtab_parse_time = module->GetSymtabParseTime().count();
     module_stat.symtab_index_time = module->GetSymtabIndexTime().count();
+    SymbolFile *sym_file = module->GetSymbolFile();
+    if (sym_file) {
+      module_stat.debug_index_time = sym_file->GetDebugInfoIndexTime().count();
+      module_stat.debug_parse_time = sym_file->GetDebugInfoParseTime().count();
+      module_stat.debug_info_size = sym_file->GetDebugInfoSize();
+    }
     symtab_parse_time += module_stat.symtab_parse_time;
     symtab_index_time += module_stat.symtab_index_time;
+    debug_parse_time += module_stat.debug_parse_time;
+    debug_index_time += module_stat.debug_index_time;
+    debug_info_size += module_stat.debug_info_size;
     json_modules.emplace_back(module_stat.ToJSON());
   }
 
   json::Object global_stats{
       {"targets", std::move(json_targets)},
       {"modules", std::move(json_modules)},
       {"totalSymbolTableParseTime", symtab_parse_time},
       {"totalSymbolTableIndexTime", symtab_index_time},
+      {"totalDebugInfoParseTime", debug_parse_time},
+      {"totalDebugInfoIndexTime", debug_index_time},
+      {"totalDebugInfoByteSize", debug_info_size},
   };
   return std::move(global_stats);
 }

lldb/test/API/commands/statistics/basic/TestStats.py

def test_default_no_run(self):
                 },
                 "frameVariable": {
                     "failures": 0,
                     "successes": 0
                 },
                 "moduleIdentifiers": [...],
             }
           ],
+          "totalDebugInfoByteSize": 182522234,
+          "totalDebugInfoIndexTime": 2.33343,
+          "totalDebugInfoParseTime": 8.2121400240000071,
           "totalSymbolTableParseTime": 0.123,
           "totalSymbolTableIndexTime": 0.234,
         }
         """
         target = self.createTestTarget()
         debug_stats = self.get_stats()
         debug_stat_keys = [
             'modules', 
             'targets',
             'totalSymbolTableParseTime',
             'totalSymbolTableIndexTime',
+            'totalDebugInfoByteSize',
+            'totalDebugInfoIndexTime',
+            'totalDebugInfoParseTime',
         ]
         self.verify_keys(debug_stats, '"debug_stats"', debug_stat_keys, None)
         stats = debug_stats['targets'][0]
         keys_exist = [
             'expressionEvaluation',
             'frameVariable',
             'moduleIdentifiers',
             'targetCreateTime',
def test_default_with_run(self):
                         "successes": 0
                     },
                     "frameVariable": {
                         "failures": 0,
                         "successes": 0
                     },
                 }
             ],
+            "totalDebugInfoByteSize": 182522234,
+            "totalDebugInfoIndexTime": 2.33343,
+            "totalDebugInfoParseTime": 8.2121400240000071,
             "totalSymbolTableParseTime": 0.123,
             "totalSymbolTableIndexTime": 0.234,
         }
 
         """
         target = self.createTestTarget()
         lldbutil.run_to_source_breakpoint(self, "// break here",
                                           lldb.SBFileSpec("main.c"))
         debug_stats = self.get_stats()
         debug_stat_keys = [
             'modules', 
             'targets',
             'totalSymbolTableParseTime',
             'totalSymbolTableIndexTime',
+            'totalDebugInfoByteSize',
+            'totalDebugInfoIndexTime',
+            'totalDebugInfoParseTime',
         ]
         self.verify_keys(debug_stats, '"debug_stats"', debug_stat_keys, None)
         stats = debug_stats['targets'][0]
         keys_exist = [
             'expressionEvaluation',
             'firstStopTime',
             'frameVariable',
             'launchOrAttachTime',
def test_modules(self):
         exe = self.getBuildArtifact("a.out")
         target = self.createTestTarget(file_path=exe)
         debug_stats = self.get_stats()
         debug_stat_keys = [
             'modules', 
             'targets',
             'totalSymbolTableParseTime',
             'totalSymbolTableIndexTime',
+            'totalDebugInfoParseTime',
+            'totalDebugInfoIndexTime',
+            'totalDebugInfoByteSize'
         ]
         self.verify_keys(debug_stats, '"debug_stats"', debug_stat_keys, None)
         stats = debug_stats['targets'][0]
         keys_exist = [
             'moduleIdentifiers',
         ]
         self.verify_keys(stats, '"stats"', keys_exist, None)
         exe_module = self.find_module_in_metrics(exe, debug_stats)
         module_keys = [
+            'debugInfoByteSize',
+            'debugInfoIndexTime',
+            'debugInfoParseTime',
             'identifier',
             'path',
             'symbolTableIndexTime',
             'symbolTableParseTime',
             'triple',
             'uuid',
         ]
         self.assertNotEqual(exe_module, None)
         self.verify_keys(exe_module, 'module dict for "%s"' % (exe), module_keys)