[llvm-objdump] Find debug information with Build ID/debuginfod.

[mysterymath]

Summary

Uses the library introduced in https://reviews.llvm.org/D132504 to add build ID fetching to llvm-objdump. This allows viewing source when disassembling stripped objects.

[mysterymath]

Documentation.

[mysterymath]

Fix a possible NPE, more comments.

[mysterymath]

Add test cases.

[mysterymath]

Make naming consistent.

[phosek]

I think that the changes to build ID/debuginfod and llvm-objdump should be split into two patches, since the former is just a refactoring while the latter is a new functionality.

llvm/lib/Object/BuildID.cpp

2

This file is missing the copyright header.

llvm/tools/llvm-objdump/llvm-objdump.cpp

1269–1280

Could this be added as a method to ObjectFile?

[mysterymath]

Move hasDebugInfo() to ObjectFile.
Add missing copyright header.

llvm/lib/Object/BuildID.cpp

2

Wow whoops. Done.

llvm/tools/llvm-objdump/llvm-objdump.cpp

1269–1280

Done, and this also made it obvious that there's already a reliable isDebugSection to base this off of.

[mysterymath]

Split out refactoring into separate change.

[mysterymath]

Use correct alias for --debug-file-directory argument.

[mysterymath]

Fix test when CURL disabled.

[mysterymath]

Add docs.

[jhenderson]

llvm/docs/CommandGuide/llvm-objdump.rst

134–137 ↗

