[NFC] [Object] Create library to fetch debug info by build ID.

[mysterymath]

Summary

This creates a library for fetching debug info by build ID, whether
locally or remotely via debuginfod. The functionality was refactored
out of existing code in the Symboliize library. Existing utilities
were refactored to use this library.

[dblaikie]

llvm/include/llvm/Debuginfod/BuildIDFetcher.h

25

llvm/include/llvm/Object/BuildID.h

42

[mysterymath]

Remove unneeded semicolons.

[MaskRay]

[NFC] [Object] Refactor out library to fetch debug info by build ID.

typo? [Object] Refactor Object to fetch debug info by build ID?

[mysterymath]

Update commit message.

[mysterymath]

In D132504#3779234, @MaskRay wrote:

[NFC] [Object] Refactor out library to fetch debug info by build ID.

typo? [Object] Refactor Object to fetch debug info by build ID?

The intent was "refactor-out", as in "extract by refactoring." Changed wording to "Create".

[mysterymath]

Correct clang-format error.

[mysterymath]

Trim includes.

[phosek]

This could be potentially split into multiple smaller patches to make this easier to review, land and revert (if needed). For example introducing llvm/include/llvm/Object/BuildID.h with just BuildID and BuildIDRef types and their usage could be its own patch. With that being said, I'd be also fine with this landing as is.

llvm/include/llvm/DebugInfo/Symbolize/DIFetcher.h

-//===-- llvm/DebugInfo/Symbolize/DIFetcher.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
-//
-//===----------------------------------------------------------------------===//
-///
-/// \file
-/// This file declares a DIFetcher abstraction for obtaining debug info from an
-/// arbitrary outside source.
-///
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_DEBUGINFO_SYMBOLIZE_DIFETCHER_H
-#define LLVM_DEBUGINFO_SYMBOLIZE_DIFETCHER_H
-
-#include <cstdint>
-#include <string>
-
-#include "llvm/ADT/ArrayRef.h"
-
-namespace llvm {
-namespace symbolize {
-
-/// The DIFetcher interface provides arbitrary mechanisms for obtaining debug
-/// info from an outside source.
-class DIFetcher {
-public:
-  virtual ~DIFetcher() = default;
-  virtual Optional<std::string>
-  fetchBuildID(ArrayRef<uint8_t> BuildID) const = 0;
-};
-
-/// LocalDIFetcher searches local cache directories for debug info.
-class LocalDIFetcher : public DIFetcher {
-public:
-  LocalDIFetcher(ArrayRef<std::string> DebugFileDirectory)
-      : DebugFileDirectory(DebugFileDirectory){};
-  virtual ~LocalDIFetcher() = default;
-
-  Optional<std::string> fetchBuildID(ArrayRef<uint8_t> BuildID) const override;
-
-private:
-  const ArrayRef<std::string> DebugFileDirectory;
-};
-
-} // end namespace symbolize
-} // end namespace llvm
-
-#endif // LLVM_DEBUGINFO_SYMBOLIZE_DIFETCHER_H

llvm/include/llvm/DebugInfo/Symbolize/Symbolize.h

 
 #ifndef LLVM_DEBUGINFO_SYMBOLIZE_SYMBOLIZE_H
 #define LLVM_DEBUGINFO_SYMBOLIZE_SYMBOLIZE_H
 
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/ilist_node.h"
 #include "llvm/ADT/simple_ilist.h"
 #include "llvm/DebugInfo/DIContext.h"
-#include "llvm/DebugInfo/Symbolize/DIFetcher.h"
 #include "llvm/Object/Binary.h"
+#include "llvm/Object/BuildID.h"
 #include "llvm/Support/Error.h"
 #include <algorithm>
 #include <cstdint>
 #include <map>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
public:
   // given in the options. Calling this invalidates references in the DI...
   // objects returned by the methods above.
   void pruneCache();
 
   static std::string
   DemangleName(const std::string &Name,
                const SymbolizableModule *DbiModuleDescriptor);
 
-  void addDIFetcher(std::unique_ptr<DIFetcher> Fetcher) {
-    DIFetchers.push_back(std::move(Fetcher));
+  void setBuildIDFetcher(std::unique_ptr<BuildIDFetcher> Fetcher) {
+    BIDFetcher = std::move(Fetcher);
   }
 
 private:
   // Bundles together object file with code/data and object file with
   // corresponding debug info. These objects can be the same.
   using ObjectPair = std::pair<const ObjectFile *, const ObjectFile *>;
 
   template <typename T>
private:
 
   /// Parsed object file for path/architecture pair, where "path" refers
   /// to Mach-O universal binary.
   std::map<std::pair<std::string, std::string>, std::unique_ptr<ObjectFile>>
       ObjectForUBPathAndArch;
 
   Options Opts;
 
-  SmallVector<std::unique_ptr<DIFetcher>> DIFetchers;
+  std::unique_ptr<BuildIDFetcher> BIDFetcher;
 };
 
 // A binary intrusively linked into a LRU cache list. If the binary is empty,
 // then the entry marks that an error occurred, and it is not part of the LRU
 // list.
 class CachedBinary : public ilist_node<CachedBinary> {
 public:
   CachedBinary() = default;
public:
 
   size_t size() { return Bin.getBinary()->getData().size(); }
 
 private:
   OwningBinary<Binary> Bin;
   std::function<void()> Evictor;
 };
 
-Optional<ArrayRef<uint8_t>> getBuildID(const ELFObjectFileBase *Obj);
-
 } // end namespace symbolize
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_SYMBOLIZE_SYMBOLIZE_H

llvm/include/llvm/Debuginfod/BuildIDFetcher.h

