llvm-dwarfdump: implement --find=<name>

[aprantl]

Summary

This patch implements the dwarfdump option --find=<name>.
This option looks for a DIE in the accelerator tables and dumps it if found.
This initial patch only adds support for .apple_names to keep the review small, adding the other sections and pubnames support should be trivial though.

[aprantl]

s/NAME/name/

[JDevlieghere]

include/llvm/DebugInfo/DWARF/DWARFContext.h

242

s/pointer/reference/

lib/DebugInfo/DWARF/DWARFAcceleratorTable.cpp

198

Why not Offset?

241

Not clang-formatted?

tools/llvm-dwarfdump/llvm-dwarfdump.cpp

254

Would it be worthwhile to stop iterating once found?

[aprantl]

Address review feedback form Jonas.

[probinson]

include/llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h

23

Forward declaration is redundant with the above #include.

test/tools/llvm-dwarfdump/X86/find.test

12

Maybe another CHECK-NOT to prove the name is associated with this subprogram? Might be overkill but we usually do something like that. Similarly for the MULTI cases below.

[aprantl]

Address review feedback from Paul.

[JDevlieghere]

To the extent of my knowledge about accelerator tables, this LGTM.

[dblaikie]

include/llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h

70

default?

72

Should this be const /ref/ return? (or non-const value, though iterators that return by value are problematic)

& what about operator->?

Should this class use one of the iterator facade helpers from llvm/ADT/iterator.h?

77

Prefer direct init over copy init:

X y = z;

rather than:

X y(z);

where possible.

include/llvm/BinaryFormat/Dwarf.h

enum {
     LINKAGE_OFFSET = 7,
     LINKAGE_MASK = 1 << LINKAGE_OFFSET
   };
 };
 
 /// Constants that define the DWARF format as 32 or 64 bit.
 enum DwarfFormat : uint8_t { DWARF32, DWARF64 };
 
+/// The Bernstein hash function used by the accelerator tables.
+uint32_t djbHash(StringRef Buffer);
+
 } // End of namespace dwarf
 
 } // End of namespace llvm
 
 #endif