(On Diff #460831)

Just trying to understand this: is this saying that LLVM_ENABLE_CURL and the server URLs effectively just impact the default value of this option, but that you can still specify --debuginfod without that being used?

llvm/test/tools/llvm-objdump/debuginfod.test

9 ↗

(On Diff #460831)

Is there a particular reason to use a canned binary instead of building from assembly with debug information (i.e. I believe llvm-mc -g)? If so, could you please include the original source file and instructions on how to compile it to create the canned input.

15 ↗

(On Diff #460831)

Looks like we're missing a word here?

llvm/tools/llvm-objdump/ObjdumpOpts.td

42–44

This option doesn't seem to be documented or tested.

llvm/tools/llvm-objdump/llvm-objdump.cpp

57

My reading of https://llvm.org/docs/CodingStandards.html#include-as-little-as-possible (primarily the last paragraph), is that if these headers are included by one of the other headers, you don't need to #include them here. It seems unlikely to me that llvm-objdump doesn't already include this file indirectly, for example.

1268

Strictly, the name should be None, to match the variable name, I'd think.

1269

I believe a later patch in the series renames this method. Is there any particular reason not to use the final name here, to reduce git blame noise in the future?

1276–1283

It seems like some of this code isn't tested?

1278

Why are we throwing away the error here, rather than reporting it? Please at least add a comment explaining why.

[mysterymath]

Address review comments.
Various changes to reduce diffs of later commits in stack.

llvm/docs/CommandGuide/llvm-objdump.rst

134–137 ↗

(On Diff #460831)

Yes, if you specify --debuginfod without curl available, it will only search the local debuginfod cached directory. This has mostly just testing utility.

llvm/test/tools/llvm-objdump/debuginfod.test

9 ↗

(On Diff #460831)

The binaries produced by llvm-mc don't include build IDs; these are currently produced by lld. I don't know of a LLVM-only way to readably and reliably produce a build ID section.
I've added a link to the existing embedded-sources.test, which provides the information used to regenerate this file. I had to run the regeneration command as part of this change to ensure that a build ID was present, since the canned binary predates their generation by default.

llvm/tools/llvm-objdump/llvm-objdump.cpp

1278

Changed this to output a warning in this case; added a corresponding test.

[mysterymath]

Update commit message.

[jhenderson]

One nitpick suggestion, otherwise LGTM.

llvm/test/tools/llvm-objdump/debuginfod.test

9 ↗

(On Diff #460831)

You might be able to write it as raw binary data as an llvm-mc section, but I suspect that won't work for various reasons, so sounds good. Thanks for the explanation.

56 ↗

(On Diff #463332)

I'd recommend using FileCheck's -D option to provide the file name explicitly for the warning message (e.g. FileCheck -DFILE=%t.err ... then warning: '[[FILE]]':

[mysterymath]

Use FileCheck -D.

[MaskRay]

The patch is not uploaded via arc diff 'HEAD^' or web interface (git format-patch -1 --stdout). I got:

% curl -L 'https://reviews.llvm.org/D131224?download=1' | patch -p1
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100 10725    0 10725    0     0  47865      0 --:--:-- --:--:-- --:--:-- 48094
patch unexpectedly ends in middle of line
patch: **** Only garbage was found in the patch input.
% arc patch D131224
...
 COMMITTED  Successfully committed patch.

 Cherry Pick Failed!
 Exception 
Command failed with error #1!
COMMAND
git cherry-pick -- arcpatch-D132504

STDOUT
On branch arcpatch-D131224
You are currently cherry-picking commit eae436e3098c.

[mysterymath]

Integrate from previous.

[mysterymath]

In D131224#3825238, @MaskRay wrote:

The patch is not uploaded via arc diff 'HEAD^' or web interface (git format-patch -1 --stdout). I got:

% curl -L 'https://reviews.llvm.org/D131224?download=1' | patch -p1
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100 10725    0 10725    0     0  47865      0 --:--:-- --:--:-- --:--:-- 48094
patch unexpectedly ends in middle of line
patch: **** Only garbage was found in the patch input.
% arc patch D131224
...
 COMMITTED  Successfully committed patch.

 Cherry Pick Failed!
 Exception 
Command failed with error #1!
COMMAND
git cherry-pick -- arcpatch-D132504

STDOUT
On branch arcpatch-D131224
You are currently cherry-picking commit eae436e3098c.

Strange; I've been using the vanilla arc diff workflow. Maybe it went out of date from the changes to the prior, and I hadn't yet reuploaded? Just sent a fresh version of the patch.

[mysterymath]

Arc diff specifically against previous commit.

[mysterymath]

Restore original patch.

[mysterymath]

Repair test on Windows.

[thakis]

llvm/tools/llvm-objdump/llvm-objdump.cpp

41

Please see the discussion on D113717, in particular the summary at https://reviews.llvm.org/D113717#3295350

llvm-objdump probably shouldn't depend on HTTPClient, at least by default.

[mysterymath]

llvm/tools/llvm-objdump/llvm-objdump.cpp

41

IIRC, it will depend only on the stubbed-out HTTPClient unless LLVM_ENABLE_CURL is set in CMake.
This is parallel to the configure-based optional dependency of binutils and elfutils objdump's on libdebuginfod (and transitively, libcurl).

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) {
+    BuildIDFetcher = 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> BuildIDFetcher;
 };
 
 // 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
+/// binaries 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;
+  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 finding local
+/// binaries by their build ID.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DEBUGINFO_OBJECT_BUILDID_H
+#define LLVM_DEBUGINFO_OBJECT_BUILDID_H
+
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/Optional.h"
+#include "llvm/ADT/SmallString.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 binaries.
+class BuildIDFetcher {
+public:
+  BuildIDFetcher(std::vector<std::string> DebugFileDirectories)
+      : DebugFileDirectories(std::move(DebugFileDirectories)){};
+  virtual ~BuildIDFetcher() = default;
+
+  /// Returns the path to the debug binary 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/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"
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 (!BuildIDFetcher)
+    return false;
+  if (Optional<std::string> Path = BuildIDFetcher->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>
 
 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);
 }
 
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)) {
           std::lock_guard<sys::RWMutex> DebugBinariesGuard(DebugBinariesMutex);
           DebugBinaries[IDString] = FilePath;
         } else {
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

+#include "llvm/Object/BuildID.h"
+
+#include "llvm/Object/ELF.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/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/Object/BuildID.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/InitLLVM.h"
 
 using namespace llvm;
 
 cl::OptionCategory DebuginfodFindCategory("llvm-debuginfod-find Options");
 
 cl::opt<std::string> InputBuildID(cl::Positional, cl::Required,

 [[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));
+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-objdump/CMakeLists.txt

add_llvm_tool(llvm-objdump
   OffloadDump.cpp
   WasmDump.cpp
   XCOFFDump.cpp
   DEPENDS
   ObjdumpOptsTableGen
   OtoolOptsTableGen
   )
 
+target_link_libraries(llvm-objdump PRIVATE LLVMDebuginfod)
+
 if(LLVM_HAVE_LIBXAR)
   target_link_libraries(llvm-objdump PRIVATE ${XAR_LIB})
 endif()
 
 add_llvm_tool_symlink(llvm-otool llvm-objdump)
 
 if(LLVM_INSTALL_BINUTILS_SYMLINKS)
   add_llvm_tool_symlink(objdump llvm-objdump)
 endif()
 
 if(LLVM_INSTALL_CCTOOLS_SYMLINKS)
   add_llvm_tool_symlink(otool llvm-otool)
 endif()

llvm/tools/llvm-objdump/ObjdumpOpts.td

def archive_headers : Flag<["--"], "archive-headers">,
   HelpText<"Display archive header information">;
 
 def : Flag<["-"], "a">, Alias<archive_headers>,
   HelpText<"Alias for --archive-headers">;
 
 def demangle : Flag<["--"], "demangle">, HelpText<"Demangle symbol names">;
 def : Flag<["-"], "C">, Alias<demangle>, HelpText<"Alias for --demangle">;
 
+defm debug_file_directory :
+  Eq<"debug-file-directory", "Path to directory where to look for debug files">,
+  MetaVarName<"<dir>">;
+
 def disassemble : Flag<["--"], "disassemble">,
   HelpText<"Disassemble all executable sections found in the input files">;
 def : Flag<["-"], "d">, Alias<disassemble>, HelpText<"Alias for --disassemble">;
 
 def disassemble_all : Flag<["--"], "disassemble-all">,
   HelpText<"Disassemble all sections found in the input files">;
 def : Flag<["-"], "D">, Alias<disassemble_all>,
   HelpText<"Alias for --disassemble-all">;

llvm/tools/llvm-objdump/SourcePrinter.h

void printLines(formatted_raw_ostream &OS, const DILineInfo &LineInfo,
                   StringRef Delimiter, LiveVariablePrinter &LVP);
 
   void printSources(formatted_raw_ostream &OS, const DILineInfo &LineInfo,
                     StringRef ObjectFilename, StringRef Delimiter,
                     LiveVariablePrinter &LVP);
 
 public:
   SourcePrinter() = default;
-  SourcePrinter(const object::ObjectFile *Obj, StringRef DefaultArch);
+  SourcePrinter(const object::ObjectFile *Obj, StringRef DefaultArch,
+                std::vector<std::string> DebugFileDirectories);
   virtual ~SourcePrinter() = default;
   virtual void printSourceLine(formatted_raw_ostream &OS,
                                object::SectionedAddress Address,
                                StringRef ObjectFilename,
                                LiveVariablePrinter &LVP,
                                StringRef Delimiter = "; ");
 };
 
 } // namespace objdump
 } // namespace llvm
 
 #endif

llvm/tools/llvm-objdump/SourcePrinter.cpp

 //===----------------------------------------------------------------------===//
 
 #include "SourcePrinter.h"
 #include "llvm-objdump.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/DebugInfo/DWARF/DWARFExpression.h"
 #include "llvm/DebugInfo/Symbolize/SymbolizableModule.h"
+#include "llvm/Debuginfod/BuildIDFetcher.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/Support/FormatVariadic.h"
 
 #define DEBUG_TYPE "objdump"
 
 namespace llvm {
 namespace objdump {
 
if (LineBuffer != LineCache.end()) {
     }
     // Vector begins at 0, line numbers are non-zero
     OS << Delimiter << LineBuffer->second[LineInfo.Line - 1];
     LVP.printBetweenInsts(OS, true);
   }
 }
 
 SourcePrinter::SourcePrinter(const object::ObjectFile *Obj,
-                             StringRef DefaultArch)
+                             StringRef DefaultArch,
+                             std::vector<std::string> DebugFileDirectories)
     : Obj(Obj) {
   symbolize::LLVMSymbolizer::Options SymbolizerOpts;
   SymbolizerOpts.PrintFunctions =
       DILineInfoSpecifier::FunctionNameKind::LinkageName;
   SymbolizerOpts.Demangle = Demangle;
   SymbolizerOpts.DefaultArch = std::string(DefaultArch);
   Symbolizer.reset(new symbolize::LLVMSymbolizer(SymbolizerOpts));
+  Symbolizer->setBuildIDFetcher(
+      std::make_unique<DebuginfodFetcher>(std::move(DebugFileDirectories)));
 }
 
 } // namespace objdump
 } // namespace llvm

llvm/tools/llvm-objdump/llvm-objdump.cpp

 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/DebugInfo/Symbolize/SymbolizableModule.h"
 #include "llvm/DebugInfo/Symbolize/Symbolize.h"
+#include "llvm/Debuginfod/BuildIDFetcher.h"
+#include "llvm/Debuginfod/Debuginfod.h"
+#include "llvm/Debuginfod/HTTPClient.h"
 #include "llvm/Demangle/Demangle.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCDisassembler/MCDisassembler.h"
 #include "llvm/MC/MCDisassembler/MCRelocationInfo.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCInstPrinter.h"
 #include "llvm/MC/MCInstrAnalysis.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCObjectFileInfo.h"
 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/MC/MCTargetOptions.h"
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Object/Archive.h"
+#include "llvm/Object/Binary.h"
+#include "llvm/Object/BuildID.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Object/COFFImportFile.h"
 #include "llvm/Object/ELFObjectFile.h"
 #include "llvm/Object/ELFTypes.h"
 #include "llvm/Object/FaultMapParser.h"
 #include "llvm/Object/MachO.h"
 #include "llvm/Object/MachOUniversal.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Object/OffloadBinary.h"
 #include "llvm/Object/Wasm.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Option/Option.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Errc.h"
+#include "llvm/Support/Error.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/GraphWriter.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/SourceMgr.h"

 } // namespace
 
 #define DEBUG_TYPE "objdump"
 
 static uint64_t AdjustVMA;
 static bool AllHeaders;
 static std::string ArchName;
 bool objdump::ArchiveHeaders;