-//===- llvm/DebugInfod/DIFetcher.h - Debug info fetcher----------*- C++ -*-===//
+//===- llvm/DebugInfod/BuildIDFetcher.h - Build ID fetcher ------*- 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
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
-/// This file declares a DIFetcher implementation for obtaining debug info from
-/// debuginfod.
+/// This file declares a Build ID fetcher implementation for obtaining debug
+/// info from debuginfod.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFOD_DIFETCHER_H
 #define LLVM_DEBUGINFOD_DIFETCHER_H
 
-#include "llvm/ADT/ArrayRef.h"
-#include "llvm/DebugInfo/Symbolize/DIFetcher.h"
+#include "llvm/Object/BuildID.h"
 
 namespace llvm {
 
-class DebuginfodDIFetcher : public symbolize::DIFetcher {
+class DebuginfodFetcher : public object::BuildIDFetcher {
 public:
-  virtual ~DebuginfodDIFetcher() = default;
+  DebuginfodFetcher(std::vector<std::string> DebugFileDirectories)
+      : BuildIDFetcher(std::move(DebugFileDirectories)) {}
+  virtual ~DebuginfodFetcher() = default;
 
   /// Fetches the given Build ID using debuginfod and returns a local path to
-  /// the resulting debug binary.
-  Optional<std::string> fetchBuildID(ArrayRef<uint8_t> BuildID) const override;
+  /// the resulting file.
+  Optional<std::string> fetch(object::BuildIDRef BuildID) const override;
 };
 
 } // namespace llvm
 
 #endif // LLVM_DEBUGINFOD_DIFETCHER_H

llvm/include/llvm/Debuginfod/Debuginfod.h

 /// DebuginfodLogEntry and DebuginfodServer structs, as well as the
 /// DebuginfodLog, DebuginfodCollection classes.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFOD_DEBUGINFOD_H
 #define LLVM_DEBUGINFOD_DEBUGINFOD_H
 
+#include "HTTPServer.h"
+
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
-#include "llvm/Debuginfod/HTTPServer.h"
+#include "llvm/Object/BuildID.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Mutex.h"
 #include "llvm/Support/RWMutex.h"
 #include "llvm/Support/Timer.h"
 
 #include <chrono>
 #include <condition_variable>
 #include <queue>
 
 namespace llvm {
 
-typedef ArrayRef<uint8_t> BuildIDRef;
-
-typedef SmallVector<uint8_t, 10> BuildID;
-
 /// Finds default array of Debuginfod server URLs by checking DEBUGINFOD_URLS
 /// environment variable.
 Expected<SmallVector<StringRef>> getDefaultDebuginfodUrls();
 
 /// Finds a default local file caching directory for the debuginfod client,
 /// first checking DEBUGINFOD_CACHE_PATH.
 Expected<std::string> getDefaultDebuginfodCacheDirectory();
 
 /// Finds a default timeout for debuginfod HTTP requests. Checks
 /// DEBUGINFOD_TIMEOUT environment variable, default is 90 seconds (90000 ms).
 std::chrono::milliseconds getDefaultDebuginfodTimeout();
 
 /// Fetches a specified source file by searching the default local cache
 /// directory and server URLs.
-Expected<std::string> getCachedOrDownloadSource(BuildIDRef ID,
+Expected<std::string> getCachedOrDownloadSource(object::BuildIDRef ID,
                                                 StringRef SourceFilePath);
 
 /// Fetches an executable by searching the default local cache directory and
 /// server URLs.
-Expected<std::string> getCachedOrDownloadExecutable(BuildIDRef ID);
+Expected<std::string> getCachedOrDownloadExecutable(object::BuildIDRef ID);
 
 /// Fetches a debug binary by searching the default local cache directory and
 /// server URLs.
-Expected<std::string> getCachedOrDownloadDebuginfo(BuildIDRef ID);
+Expected<std::string> getCachedOrDownloadDebuginfo(object::BuildIDRef ID);
 
 /// Fetches any debuginfod artifact using the default local cache directory and
 /// server URLs.
 Expected<std::string> getCachedOrDownloadArtifact(StringRef UniqueKey,
                                                   StringRef UrlPath);
 
 /// Fetches any debuginfod artifact using the specified local cache directory,
 /// server URLs, and request timeout (in milliseconds). If the artifact is

 /// Tracks a collection of debuginfod artifacts on the local filesystem.
 class DebuginfodCollection {
   SmallVector<std::string, 1> Paths;
   sys::RWMutex BinariesMutex;
   StringMap<std::string> Binaries;
   sys::RWMutex DebugBinariesMutex;
   StringMap<std::string> DebugBinaries;
   Error findBinaries(StringRef Path);
-  Expected<Optional<std::string>> getDebugBinaryPath(BuildIDRef);
-  Expected<Optional<std::string>> getBinaryPath(BuildIDRef);
+  Expected<Optional<std::string>> getDebugBinaryPath(object::BuildIDRef);
+  Expected<Optional<std::string>> getBinaryPath(object::BuildIDRef);
   // If the collection has not been updated since MinInterval, call update() and
   // return true. Otherwise return false. If update returns an error, return the
   // error.
   Expected<bool> updateIfStale();
   DebuginfodLog &Log;
   ThreadPool &Pool;
   Timer UpdateTimer;
   sys::Mutex UpdateMutex;
 
   // Minimum update interval, in seconds, for on-demand updates triggered when a
   // build-id is not found.
   double MinInterval;
 
 public:
   DebuginfodCollection(ArrayRef<StringRef> Paths, DebuginfodLog &Log,
                        ThreadPool &Pool, double MinInterval);
   Error update();
   Error updateForever(std::chrono::milliseconds Interval);
-  Expected<std::string> findDebugBinaryPath(BuildIDRef);
-  Expected<std::string> findBinaryPath(BuildIDRef);
+  Expected<std::string> findDebugBinaryPath(object::BuildIDRef);
+  Expected<std::string> findBinaryPath(object::BuildIDRef);
 };
 
 struct DebuginfodServer {
   HTTPServer Server;
   DebuginfodLog &Log;
   DebuginfodCollection &Collection;
   DebuginfodServer(DebuginfodLog &Log, DebuginfodCollection &Collection);
 };
 
 } // end namespace llvm
 
 #endif

llvm/include/llvm/Object/BuildID.h

+//===- llvm/Object/BuildID.h - Build ID -------------------------*- 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
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file declares a library for handling Build IDs and using them to find
+/// debug info.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DEBUGINFO_OBJECT_BUILDID_H
+#define LLVM_DEBUGINFO_OBJECT_BUILDID_H
+
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/SmallVector.h"
+
+namespace llvm {
+namespace object {
+
+/// A build ID in binary form.
+typedef SmallVector<uint8_t, 10> BuildID;
+
+/// A reference to a BuildID in binary form.
+typedef ArrayRef<uint8_t> BuildIDRef;
+
+class ObjectFile;
+
+/// Returns the build ID, if any, contained in the given object file.
+Optional<BuildIDRef> getBuildID(const ObjectFile *Obj);
+
+/// BuildIDFetcher searches local cache directories for debug info.
+class BuildIDFetcher {
+public:
+  BuildIDFetcher(std::vector<std::string> DebugFileDirectories)
+      : DebugFileDirectories(std::move(DebugFileDirectories)) {}
+  virtual ~BuildIDFetcher() = default;
+
+  /// Returns the path to the debug file with the given build ID.
+  virtual Optional<std::string> fetch(BuildIDRef BuildID) const;
+
+private:
+  const std::vector<std::string> DebugFileDirectories;
+};
+
+} // namespace object
+} // namespace llvm
+
+#endif // LLVM_DEBUGINFO_OBJECT_BUILDID_H

llvm/include/llvm/Object/ObjectFile.h

public:
   virtual section_iterator section_begin() const = 0;
   virtual section_iterator section_end() const = 0;
 
   using section_iterator_range = iterator_range<section_iterator>;
   section_iterator_range sections() const {
     return section_iterator_range(section_begin(), section_end());
   }
 
+  virtual bool hasDebugInfo() const;
+
   /// The number of bytes used to represent an address in this object
   ///        file format.
   virtual uint8_t getBytesInAddress() const = 0;
 
   virtual StringRef getFileFormatName() const = 0;
   virtual Triple::ArchType getArch() const = 0;
   virtual SubtargetFeatures getFeatures() const = 0;
   virtual Optional<StringRef> tryGetCPUName() const { return None; };

llvm/lib/DebugInfo/Symbolize/CMakeLists.txt

 add_llvm_component_library(LLVMSymbolize
-  DIFetcher.cpp
   DIPrinter.cpp
   Markup.cpp
   MarkupFilter.cpp
   SymbolizableObjectFile.cpp
   Symbolize.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/DebugInfo/Symbolize
 
   LINK_COMPONENTS
   DebugInfoDWARF
   DebugInfoPDB
   Object
   Support
   Demangle
   )

llvm/lib/DebugInfo/Symbolize/DIFetcher.cpp

-//===-- lib/DebugInfo/Symbolize/DIFetcher.cpp -----------------------------===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-///
-/// \file
-/// This file defines the implementation of the local debug info fetcher, which
-/// searches cache directories.
-///
-//===----------------------------------------------------------------------===//
-
-#include "llvm/DebugInfo/Symbolize/DIFetcher.h"
-
-#include "llvm/Support/FileSystem.h"
-#include "llvm/Support/Path.h"
-
-namespace llvm {
-namespace symbolize {
-
-Optional<std::string>
-LocalDIFetcher::fetchBuildID(ArrayRef<uint8_t> BuildID) const {
-  auto GetDebugPath = [&](StringRef Directory) {
-    SmallString<128> Path{Directory};
-    sys::path::append(Path, ".build-id",
-                      llvm::toHex(BuildID[0], /*LowerCase=*/true),
-                      llvm::toHex(BuildID.slice(1), /*LowerCase=*/true));
-    Path += ".debug";
-    return Path;
-  };
-  if (DebugFileDirectory.empty()) {
-    SmallString<128> Path = GetDebugPath(
-#if defined(__NetBSD__)
-        // Try /usr/libdata/debug/.build-id/../...
-        "/usr/libdata/debug"
-#else
-        // Try /usr/lib/debug/.build-id/../...
-        "/usr/lib/debug"
-#endif
-    );
-    if (llvm::sys::fs::exists(Path))
-      return std::string(Path);
-  } else {
-    for (const auto &Directory : DebugFileDirectory) {
-      // Try <debug-file-directory>/.build-id/../...
-      SmallString<128> Path = GetDebugPath(Directory);
-      if (llvm::sys::fs::exists(Path))
-        return std::string(Path);
-    }
-  }
-  return None;
-}
-
-} // namespace symbolize
-} // namespace llvm

llvm/lib/DebugInfo/Symbolize/Symbolize.cpp

 //===----------------------------------------------------------------------===//
 
 #include "llvm/DebugInfo/Symbolize/Symbolize.h"
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/DebugInfo/PDB/PDB.h"
 #include "llvm/DebugInfo/PDB/PDBContext.h"
-#include "llvm/DebugInfo/Symbolize/DIFetcher.h"
 #include "llvm/DebugInfo/Symbolize/SymbolizableObjectFile.h"
 #include "llvm/Demangle/Demangle.h"
+#include "llvm/Object/BuildID.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Object/ELFObjectFile.h"
 #include "llvm/Object/MachO.h"
 #include "llvm/Object/MachOUniversal.h"
 #include "llvm/Support/CRC.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/DataExtractor.h"
 #include "llvm/Support/Errc.h"

 }
 namespace object {
 template <class ELFT> class ELFFile;
 }
 namespace symbolize {
 
 LLVMSymbolizer::LLVMSymbolizer() = default;
 
-LLVMSymbolizer::LLVMSymbolizer(const Options &Opts) : Opts(Opts) {}
+LLVMSymbolizer::LLVMSymbolizer(const Options &Opts)
+    : Opts(Opts),
+      BIDFetcher(std::make_unique<BuildIDFetcher>(Opts.DebugFileDirectory)) {}
 
 LLVMSymbolizer::~LLVMSymbolizer() = default;
 
 template <typename T>
 Expected<DILineInfo>
 LLVMSymbolizer::symbolizeCodeCommon(const T &ModuleSpecifier,
                                     object::SectionedAddress ModuleOffset) {
 
bool darwinDsymMatchesBinary(const MachOObjectFile *DbgObj,
                              const MachOObjectFile *Obj) {
   ArrayRef<uint8_t> dbg_uuid = DbgObj->getUuid();
   ArrayRef<uint8_t> bin_uuid = Obj->getUuid();
   if (dbg_uuid.empty() || bin_uuid.empty())
     return false;
   return !memcmp(dbg_uuid.data(), bin_uuid.data(), dbg_uuid.size());
 }
 
-template <typename ELFT>
-Optional<ArrayRef<uint8_t>> getBuildID(const ELFFile<ELFT> &Obj) {
-  auto PhdrsOrErr = Obj.program_headers();
-  if (!PhdrsOrErr) {
-    consumeError(PhdrsOrErr.takeError());
-    return {};
-  }
-  for (const auto &P : *PhdrsOrErr) {
-    if (P.p_type != ELF::PT_NOTE)
-      continue;
-    Error Err = Error::success();
-    for (auto N : Obj.notes(P, Err))
-      if (N.getType() == ELF::NT_GNU_BUILD_ID &&
-          N.getName() == ELF::ELF_NOTE_GNU)
-        return N.getDesc();
-    consumeError(std::move(Err));
-  }
-  return {};
-}
-
 } // end anonymous namespace
 
-Optional<ArrayRef<uint8_t>> getBuildID(const ELFObjectFileBase *Obj) {
-  Optional<ArrayRef<uint8_t>> BuildID;
-  if (auto *O = dyn_cast<ELFObjectFile<ELF32LE>>(Obj))
-    BuildID = getBuildID(O->getELFFile());
-  else if (auto *O = dyn_cast<ELFObjectFile<ELF32BE>>(Obj))
-    BuildID = getBuildID(O->getELFFile());
-  else if (auto *O = dyn_cast<ELFObjectFile<ELF64LE>>(Obj))
-    BuildID = getBuildID(O->getELFFile());
-  else if (auto *O = dyn_cast<ELFObjectFile<ELF64BE>>(Obj))
-    BuildID = getBuildID(O->getELFFile());
-  else
-    llvm_unreachable("unsupported file format");
-  return BuildID;
-}
-
 ObjectFile *LLVMSymbolizer::lookUpDsymFile(const std::string &ExePath,
                                            const MachOObjectFile *MachExeObj,
                                            const std::string &ArchName) {
   // On Darwin we may find DWARF in separate object file in
   // resource directory.
   std::vector<std::string> DsymPaths;
   StringRef Filename = sys::path::filename(ExePath);
   DsymPaths.push_back(

 bool LLVMSymbolizer::getOrFindDebugBinary(const ArrayRef<uint8_t> BuildID,
                                           std::string &Result) {
   StringRef BuildIDStr = getBuildIDStr(BuildID);
   auto I = BuildIDPaths.find(BuildIDStr);
   if (I != BuildIDPaths.end()) {
     Result = I->second;
     return true;
   }
-  auto recordPath = [&](StringRef Path) {
-    Result = Path.str();
+  if (!BIDFetcher)
+    return false;
+  if (Optional<std::string> Path = BIDFetcher->fetch(BuildID)) {
+    Result = *Path;
     auto InsertResult = BuildIDPaths.insert({BuildIDStr, Result});
     assert(InsertResult.second);
     (void)InsertResult;
-  };
-
-  Optional<std::string> Path;
-  Path = LocalDIFetcher(Opts.DebugFileDirectory).fetchBuildID(BuildID);
-  if (Path) {
-    recordPath(*Path);
     return true;
   }
 
-  // Try caller-provided debug info fetchers.
-  for (const std::unique_ptr<DIFetcher> &Fetcher : DIFetchers) {
-    Path = Fetcher->fetchBuildID(BuildID);
-    if (Path) {
-      recordPath(*Path);
-      return true;
-    }
-  }
-
   return false;
 }
 
 Expected<LLVMSymbolizer::ObjectPair>
 LLVMSymbolizer::getOrCreateObjectPair(const std::string &Path,
                                       const std::string &ArchName) {
   auto I = ObjectPairForPathArch.find(std::make_pair(Path, ArchName));
   if (I != ObjectPairForPathArch.end()) {

llvm/lib/Debuginfod/BuildIDFetcher.cpp

-//===- llvm/DebugInfod/DIFetcher.cpp - Debug info fetcher -----------------===//
+//===- llvm/DebugInfod/BuildIDFetcher.cpp - Build ID fetcher --------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// This file defines a DIFetcher implementation for obtaining debug info
 /// from debuginfod.
 ///
 //===----------------------------------------------------------------------===//
 
-#include "llvm/Debuginfod/DIFetcher.h"
+#include "llvm/Debuginfod/BuildIDFetcher.h"
 
 #include "llvm/Debuginfod/Debuginfod.h"
 
 using namespace llvm;
 
 Optional<std::string>
-DebuginfodDIFetcher::fetchBuildID(ArrayRef<uint8_t> BuildID) const {
+DebuginfodFetcher::fetch(ArrayRef<uint8_t> BuildID) const {
+  if (Optional<std::string> Path = BuildIDFetcher::fetch(BuildID))
+    return std::move(*Path);
+
   Expected<std::string> PathOrErr = getCachedOrDownloadDebuginfo(BuildID);
   if (PathOrErr)
     return *PathOrErr;
   consumeError(PathOrErr.takeError());
   return None;
 }

llvm/lib/Debuginfod/CMakeLists.txt

 # Make sure pthread is linked if this is a unix host
 if (CMAKE_HOST_UNIX)
   set(imported_libs ${imported_libs} ${LLVM_PTHREAD_LIB})
 endif()
 
 # Note: This isn't a component, since that could potentially add a libcurl
 # dependency to libLLVM.
 add_llvm_library(LLVMDebuginfod
+  BuildIDFetcher.cpp
   Debuginfod.cpp
-  DIFetcher.cpp
   HTTPClient.cpp
   HTTPServer.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/Debuginfod
 
   LINK_LIBS
   ${imported_libs}
 
   LINK_COMPONENTS
   Support
   Symbolize
   DebugInfoDWARF
   BinaryFormat
   Object
   )

llvm/lib/Debuginfod/Debuginfod.cpp

 //===----------------------------------------------------------------------===//
 
 #include "llvm/Debuginfod/Debuginfod.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/BinaryFormat/Magic.h"
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/DebugInfo/Symbolize/Symbolize.h"
 #include "llvm/Debuginfod/HTTPClient.h"
-#include "llvm/Object/Binary.h"
+#include "llvm/Object/BuildID.h"
 #include "llvm/Object/ELFObjectFile.h"
-#include "llvm/Object/ObjectFile.h"
 #include "llvm/Support/CachePruning.h"
 #include "llvm/Support/Caching.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/FileUtilities.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/ThreadPool.h"
 #include "llvm/Support/xxhash.h"
 
 #include <atomic>
 #include <thread>
 
 namespace llvm {
+
+using llvm::object::BuildIDRef;
+
 static std::string uniqueKey(llvm::StringRef S) { return utostr(xxHash64(S)); }
 
 // Returns a binary BuildID as a normalized hex string.
 // Uses lowercase for compatibility with common debuginfod servers.
 static std::string buildIDToString(BuildIDRef ID) {
   return llvm::toHex(ID, /*LowerCase=*/true);
 }
 
Error DebuginfodCollection::updateForever(std::chrono::milliseconds Interval) {
   while (true) {
     if (Error Err = update())
       return Err;
     std::this_thread::sleep_for(Interval);
   }
   llvm_unreachable("updateForever loop should never end");
 }
 
-static bool isDebugBinary(object::ObjectFile *Object) {
-  // TODO: handle PDB debuginfo
-  std::unique_ptr<DWARFContext> Context = DWARFContext::create(
-      *Object, DWARFContext::ProcessDebugRelocations::Process);
-  const DWARFObject &DObj = Context->getDWARFObj();
-  unsigned NumSections = 0;
-  DObj.forEachInfoSections([&](const DWARFSection &S) { NumSections++; });
-  return NumSections;
-}
-
 static bool hasELFMagic(StringRef FilePath) {
   file_magic Type;
   std::error_code EC = identify_magic(FilePath, Type);
   if (EC)
     return false;
   switch (Type) {
   case file_magic::elf:
   case file_magic::elf_relocatable:
IteratorGroup.async([&, this]() -> void {
           continue;
 
         // TODO: Support non-ELF binaries
         object::ELFObjectFileBase *Object =
             dyn_cast<object::ELFObjectFileBase>(Bin);
         if (!Object)
           continue;
 
-        Optional<BuildIDRef> ID = symbolize::getBuildID(Object);
+        Optional<BuildIDRef> ID = getBuildID(Object);
         if (!ID)
           continue;
 
         std::string IDString = buildIDToString(ID.value());
-        if (isDebugBinary(Object)) {
+        if (Object->hasDebugInfo()) {
           std::lock_guard<sys::RWMutex> DebugBinariesGuard(DebugBinariesMutex);
           DebugBinaries[IDString] = FilePath;
         } else {
           std::lock_guard<sys::RWMutex> BinariesGuard(BinariesMutex);
           Binaries[IDString] = FilePath;
         }
       }
     });
cantFail(
       Server.get(R"(/buildid/(.*)/debuginfo)", [&](HTTPServerRequest Request) {
         Log.push("GET " + Request.UrlPath);
         std::string IDString;
         if (!tryGetFromHex(Request.UrlPathMatches[0], IDString)) {
           Request.setResponse(
               {404, "text/plain", "Build ID is not a hex string\n"});
           return;
         }
-        BuildID ID(IDString.begin(), IDString.end());
+        object::BuildID ID(IDString.begin(), IDString.end());
         Expected<std::string> PathOrErr = Collection.findDebugBinaryPath(ID);
         if (Error Err = PathOrErr.takeError()) {
           consumeError(std::move(Err));
           Request.setResponse({404, "text/plain", "Build ID not found\n"});
           return;
         }
         streamFile(Request, *PathOrErr);
       }));
   cantFail(
       Server.get(R"(/buildid/(.*)/executable)", [&](HTTPServerRequest Request) {
         Log.push("GET " + Request.UrlPath);
         std::string IDString;
         if (!tryGetFromHex(Request.UrlPathMatches[0], IDString)) {
           Request.setResponse(
               {404, "text/plain", "Build ID is not a hex string\n"});
           return;
         }
-        BuildID ID(IDString.begin(), IDString.end());
+        object::BuildID ID(IDString.begin(), IDString.end());
         Expected<std::string> PathOrErr = Collection.findBinaryPath(ID);
         if (Error Err = PathOrErr.takeError()) {
           consumeError(std::move(Err));
           Request.setResponse({404, "text/plain", "Build ID not found\n"});
           return;
         }
         streamFile(Request, *PathOrErr);
       }));
 }
 
 } // namespace llvm

llvm/lib/Object/BuildID.cpp

+//===- llvm/Object/BuildID.cpp - Build ID ---------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file defines a library for handling Build IDs and using them to find
+/// debug info.
+///
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Object/BuildID.h"
+
+#include "llvm/Object/ELFObjectFile.h"
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/Path.h"
+
+namespace llvm {
+namespace object {
+
+namespace {
+
+template <typename ELFT>
+Optional<BuildIDRef> getBuildID(const ELFFile<ELFT> &Obj) {
+  auto PhdrsOrErr = Obj.program_headers();
+  if (!PhdrsOrErr) {
+    consumeError(PhdrsOrErr.takeError());
+    return {};
+  }
+  for (const auto &P : *PhdrsOrErr) {
+    if (P.p_type != ELF::PT_NOTE)
+      continue;
+    Error Err = Error::success();
+    for (auto N : Obj.notes(P, Err))
+      if (N.getType() == ELF::NT_GNU_BUILD_ID &&
+          N.getName() == ELF::ELF_NOTE_GNU)
+        return N.getDesc();
+    consumeError(std::move(Err));
+  }
+  return {};
+}
+
+} // namespace
+
+Optional<BuildIDRef> getBuildID(const ObjectFile *Obj) {
+  if (auto *O = dyn_cast<ELFObjectFile<ELF32LE>>(Obj))
+    return getBuildID(O->getELFFile());
+  if (auto *O = dyn_cast<ELFObjectFile<ELF32BE>>(Obj))
+    return getBuildID(O->getELFFile());
+  if (auto *O = dyn_cast<ELFObjectFile<ELF64LE>>(Obj))
+    return getBuildID(O->getELFFile());
+  if (auto *O = dyn_cast<ELFObjectFile<ELF64BE>>(Obj))
+    return getBuildID(O->getELFFile());
+  return None;
+}
+
+Optional<std::string> BuildIDFetcher::fetch(BuildIDRef BuildID) const {
+  auto GetDebugPath = [&](StringRef Directory) {
+    SmallString<128> Path{Directory};
+    sys::path::append(Path, ".build-id",
+                      llvm::toHex(BuildID[0], /*LowerCase=*/true),
+                      llvm::toHex(BuildID.slice(1), /*LowerCase=*/true));
+    Path += ".debug";
+    return Path;
+  };
+  if (DebugFileDirectories.empty()) {
+    SmallString<128> Path = GetDebugPath(
+#if defined(__NetBSD__)
+        // Try /usr/libdata/debug/.build-id/../...
+        "/usr/libdata/debug"
+#else
+        // Try /usr/lib/debug/.build-id/../...
+        "/usr/lib/debug"
+#endif
+    );
+    if (llvm::sys::fs::exists(Path))
+      return std::string(Path);
+  } else {
+    for (const auto &Directory : DebugFileDirectories) {
+      // Try <debug-file-directory>/.build-id/../...
+      SmallString<128> Path = GetDebugPath(Directory);
+      if (llvm::sys::fs::exists(Path))
+        return std::string(Path);
+    }
+  }
+  return None;
+}
+
+} // namespace object
+} // namespace llvm

llvm/lib/Object/CMakeLists.txt

 add_llvm_component_library(LLVMObject
   Archive.cpp
   ArchiveWriter.cpp
   Binary.cpp
+  BuildID.cpp
   COFFImportFile.cpp
   COFFModuleDefinition.cpp
   COFFObjectFile.cpp
   Decompressor.cpp
   DXContainer.cpp
   ELF.cpp
   ELFObjectFile.cpp
   Error.cpp

llvm/lib/Object/ObjectFile.cpp

 }
 
 bool ObjectFile::isBerkeleyData(DataRefImpl Sec) const {
   return isSectionData(Sec);
 }
 
 bool ObjectFile::isDebugSection(DataRefImpl Sec) const { return false; }
 
+bool ObjectFile::hasDebugInfo() const {
+  return any_of(sections(),
+                [](SectionRef Sec) { return Sec.isDebugSection(); });
+}
+
 Expected<section_iterator>
 ObjectFile::getRelocatedSection(DataRefImpl Sec) const {
   return section_iterator(SectionRef(Sec, this));
 }
 
 Triple ObjectFile::makeTriple() const {
   Triple TheTriple;
   auto Arch = getArch();

llvm/tools/llvm-debuginfod-find/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
+  Object
   Support
-  Symbolize
   )
 add_llvm_tool(llvm-debuginfod-find
   llvm-debuginfod-find.cpp
   )
 target_link_libraries(llvm-debuginfod-find PRIVATE LLVMDebuginfod)
 if(LLVM_INSTALL_BINUTILS_SYMLINKS)
   add_llvm_tool_symlink(debuginfod-find llvm-debuginfod-find)
 endif()

llvm/tools/llvm-debuginfod-find/llvm-debuginfod-find.cpp

 /// This file contains the llvm-debuginfod-find tool. This tool
 /// queries the debuginfod servers in the DEBUGINFOD_URLS environment
 /// variable (delimited by space (" ")) for the executable,
 /// debuginfo, or specified source file of the binary matching the
 /// given build-id.
 ///
 //===----------------------------------------------------------------------===//
 
-#include "llvm/DebugInfo/Symbolize/DIFetcher.h"
+#include "llvm/Debuginfod/BuildIDFetcher.h"
 #include "llvm/Debuginfod/Debuginfod.h"
 #include "llvm/Debuginfod/HTTPClient.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/InitLLVM.h"
 
 using namespace llvm;
 
 cl::OptionCategory DebuginfodFindCategory("llvm-debuginfod-find Options");

 [[noreturn]] static void helpExit() {
   errs() << "Must specify exactly one of --executable, "
             "--source=/path/to/file, or --debuginfo.";
   exit(1);
 }
 
 ExitOnError ExitOnErr;
 
-static std::string fetchDebugInfo(ArrayRef<uint8_t> BuildID);
+static std::string fetchDebugInfo(object::BuildIDRef BuildID);
 
 int main(int argc, char **argv) {
   InitLLVM X(argc, argv);
   HTTPClient::initialize();
 
   cl::HideUnrelatedOptions({&DebuginfodFindCategory});
   cl::ParseCommandLineOptions(
       argc, argv,
       "llvm-debuginfod-find: Fetch debuginfod artifacts\n\n"
       "This program is a frontend to the debuginfod client library. The cache "
       "directory, request timeout (in seconds), and debuginfod server urls are "
       "set by these environment variables:\n"
       "DEBUGINFOD_CACHE_PATH (default set by sys::path::cache_directory)\n"
       "DEBUGINFOD_TIMEOUT (defaults to 90s)\n"
       "DEBUGINFOD_URLS=[comma separated URLs] (defaults to empty)\n");
 
   if (FetchExecutable + FetchDebuginfo + (FetchSource != "") != 1)
     helpExit();
 
   std::string IDString;
   if (!tryGetFromHex(InputBuildID, IDString)) {
     errs() << "Build ID " << InputBuildID << " is not a hex string.\n";
     exit(1);
   }
-  BuildID ID(IDString.begin(), IDString.end());
+  object::BuildID ID(IDString.begin(), IDString.end());
 
   std::string Path;
   if (FetchSource != "")
     Path = ExitOnErr(getCachedOrDownloadSource(ID, FetchSource));
   else if (FetchExecutable)
     Path = ExitOnErr(getCachedOrDownloadExecutable(ID));
   else if (FetchDebuginfo)
     Path = fetchDebugInfo(ID);
   else
     llvm_unreachable("We have already checked that exactly one of the above "
                      "conditions is true.");
 
   if (DumpToStdout) {
     // Print the contents of the artifact.
     ErrorOr<std::unique_ptr<MemoryBuffer>> Buf = MemoryBuffer::getFile(
         Path, /*IsText=*/false, /*RequiresNullTerminator=*/false);
     ExitOnErr(errorCodeToError(Buf.getError()));
     outs() << Buf.get()->getBuffer();
   } else
     // Print the path to the cached artifact file.
     outs() << Path << "\n";
 }
 
-// Find a debug binary in local build ID directories and via debuginfod.
-std::string fetchDebugInfo(ArrayRef<uint8_t> BuildID) {
-  if (!DebugFileDirectory.empty()) {
-    symbolize::LocalDIFetcher Fetcher(DebugFileDirectory);
-    if (Optional<std::string> LocalPath = Fetcher.fetchBuildID(BuildID))
-      return *LocalPath;
-  }
-  return ExitOnErr(getCachedOrDownloadDebuginfo(BuildID));
+// Find a debug file in local build ID directories and via debuginfod.
+std::string fetchDebugInfo(object::BuildIDRef BuildID) {
+  if (Optional<std::string> Path =
+          DebuginfodFetcher(DebugFileDirectory).fetch(BuildID))
+    return *Path;
+  errs() << "Build ID " << llvm::toHex(BuildID, /*Lowercase=*/true)
+         << " could not be found.";
+  exit(1);
 }

llvm/tools/llvm-symbolizer/llvm-symbolizer.cpp

 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Config/config.h"
 #include "llvm/DebugInfo/Symbolize/DIPrinter.h"
 #include "llvm/DebugInfo/Symbolize/Markup.h"
 #include "llvm/DebugInfo/Symbolize/MarkupFilter.h"
 #include "llvm/DebugInfo/Symbolize/SymbolizableModule.h"
 #include "llvm/DebugInfo/Symbolize/Symbolize.h"
-#include "llvm/Debuginfod/DIFetcher.h"
+#include "llvm/Debuginfod/BuildIDFetcher.h"
 #include "llvm/Debuginfod/Debuginfod.h"
 #include "llvm/Debuginfod/HTTPClient.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Option/Option.h"
 #include "llvm/Support/COM.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"

 enum class OutputStyle { LLVM, GNU, JSON };
 
 enum class Command {
   Code,
   Data,
   Frame,
 };
 
-static void enableDebuginfod(LLVMSymbolizer &Symbolizer) {
+static void enableDebuginfod(LLVMSymbolizer &Symbolizer,
+                             const opt::ArgList &Args) {
   static bool IsEnabled = false;
   if (IsEnabled)
     return;
   IsEnabled = true;
   // Look up symbols using the debuginfod client.
-  Symbolizer.addDIFetcher(std::make_unique<DebuginfodDIFetcher>());
+  Symbolizer.setBuildIDFetcher(std::make_unique<DebuginfodFetcher>(
+      Args.getAllArgValues(OPT_debug_file_directory_EQ)));
   // The HTTPClient must be initialized for use by the debuginfod client.
   HTTPClient::initialize();
 }
 
-static SmallVector<uint8_t> parseBuildID(StringRef Str) {
+static object::BuildID parseBuildID(StringRef Str) {
   std::string Bytes;
   if (!tryGetFromHex(Str, Bytes))
     return {};
   ArrayRef<uint8_t> BuildID(reinterpret_cast<const uint8_t *>(Bytes.data()),
                             Bytes.size());
-  return SmallVector<uint8_t>(BuildID.begin(), BuildID.end());
+  return object::BuildID(BuildID.begin(), BuildID.end());
 }
 
 static bool parseCommand(StringRef BinaryName, bool IsAddr2Line,
                          StringRef InputString, Command &Cmd,
-                         std::string &ModuleName,
-                         SmallVectorImpl<uint8_t> &BuildID,
+                         std::string &ModuleName, object::BuildID &BuildID,
                          uint64_t &ModuleOffset) {
   const char kDelimiters[] = " \n\r";
   ModuleName = "";
   if (InputString.consume_front("CODE ")) {
     Cmd = Command::Code;
   } else if (InputString.consume_front("DATA ")) {
     Cmd = Command::Data;
   } else if (InputString.consume_front("FRAME ")) {
if (Cmd == Command::Data) {
     Expected<DILineInfo> ResOrErr =
         Symbolizer.symbolizeCode(ModuleSpec, Address);
     print({ModuleName, Offset}, ResOrErr, Printer);
   }
   Symbolizer.pruneCache();
 }
 
 static void symbolizeInput(const opt::InputArgList &Args,
-                           ArrayRef<uint8_t> IncomingBuildID,
+                           object::BuildIDRef IncomingBuildID,
                            uint64_t AdjustVMA, bool IsAddr2Line,
                            OutputStyle Style, StringRef InputString,
                            LLVMSymbolizer &Symbolizer, DIPrinter &Printer) {
   Command Cmd;
   std::string ModuleName;
-  SmallVector<uint8_t> BuildID(IncomingBuildID.begin(), IncomingBuildID.end());
+  object::BuildID BuildID(IncomingBuildID.begin(), IncomingBuildID.end());
   uint64_t Offset = 0;
   if (!parseCommand(Args.getLastArgValue(OPT_obj_EQ), IsAddr2Line,
                     StringRef(InputString), Cmd, ModuleName, BuildID, Offset)) {
     Printer.printInvalidCommand({ModuleName, None}, InputString);
     return;
   }
   bool ShouldInline = Args.hasFlag(OPT_inlines, OPT_no_inlines, !IsAddr2Line);
   if (!BuildID.empty()) {
     assert(ModuleName.empty());
     if (!Args.hasArg(OPT_no_debuginfod))
-      enableDebuginfod(Symbolizer);
+      enableDebuginfod(Symbolizer, Args);
     std::string BuildIDStr = toHex(BuildID);
     executeCommand(BuildIDStr, BuildID, Cmd, Offset, AdjustVMA, ShouldInline,
                    Style, Symbolizer, Printer);
   } else {
     executeCommand(ModuleName, ModuleName, Cmd, Offset, AdjustVMA, ShouldInline,
                    Style, Symbolizer, Printer);
   }
 }
static Optional<bool> parseColorArg(const opt::InputArgList &Args) {
   if (const opt::Arg *A = Args.getLastArg(OPT_color_EQ))
     return StringSwitch<Optional<bool>>(A->getValue())
         .Case("always", true)
         .Case("never", false)
         .Case("auto", None);
   return None;
 }
 
-static SmallVector<uint8_t> parseBuildIDArg(const opt::InputArgList &Args,
-                                            int ID) {
+static object::BuildID parseBuildIDArg(const opt::InputArgList &Args, int ID) {
   const opt::Arg *A = Args.getLastArg(ID);
   if (!A)
     return {};
 
   StringRef V(A->getValue());
-  SmallVector<uint8_t> BuildID = parseBuildID(V);
+  object::BuildID BuildID = parseBuildID(V);
   if (BuildID.empty()) {
     errs() << A->getSpelling() + ": expected a build ID, but got '" + V + "'\n";
     exit(1);
   }
   return BuildID;
 }
 
 // Symbolize markup from stdin and write the result to stdout.
#endif
 
   // A debuginfod lookup could succeed if a HTTP client is available and at
   // least one backing URL is configured.
   bool ShouldUseDebuginfodByDefault =
       HTTPClient::isAvailable() &&
       !ExitOnErr(getDefaultDebuginfodUrls()).empty();
   if (Args.hasFlag(OPT_debuginfod, OPT_no_debuginfod,
                    ShouldUseDebuginfodByDefault))
-    enableDebuginfod(Symbolizer);
+    enableDebuginfod(Symbolizer, Args);
 
   if (Args.hasArg(OPT_filter_markup)) {
     filterMarkup(Args, Symbolizer);
     return 0;
   }
 
   auto Style = IsAddr2Line ? OutputStyle::GNU : OutputStyle::LLVM;
   if (const opt::Arg *A = Args.getLastArg(OPT_output_style_EQ)) {
     if (strcmp(A->getValue(), "GNU") == 0)
       Style = OutputStyle::GNU;
     else if (strcmp(A->getValue(), "JSON") == 0)
       Style = OutputStyle::JSON;
     else
       Style = OutputStyle::LLVM;
   }
 
   if (Args.hasArg(OPT_build_id_EQ) && Args.hasArg(OPT_obj_EQ)) {
     errs() << "error: cannot specify both --build-id and --obj\n";
     return EXIT_FAILURE;
   }
-  SmallVector<uint8_t> BuildID = parseBuildIDArg(Args, OPT_build_id_EQ);
+  object::BuildID BuildID = parseBuildIDArg(Args, OPT_build_id_EQ);
 
   std::unique_ptr<DIPrinter> Printer;
   if (Style == OutputStyle::GNU)
     Printer = std::make_unique<GNUPrinter>(outs(), errs(), Config);
   else if (Style == OutputStyle::JSON)
     Printer = std::make_unique<JSONPrinter>(outs(), Config);
   else
     Printer = std::make_unique<LLVMPrinter>(outs(), errs(), Config);