include/llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h

 //===- DWARFAcceleratorTable.h ----------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_DWARFACCELERATORTABLE_H
 #define LLVM_DEBUGINFO_DWARFACCELERATORTABLE_H
 
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/DebugInfo/DWARF/DWARFDataExtractor.h"
-#include "llvm/DebugInfo/DWARF/DWARFRelocMap.h"
+#include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
 #include <cstdint>
 #include <utility>
 
 namespace llvm {
 
 class raw_ostream;
+class DWARFFormValue;
 
+/// This implements the Apple accelerator table format, a precursor of the
+/// DWARF 5 accelerator table format.
+/// TODO: Factor out a common base class for both formats.
 class DWARFAcceleratorTable {
   struct Header {
     uint32_t Magic;
     uint16_t Version;
     uint16_t HashFunction;
     uint32_t NumBuckets;
     uint32_t NumHashes;
     uint32_t HeaderDataLength;
   };
 
   struct HeaderData {
     using AtomType = uint16_t;
     using Form = dwarf::Form;
 
     uint32_t DIEOffsetBase;
     SmallVector<std::pair<AtomType, Form>, 3> Atoms;
   };
 
   struct Header Hdr;
   struct HeaderData HdrData;
   DWARFDataExtractor AccelSection;
   DataExtractor StringSection;
+  bool IsValid = false;
 
 public:
+  /// An iterator for the entries associated with one key. Each entry can have
+  /// multiple DWARFFormValues.
+  class ValueIterator : public std::iterator<std::input_iterator_tag,
+                                            ArrayRef<DWARFFormValue>> {
+    const DWARFAcceleratorTable *AccelTable = nullptr;
+    SmallVector<DWARFFormValue, 3> AtomForms; ///< The decoded data entry.
+
+    unsigned DataOffset = 0; ///< Offset into the section.
+    unsigned Data = 0; ///< Current data entry.
+    unsigned NumData = 0; ///< Number of data entries.
+
+    /// Advance the iterator.
+    void Next();
+  public:
+    /// Construct a new iterator for the entries at \p DataOffset.
+    ValueIterator(const DWARFAcceleratorTable &AccelTable, unsigned DataOffset);
+    /// End marker.
+    ValueIterator() : NumData(0) {}
+
+    const ArrayRef<DWARFFormValue> operator*() const {
+      return AtomForms;
+    }
+    ValueIterator &operator++() { Next(); return *this; }
+    ValueIterator operator++(int) {
+      ValueIterator I(*this);
+      Next();
+      return I;
+    }
+    friend bool operator==(const ValueIterator &A, const ValueIterator &B) {
+      return A.NumData == B.NumData && A.DataOffset == B.DataOffset;
+    }
+    friend bool operator!=(const ValueIterator &A, const ValueIterator &B) {
+      return !(A == B);
+    }
+  };
+
+
   DWARFAcceleratorTable(const DWARFDataExtractor &AccelSection,
                         DataExtractor StringSection)
       : AccelSection(AccelSection), StringSection(StringSection) {}
 
   bool extract();
   uint32_t getNumBuckets();
   uint32_t getNumHashes();
   uint32_t getSizeHdr();
   uint32_t getHeaderDataLength();
   ArrayRef<std::pair<HeaderData::AtomType, HeaderData::Form>> getAtomsDesc();
   bool validateForms();
 
   /// Return information related to the DWARF DIE we're looking for when
   /// performing a lookup by name.
   ///
   /// \param HashDataOffset an offset into the hash data table
   /// \returns <DieOffset, DieTag>
   /// DieOffset is the offset into the .debug_info section for the DIE
   /// related to the input hash data offset.
   /// DieTag is the tag of the DIE
   std::pair<uint32_t, dwarf::Tag> readAtoms(uint32_t &HashDataOffset);
   void dump(raw_ostream &OS) const;
+
+  /// Look up all entries in the accelerator table matching \c Key.
+  iterator_range<ValueIterator> equal_range(StringRef Key) const;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_DWARFACCELERATORTABLE_H

include/llvm/DebugInfo/DWARF/DWARFContext.h

 
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/DebugInfo/DIContext.h"
+#include "llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h"
 #include "llvm/DebugInfo/DWARF/DWARFCompileUnit.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugAbbrev.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugAranges.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugFrame.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugLine.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugLoc.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugMacro.h"
 #include "llvm/DebugInfo/DWARF/DWARFDie.h"
class DWARFContext : public DIContext {
   std::unique_ptr<DWARFUnitIndex> TUIndex;
   std::unique_ptr<DWARFDebugAbbrev> Abbrev;
   std::unique_ptr<DWARFDebugLoc> Loc;
   std::unique_ptr<DWARFDebugAranges> Aranges;
   std::unique_ptr<DWARFDebugLine> Line;
   std::unique_ptr<DWARFDebugFrame> DebugFrame;
   std::unique_ptr<DWARFDebugFrame> EHFrame;
   std::unique_ptr<DWARFDebugMacro> Macro;
+  std::unique_ptr<DWARFAcceleratorTable> AppleNames;
 
   DWARFUnitSection<DWARFCompileUnit> DWOCUs;
   std::deque<DWARFUnitSection<DWARFTypeUnit>> DWOTUs;
   std::unique_ptr<DWARFDebugAbbrev> AbbrevDWO;
   std::unique_ptr<DWARFDebugLocDWO> LocDWO;
 
   /// The maximum DWARF version of all units.
   unsigned MaxVersion = 0;
public:
   const DWARFDebugFrame *getDebugFrame();
 
   /// Get a pointer to the parsed eh frame information object.
   const DWARFDebugFrame *getEHFrame();
 
   /// Get a pointer to the parsed DebugMacro object.
   const DWARFDebugMacro *getDebugMacro();
 
+  /// Get a pointer to the parsed accelerator table object.
+  const DWARFAcceleratorTable &getAppleNames();
+
   /// Get a pointer to a parsed line table corresponding to a compile unit.
   const DWARFDebugLine::LineTable *getLineTableForUnit(DWARFUnit *cu);
 
   DILineInfo getLineInfoForAddress(uint64_t Address,
       DILineInfoSpecifier Specifier = DILineInfoSpecifier()) override;
   DILineInfoTable getLineInfoForAddressRange(uint64_t Address, uint64_t Size,
       DILineInfoSpecifier Specifier = DILineInfoSpecifier()) override;
   DIInliningInfo getInliningInfoForAddress(uint64_t Address,

lib/BinaryFormat/Dwarf.cpp

 bool llvm::dwarf::isValidFormForVersion(Form F, unsigned Version,
                                         bool ExtensionsOk) {
   if (FormVendor(F) == DWARF_VENDOR_DWARF) {
     unsigned FV = FormVersion(F);
     return FV > 0 && FV <= Version;
   }
   return ExtensionsOk;
 }
+
+uint32_t llvm::dwarf::djbHash(StringRef Buffer) {
+  uint32_t H = 5381;
+  for (char C : Buffer.bytes())
+    H = ((H << 5) + H) + C;
+  return H;
+}

lib/CodeGen/AsmPrinter/DwarfAccelTable.h

 // grab the offset in the data for our final match.
 
 namespace llvm {
 
 class AsmPrinter;
 class DwarfDebug;
 
 class DwarfAccelTable {
-  static uint32_t HashDJB(StringRef Str) {
-    uint32_t h = 5381;
-    for (unsigned i = 0, e = Str.size(); i != e; ++i)
-      h = ((h << 5) + h) + Str[i];
-    return h;
-  }
-
   // Helper function to compute the number of buckets needed based on
   // the number of unique hashes.
   void ComputeBucketCount();
 
   struct TableHeader {
     uint32_t magic = MagicHash; // 'HASH' magic value to allow endian detection
     uint16_t version = 1;       // Version number.
     uint16_t hash_function = dwarf::DW_hash_function_djb;
private:
   struct HashData {
     StringRef Str;
     uint32_t HashValue;
     MCSymbol *Sym;
     DwarfAccelTable::DataArray &Data; // offsets
 
     HashData(StringRef S, DwarfAccelTable::DataArray &Data)
         : Str(S), Data(Data) {
-      HashValue = DwarfAccelTable::HashDJB(S);
+      HashValue = dwarf::djbHash(S);
     }
 
 #ifndef NDEBUG
     void print(raw_ostream &OS) {
       OS << "Name: " << Str << "\n";
       OS << "  Hash Value: " << format("0x%x", HashValue) << "\n";
       OS << "  Symbol: ";
       if (Sym)

lib/DebugInfo/DWARF/DWARFAcceleratorTable.cpp

 //===- DWARFAcceleratorTable.cpp ------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h"
 
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
-#include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
 #include "llvm/DebugInfo/DWARF/DWARFRelocMap.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cstddef>
 #include <cstdint>
 #include <utility>
 
bool DWARFAcceleratorTable::extract() {
   uint32_t NumAtoms = AccelSection.getU32(&Offset);
 
   for (unsigned i = 0; i < NumAtoms; ++i) {
     uint16_t AtomType = AccelSection.getU16(&Offset);
     auto AtomForm = static_cast<dwarf::Form>(AccelSection.getU16(&Offset));
     HdrData.Atoms.push_back(std::make_pair(AtomType, AtomForm));
   }
 
+  IsValid = true;
   return true;
 }
 
 uint32_t DWARFAcceleratorTable::getNumBuckets() { return Hdr.NumBuckets; }
 uint32_t DWARFAcceleratorTable::getNumHashes() { return Hdr.NumHashes; }
 uint32_t DWARFAcceleratorTable::getSizeHdr() { return sizeof(Hdr); }
 uint32_t DWARFAcceleratorTable::getHeaderDataLength() {
   return Hdr.HeaderDataLength;
for (auto Atom : getAtomsDesc()) {
     default:
       break;
     }
   }
   return {DieOffset, DieTag};
 }
 
 LLVM_DUMP_METHOD void DWARFAcceleratorTable::dump(raw_ostream &OS) const {
+  if (!IsValid)
+    return;
+
   // Dump the header.
   OS << "Magic = " << format("0x%08x", Hdr.Magic) << '\n'
      << "Version = " << format("0x%04x", Hdr.Version) << '\n'
      << "Hash function = " << format("0x%08x", Hdr.HashFunction) << '\n'
      << "Bucket count = " << Hdr.NumBuckets << '\n'
      << "Hashes count = " << Hdr.NumHashes << '\n'
      << "HeaderData length = " << Hdr.HeaderDataLength << '\n'
      << "DIE offset base = " << HdrData.DIEOffsetBase << '\n'
for (unsigned HashIdx = Index; HashIdx < Hdr.NumHashes; ++HashIdx) {
             OS << "} ";
           }
           OS << '\n';
         }
       }
     }
   }
 }
+
+DWARFAcceleratorTable::ValueIterator::ValueIterator(
+    const DWARFAcceleratorTable &AccelTable, unsigned Ofs)
+    : AccelTable(&AccelTable), DataOffset(Ofs) {
+  if (!AccelTable.AccelSection.isValidOffsetForDataOfSize(DataOffset, 4))
+    return;
+
+  for (const auto &Atom : AccelTable.HdrData.Atoms)
+    AtomForms.push_back(DWARFFormValue(Atom.second));
+
+  // Read the first entry.
+  NumData = AccelTable.AccelSection.getU32(&DataOffset);
+  Next();
+}
+
+void DWARFAcceleratorTable::ValueIterator::Next() {
+  assert(NumData > 0 && "attempted to increment iterator past the end");
+  auto &AccelSection = AccelTable->AccelSection;
+  if (Data >= NumData ||
+      !AccelSection.isValidOffsetForDataOfSize(DataOffset, 4)) {
+    NumData = 0;
+    return;
+  }
+  for (auto &Atom : AtomForms)
+    Atom.extractValue(AccelSection, &DataOffset, nullptr);
+  ++Data;
+}
+
+iterator_range<DWARFAcceleratorTable::ValueIterator>
+DWARFAcceleratorTable::equal_range(StringRef Key) const {
+  if (!IsValid)
+    return make_range(ValueIterator(), ValueIterator());
+
+  // Find the bucket.
+  unsigned HashValue = dwarf::djbHash(Key);
+  unsigned Bucket = HashValue % Hdr.NumBuckets;
+  unsigned BucketBase = sizeof(Hdr) + Hdr.HeaderDataLength;
+  unsigned HashesBase = BucketBase + Hdr.NumBuckets * 4;
+  unsigned OffsetsBase = HashesBase + Hdr.NumHashes * 4;
+
+  unsigned BucketOffset = BucketBase + Bucket * 4;
+  unsigned Index = AccelSection.getU32(&BucketOffset);
+      
+  // Search through all hashes in the bucket.
+  for (unsigned HashIdx = Index; HashIdx < Hdr.NumHashes; ++HashIdx) {
+    unsigned HashOffset = HashesBase + HashIdx*4;
+    unsigned OffsetsOffset = OffsetsBase + HashIdx*4;
+    uint32_t Hash = AccelSection.getU32(&HashOffset);
+
+    if (Hash % Hdr.NumBuckets != Bucket)
+      // We are already in the next bucket.
+      break;
+
+    unsigned DataOffset = AccelSection.getU32(&OffsetsOffset);
+    unsigned StringOffset = AccelSection.getRelocatedValue(4, &DataOffset);
+    if (!StringOffset)
+      break;
+
+    // Finally compare the key.
+    if (Key == StringSection.getCStr(&StringOffset))
+      return make_range({*this, DataOffset}, ValueIterator());
+  }
+  return make_range(ValueIterator(), ValueIterator());
+}

lib/DebugInfo/DWARF/DWARFContext.cpp

void DWARFContext::dump(
 
   if (shouldDump(Explicit, ".gnu_index", DIDT_ID_GdbIndex,
                  DObj->getGdbIndexSection())) {
     getGdbIndex().dump(OS);
   }
 
   if (shouldDump(Explicit, ".apple_names", DIDT_ID_AppleNames,
                  DObj->getAppleNamesSection().Data))
-    dumpAccelSection(OS, *DObj, DObj->getAppleNamesSection(),
-                     DObj->getStringSection(), isLittleEndian());
+    getAppleNames().dump(OS);
 
   if (shouldDump(Explicit, ".apple_types", DIDT_ID_AppleTypes,
                  DObj->getAppleTypesSection().Data))
     dumpAccelSection(OS, *DObj, DObj->getAppleTypesSection(),
                      DObj->getStringSection(), isLittleEndian());
 
   if (shouldDump(Explicit, ".apple_namespaces", DIDT_ID_AppleNamespaces,
                  DObj->getAppleNamespacesSection().Data))
if (Macro)
     return Macro.get();
 
   DataExtractor MacinfoData(DObj->getMacinfoSection(), isLittleEndian(), 0);
   Macro.reset(new DWARFDebugMacro());
   Macro->parse(MacinfoData);
   return Macro.get();
 }
 
+static DWARFAcceleratorTable &
+getAccelTable(std::unique_ptr<DWARFAcceleratorTable> &Cache,
+              const DWARFObject &Obj, const DWARFSection &Section,
+              StringRef StringSection, bool IsLittleEndian) {
+  if (Cache)
+    return *Cache;
+  DWARFDataExtractor AccelSection(Obj, Section, IsLittleEndian, 0);
+  DataExtractor StrData(StringSection, IsLittleEndian, 0);
+  Cache.reset(new DWARFAcceleratorTable(AccelSection, StrData));
+  Cache->extract();
+  return *Cache;
+}
+
+const DWARFAcceleratorTable &DWARFContext::getAppleNames() {
+  return getAccelTable(AppleNames, *DObj, DObj->getAppleNamesSection(),
+                       DObj->getStringSection(), isLittleEndian());
+}
+
 const DWARFLineTable *
 DWARFContext::getLineTableForUnit(DWARFUnit *U) {
   if (!Line)
     Line.reset(new DWARFDebugLine);
 
   auto UnitDIE = U->getUnitDIE();
   if (!UnitDIE)
     return nullptr;

test/tools/llvm-dwarfdump/X86/find.test

+RUN: llvm-mc %S/brief.s -filetype obj -triple x86_64-apple-darwin -o - \
+RUN:   | llvm-dwarfdump -find=not_there_at_all - | \
+RUN: FileCheck %s --check-prefix=EMPTY --allow-empty
+EMPTY: {{^$}}
+
+RUN: llvm-mc %S/brief.s -filetype obj -triple x86_64-apple-darwin -o - \
+RUN:   | llvm-dwarfdump -find=main - | FileCheck %s
+CHECK: .debug_info contents:
+CHECK-NOT: {{:}}
+CHECK: : DW_TAG_subprogram
+CHECK:     DW_AT_name ("main")
+CHECK-NOT: {{:}}
+
+RUN: llvm-dwarfdump --debug-info %S/../../dsymutil/Inputs/libfat-test.a \
+RUN:   -find=x86_64h_var -find=i386_var \
+RUN:   | FileCheck %s --check-prefix=MULTI
+MULTI: .debug_info contents:
+MULTI-NOT: {{: DW}}
+MULTI: : DW_TAG_variable
+MULTI:    DW_AT_name ("i386_var")
+MULTI-NOT: {{: DW}}
+MULTI: .debug_info contents:
+MULTI: : DW_TAG_variable
+MULTI:    DW_AT_name ("x86_64h_var")
+MULTI-NOT: {{: DW}}

test/tools/llvm-dwarfdump/cmdline.test

 RUN: llvm-dwarfdump -h 2>&1 | FileCheck --check-prefix=HELP %s
 RUN: llvm-dwarfdump --help 2>&1 | FileCheck --check-prefix=HELP %s
 HELP: USAGE: llvm-dwarfdump{{[^ ]*}} [options] <input object files or .dSYM bundles>
 HELP-NOT: -reverse-iterate
 HELP: Section-specific Dump Options
 HELP: -debug-info            - Dump the .debug_info section
 HELP: -eh-frame
 HELP: Specific Options
+HELP: -find
 HELP: -recurse-depth=<N> 
 HELP: -show-children
 HELP: -show-parents
 HELP: -summarize-types
 HELP-NOT: -reverse-iterate
 
 RUN: llvm-dwarfdump --version 2>&1 | FileCheck --check-prefix=VERSION %s
 VERSION: {{ version }}

tools/llvm-dwarfdump/llvm-dwarfdump.cpp

static alias DumpDebugFrameAlias("eh-frame", desc("Alias for -debug-frame"),
                                  aliasopt(DumpDebugFrame));
 static list<std::string>
     ArchFilters("arch",
                 desc("Dump debug information for the specified CPU "
                      "architecture only. Architectures may be specified by "
                      "name or by number. This option can be specified "
                      "multiple times, once for each desired architecture."),
                 cat(DwarfDumpCategory));
+static list<std::string>
+    Find("find",
+         desc("Search for the exact match for <name> in the accelerator tables "
+              "and print the matching debug information entries."),
+         value_desc("name"), cat(DwarfDumpCategory));
+static alias FindAlias("f", desc("Alias for -find"), aliasopt(Find));
+
 static opt<bool> DumpUUID("uuid", desc("Show the UUID for each architecture"),
                           cat(DwarfDumpCategory));
 static alias DumpUUIDAlias("u", desc("Alias for -uuid"), aliasopt(DumpUUID));
 static opt<std::string>
     OutputFilename("out-file", cl::init(""),
                    cl::desc("Redirect output to the specified file"),
                    cl::value_desc("filename"));
 static alias OutputFilenameAlias("o", desc("Alias for -out-file"),

 static alias ShowParentsAlias("p", desc("Alias for -show-parents"),
                               aliasopt(ShowParents));
 static opt<unsigned> RecurseDepth(
     "recurse-depth",
     desc("Only recurse to a depth of N when displaying debug info entries."),
     cat(DwarfDumpCategory), init(-1U), value_desc("N"));
 static alias RecurseDepthAlias("r", desc("Alias for -recurse-depth"),
                                aliasopt(RecurseDepth));
   
 static opt<bool>
     SummarizeTypes("summarize-types",
                    desc("Abbreviate the description of type unit entries"),
                    cat(DwarfDumpCategory));
 static opt<bool> Verify("verify", desc("Verify the DWARF debug info"),
                         cat(DwarfDumpCategory));
 static opt<bool> Quiet("quiet", desc("Use with -verify to not emit to STDOUT."),
                        cat(DwarfDumpCategory));

 
 using HandlerFn = std::function<bool(ObjectFile &, DWARFContext &DICtx, Twine,
                                      raw_ostream &)>;
 
 static bool dumpObjectFile(ObjectFile &Obj, DWARFContext &DICtx, Twine Filename,
                            raw_ostream &OS) {
   logAllUnhandledErrors(DICtx.loadRegisterInfo(Obj), errs(),
                         Filename.str() + ": ");
+
+  // Handle the --find option and lower it to --debug-info=<offset>.
+  if (!Find.empty()) {
+    DumpOffsets[DIDT_ID_DebugInfo] = None;
+    for (auto Name : Find)
+      for (auto Entry : DICtx.getAppleNames().equal_range(Name))
+        for (auto Atom : Entry)
+          if (auto Offset = Atom.getAsSectionOffset())
+            DumpOffsets[DIDT_ID_DebugInfo] = *Offset;
+    // Early exit if --find was specified but the current file doesn't have it.
+    if (!DumpOffsets[DIDT_ID_DebugInfo])
+      return true;
+  }
+  
   // The UUID dump already contains all the same information.
   if (!(DumpType & DIDT_UUID) || DumpType == DIDT_All)
     OS << Filename << ":\tfile format " << Obj.getFileFormatName() << '\n';
 
   // Dump the complete DWARF structure.
   DICtx.dump(OS, getDumpOpts(), DumpOffsets);
   return true;
 }