[DebugInfo]Lazy parse abbrevs when symbolizing

[dblaikie]

Summary

This speeds up llvm-symbolizer on code without .debug_aranges - we don't
need to parse all the abbrevs for every CU, just usually the first
abbrev for most CUs, then more abbrevs for any CU we go look into for
symbolizing.

I don't think this makes enough of a difference to worry too much about - but
throwing it out there since I wrote it while exploring things.

llvm/include/llvm/DebugInfo/DWARF/DWARFDebugAbbrev.h

 //===- DWARFDebugAbbrev.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 LLVM_DEBUGINFO_DWARF_DWARFDEBUGABBREV_H
 #define LLVM_DEBUGINFO_DWARF_DWARFDEBUGABBREV_H
 
 #include "llvm/DebugInfo/DWARF/DWARFAbbreviationDeclaration.h"
 #include "llvm/Support/DataExtractor.h"
 #include <cstdint>
+#include <deque>
 #include <map>
-#include <vector>
 
 namespace llvm {
 
 class raw_ostream;
 
 class DWARFAbbreviationDeclarationSet {
   uint64_t Offset;
+  mutable uint64_t CurOffset;
   /// Code of the first abbreviation, if all abbreviations in the set have
   /// consecutive codes. UINT32_MAX otherwise.
-  uint32_t FirstAbbrCode;
-  std::vector<DWARFAbbreviationDeclaration> Decls;
+  mutable uint32_t FirstAbbrCode;
+  mutable std::deque<DWARFAbbreviationDeclaration> Decls;
+  mutable std::optional<DataExtractor> Data;
 
-  using const_iterator =
-      std::vector<DWARFAbbreviationDeclaration>::const_iterator;
+  using const_iterator = decltype(Decls)::const_iterator;
 
 public:
   DWARFAbbreviationDeclarationSet();
 
   uint64_t getOffset() const { return Offset; }
   void dump(raw_ostream &OS) const;
-  bool extract(DataExtractor Data, uint64_t *OffsetPtr);
+  bool extract(DataExtractor Data, uint64_t *OffsetPtr, bool Lazy = false);
 
   const DWARFAbbreviationDeclaration *
   getAbbreviationDeclaration(uint32_t AbbrCode) const;
 
   const_iterator begin() const {
     return Decls.begin();
   }
 
class DWARFDebugAbbrev {
   mutable DWARFAbbreviationDeclarationSetMap AbbrDeclSets;
   mutable DWARFAbbreviationDeclarationSetMap::const_iterator PrevAbbrOffsetPos;
   mutable std::optional<DataExtractor> Data;
 
 public:
   DWARFDebugAbbrev();
 
   const DWARFAbbreviationDeclarationSet *
-  getAbbreviationDeclarationSet(uint64_t CUAbbrOffset) const;
+  getAbbreviationDeclarationSet(uint64_t CUAbbrOffset, bool Lazy = false) const;
 
   void dump(raw_ostream &OS) const;
   void parse() const;
   void extract(DataExtractor Data);
 
   DWARFAbbreviationDeclarationSetMap::const_iterator begin() const {
     parse();
     return AbbrDeclSets.begin();

llvm/include/llvm/DebugInfo/DWARF/DWARFUnit.h

public:
 
   uint64_t getStringOffsetsBase() const {
     assert(StringOffsetsTableContribution);
     return StringOffsetsTableContribution->Base;
   }
 
   uint64_t getAbbreviationsOffset() const { return Header.getAbbrOffset(); }
 
-  const DWARFAbbreviationDeclarationSet *getAbbreviations() const;
+  const DWARFAbbreviationDeclarationSet *
+  getAbbreviations(bool Lazy = false) const;
 
   static bool isMatchingUnitTypeAndTag(uint8_t UnitType, dwarf::Tag Tag) {
     switch (UnitType) {
     case dwarf::DW_UT_compile:
       return Tag == dwarf::DW_TAG_compile_unit;
     case dwarf::DW_UT_type:
       return Tag == dwarf::DW_TAG_type_unit;
     case dwarf::DW_UT_partial:

llvm/lib/DebugInfo/DWARF/DWARFDebugAbbrev.cpp

 
 DWARFAbbreviationDeclarationSet::DWARFAbbreviationDeclarationSet() {
   clear();
 }
 
 void DWARFAbbreviationDeclarationSet::clear() {
   Offset = 0;
   FirstAbbrCode = 0;
+  Data = std::nullopt;
+  CurOffset = 0;
   Decls.clear();
 }
 
 bool DWARFAbbreviationDeclarationSet::extract(DataExtractor Data,
-                                              uint64_t *OffsetPtr) {
+                                              uint64_t *OffsetPtr, bool Lazy) {
   clear();
-  const uint64_t BeginOffset = *OffsetPtr;
-  Offset = BeginOffset;
+  Offset = *OffsetPtr;
   DWARFAbbreviationDeclaration AbbrDecl;
   uint32_t PrevAbbrCode = 0;
   while (AbbrDecl.extract(Data, OffsetPtr)) {
     if (FirstAbbrCode == 0) {
       FirstAbbrCode = AbbrDecl.getCode();
     } else {
       if (PrevAbbrCode + 1 != AbbrDecl.getCode()) {
         // Codes are not consecutive, can't do O(1) lookups.
         FirstAbbrCode = UINT32_MAX;
       }
     }
     PrevAbbrCode = AbbrDecl.getCode();
     Decls.push_back(std::move(AbbrDecl));
+    if (Lazy) {
+      this->Data = Data;
+      CurOffset = *OffsetPtr;
+      return true;
+    }
   }
-  return BeginOffset != *OffsetPtr;
+  return Offset != *OffsetPtr;
 }
 
 void DWARFAbbreviationDeclarationSet::dump(raw_ostream &OS) const {
   for (const auto &Decl : Decls)
     Decl.dump(OS);
 }
 
 const DWARFAbbreviationDeclaration *
 DWARFAbbreviationDeclarationSet::getAbbreviationDeclaration(
     uint32_t AbbrCode) const {
   if (FirstAbbrCode == UINT32_MAX) {
     for (const auto &Decl : Decls) {
       if (Decl.getCode() == AbbrCode)
         return &Decl;
     }
-    return nullptr;
+  } else if (AbbrCode >= FirstAbbrCode &&
+             AbbrCode < FirstAbbrCode + Decls.size()) {
+    return &Decls[AbbrCode - FirstAbbrCode];
+  }
+  if (Data) {
+    DWARFAbbreviationDeclaration AbbrDecl;
+    uint32_t PrevAbbrCode = 0;
+    while (AbbrDecl.extract(*Data, &CurOffset)) {
+      if (FirstAbbrCode == 0) {
+        FirstAbbrCode = AbbrDecl.getCode();
+      } else {
+        if (PrevAbbrCode + 1 != AbbrDecl.getCode()) {
+          // Codes are not consecutive, can't do O(1) lookups.
+          FirstAbbrCode = UINT32_MAX;
+        }
+      }
+      PrevAbbrCode = AbbrDecl.getCode();
+      Decls.push_back(std::move(AbbrDecl));
+      if (AbbrDecl.getCode())
+        return &Decls.back();
+    }
+    CurOffset = 0;
+    Data = std::nullopt;
   }
-  if (AbbrCode < FirstAbbrCode || AbbrCode >= FirstAbbrCode + Decls.size())
-    return nullptr;
-  return &Decls[AbbrCode - FirstAbbrCode];
 }
 
 std::string DWARFAbbreviationDeclarationSet::getCodeRange() const {
   // Create a sorted list of all abbrev codes.
   std::vector<uint32_t> Codes;
   Codes.reserve(Decls.size());
   for (const auto &Decl : Decls)
     Codes.push_back(Decl.getCode());
void DWARFDebugAbbrev::dump(raw_ostream &OS) const {
   }
 
   for (const auto &I : AbbrDeclSets) {
     OS << format("Abbrev table for offset: 0x%8.8" PRIx64 "\n", I.first);
     I.second.dump(OS);
   }
 }
 
-const DWARFAbbreviationDeclarationSet*
-DWARFDebugAbbrev::getAbbreviationDeclarationSet(uint64_t CUAbbrOffset) const {
+const DWARFAbbreviationDeclarationSet *
+DWARFDebugAbbrev::getAbbreviationDeclarationSet(uint64_t CUAbbrOffset,
+                                                bool Lazy) const {
   const auto End = AbbrDeclSets.end();
   if (PrevAbbrOffsetPos != End && PrevAbbrOffsetPos->first == CUAbbrOffset) {
     return &(PrevAbbrOffsetPos->second);
   }
 
   const auto Pos = AbbrDeclSets.find(CUAbbrOffset);
   if (Pos != End) {
     PrevAbbrOffsetPos = Pos;
     return &(Pos->second);
   }
 
   if (Data && CUAbbrOffset < Data->getData().size()) {
     uint64_t Offset = CUAbbrOffset;
     DWARFAbbreviationDeclarationSet AbbrDecls;
-    if (!AbbrDecls.extract(*Data, &Offset))
+    if (!AbbrDecls.extract(*Data, &Offset, Lazy))
       return nullptr;
     PrevAbbrOffsetPos =
         AbbrDeclSets.insert(std::make_pair(CUAbbrOffset, std::move(AbbrDecls)))
             .first;
     return &PrevAbbrOffsetPos->second;
   }
 
   return nullptr;
 }

llvm/lib/DebugInfo/DWARF/DWARFDebugInfoEntry.cpp

bool DWARFDebugInfoEntry::extractFast(const DWARFUnit &U, uint64_t *OffsetPtr,
   }
   assert(DebugInfoData.isValidOffset(UEndOffset - 1));
   uint64_t AbbrCode = DebugInfoData.getULEB128(OffsetPtr);
   if (0 == AbbrCode) {
     // NULL debug tag entry.
     AbbrevDecl = nullptr;
     return true;
   }
-  const auto *AbbrevSet = U.getAbbreviations();
+  const auto *AbbrevSet = U.getAbbreviations(/*Lazy=*/true);
   if (!AbbrevSet) {
     U.getContext().getWarningHandler()(
         createStringError(errc::invalid_argument,
                           "DWARF unit at offset 0x%8.8" PRIx64 " "
                           "contains invalid abbreviation set offset 0x%" PRIx64,
                           U.getOffset(), U.getAbbreviationsOffset()));
     // Restore the original offset.
     *OffsetPtr = Offset;

llvm/lib/DebugInfo/DWARF/DWARFUnit.cpp

assert(getDIEIndex(Die) ==
                getDIEIndex(const_cast<DWARFUnit *>(this)->getUnitDIE()) &&
            "Bad unit die");
     return &DieArray.back();
   }
 
   return nullptr;
 }
 
-const DWARFAbbreviationDeclarationSet *DWARFUnit::getAbbreviations() const {
+const DWARFAbbreviationDeclarationSet *
+DWARFUnit::getAbbreviations(bool Lazy) const {
   if (!Abbrevs)
-    Abbrevs = Abbrev->getAbbreviationDeclarationSet(getAbbreviationsOffset());
+    Abbrevs =
+        Abbrev->getAbbreviationDeclarationSet(getAbbreviationsOffset(), Lazy);
   return Abbrevs;
 }
 
 std::optional<object::SectionedAddress> DWARFUnit::getBaseAddress() {
   if (BaseAddr)
     return BaseAddr;
 
   DWARFDie UnitDie = getUnitDIE();