+static std::vector<std::string> DebugFileDirectories;
 bool objdump::Demangle;
 bool objdump::Disassemble;
 bool objdump::DisassembleAll;
 bool objdump::SymbolDescription;
 static std::vector<std::string> DisassembleSymbols;
 static bool DisassembleZeroes;
 static std::vector<std::string> DisassemblerOptions;
 DIDumpType objdump::DwarfDumpType;
else if (auto *Elf32BEObj = dyn_cast<ELF32BEObjectFile>(&Obj))
     Elf32BEObj->createFakeSections();
   else if (auto *Elf64BEObj = cast<ELF64BEObjectFile>(&Obj))
     Elf64BEObj->createFakeSections();
   else
     llvm_unreachable("Unsupported binary format");
 }
 
 static void disassembleObject(const Target *TheTarget, ObjectFile &Obj,
                               MCContext &Ctx, MCDisassembler *PrimaryDisAsm,
                               MCDisassembler *SecondaryDisAsm,
                               const MCInstrAnalysis *MIA, MCInstPrinter *IP,
                               const MCSubtargetInfo *PrimarySTI,
                               const MCSubtargetInfo *SecondarySTI,
                               PrettyPrinter &PIP, SourcePrinter &SP,
                               bool InlineRelocs) {
   const MCSubtargetInfo *STI = PrimarySTI;
   MCDisassembler *DisAsm = PrimaryDisAsm;
   bool PrimaryIsThumb = false;
   if (isArmElf(Obj))
     PrimaryIsThumb = STI->checkFeatures("+thumb-mode");
 
   std::map<SectionRef, std::vector<RelocationRef>> RelocMap;
   if (InlineRelocs)
     RelocMap = getRelocsMap(Obj);
   bool Is64Bits = Obj.getBytesInAddress() > 4;
 
   // Create a mapping from virtual address to symbol name.  This is used to
   // pretty print the symbols while disassembling.
   std::map<SectionRef, SectionSymbolsTy> AllSymbols;
   SectionSymbolsTy AbsoluteSymbols;
   const StringRef FileName = Obj.getFileName();
   const MachOObjectFile *MachO = dyn_cast<const MachOObjectFile>(&Obj);
static void disassembleObject(const Target *TheTarget, ObjectFile &Obj,
   StringSet<> FoundDisasmSymbolSet;
   for (std::pair<const SectionRef, SectionSymbolsTy> &SecSyms : AllSymbols)
     llvm::stable_sort(SecSyms.second);
   llvm::stable_sort(AbsoluteSymbols);
 
   std::unique_ptr<DWARFContext> DICtx;
   LiveVariablePrinter LVP(*Ctx.getRegisterInfo(), *STI);
 
+  OwningBinary<Binary> DebugBinary;
   if (DbgVariables != DVDisabled) {
     DICtx = DWARFContext::create(Obj);
+    if (DICtx->compile_units().empty()) {
+      Optional<object::BuildIDRef> BuildID = getBuildID(&Obj);
+      if (BuildID) {
+        if (Optional<std::string> Path =
+                DebuginfodFetcher{DebugFileDirectories}.fetch(*BuildID)) {
+          DebugBinary = unwrapOrError(createBinary(*Path), *Path);
+          if (auto *O = dyn_cast<ObjectFile>(DebugBinary.getBinary()))
+            DICtx = DWARFContext::create(*O);
+        }
+      }
+    }
     for (const std::unique_ptr<DWARFUnit> &CU : DICtx->compile_units())
       LVP.addCompileUnit(CU->getUnitDIE(false));
   }
 
   LLVM_DEBUG(LVP.dump());
 
   std::unordered_map<uint64_t, BBAddrMap> AddrToBBAddrMap;
   auto ReadBBAddrMap = [&](Optional<unsigned> SectionIndex = None) {
if (!IP)
     reportError(Obj->getFileName(),
                 "no instruction printer for target " + TripleName);
   IP->setPrintImmHex(PrintImmHex);
   IP->setPrintBranchImmAsAddress(true);
   IP->setSymbolizeOperands(SymbolizeOperands);
   IP->setMCInstrAnalysis(MIA.get());
 
   PrettyPrinter &PIP = selectPrettyPrinter(Triple(TripleName));
-  SourcePrinter SP(Obj, TheTarget->getName());
+  SourcePrinter SP(Obj, TheTarget->getName(), DebugFileDirectories);
 
   for (StringRef Opt : DisassemblerOptions)
     if (!IP->applyTargetSpecificCLOption(Opt))
       reportError(Obj->getFileName(),
                   "Unrecognized disassembler option: " + Opt);
 
   disassembleObject(TheTarget, *Obj, Ctx, DisAsm.get(), SecondaryDisAsm.get(),
                     MIA.get(), IP.get(), STI.get(), SecondarySTI.get(), PIP, SP,
static void parseOtoolOptions(const llvm::opt::InputArgList &InputArgs) {
   }
 }
 
 static void parseObjdumpOptions(const llvm::opt::InputArgList &InputArgs) {
   parseIntArg(InputArgs, OBJDUMP_adjust_vma_EQ, AdjustVMA);
   AllHeaders = InputArgs.hasArg(OBJDUMP_all_headers);
   ArchName = InputArgs.getLastArgValue(OBJDUMP_arch_name_EQ).str();
   ArchiveHeaders = InputArgs.hasArg(OBJDUMP_archive_headers);
+  DebugFileDirectories = InputArgs.getAllArgValues(OBJDUMP_debug_file_directory_eq);
   Demangle = InputArgs.hasArg(OBJDUMP_demangle);
   Disassemble = InputArgs.hasArg(OBJDUMP_disassemble);
   DisassembleAll = InputArgs.hasArg(OBJDUMP_disassemble_all);
   SymbolDescription = InputArgs.hasArg(OBJDUMP_symbol_description);
   DisassembleSymbols =
       commaSeparatedValues(InputArgs, OBJDUMP_disassemble_symbols_EQ);
   DisassembleZeroes = InputArgs.hasArg(OBJDUMP_disassemble_zeroes);
   if (const opt::Arg *A = InputArgs.getLastArg(OBJDUMP_dwarf_EQ)) {
if (InputArgs.hasArg(HelpHiddenFlag)) {
     T->printHelp(ToolName, /*ShowHidden=*/true);
     return 0;
   }
 
   // Initialize targets and assembly printers/parsers.
   InitializeAllTargetInfos();
   InitializeAllTargetMCs();
   InitializeAllDisassemblers();
+  HTTPClient::initialize();
 
   if (InputArgs.hasArg(VersionFlag)) {
     cl::PrintVersionMessage();
     if (!Is("otool")) {
       outs() << '\n';
       TargetRegistry::printRegisteredTargetsForVersion(outs());
     }
     return 0;

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,
+                         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);