[llvm-symbolizer] Introduce the -dsym-hint option.

[glider]

Summary

llvm-symbolizer will consult one of the .dSYM paths passed via -dsym-hint if it fails to find the .dSYM bundle at the default location.

[samsonov]

Sorry, wasn't able to carefully review it today. Some early feedback.

Note that you will need tests in test/DebugInfo/ (add actual .dSYM bundles and macho files you're trying to symbolize under test/DebugInfo/, preferrably with sources and comments describing how to build them).

LLVMSymbolize.cpp

215 ↗

(On Diff #14660)

Why all this complexity? Can you just change this function to take .dSYM bundle, and call it either on file from .dSYM hints argument, or from PathToExe + ".dSYM"?

329 ↗

(On Diff #14660)

This can be a static helper, pass Opts.DynamicHints here.
Output parameters ("Paths") should better go last in argument list.

llvm-symbolizer.cpp

34 ↗

(On Diff #14660)

Please update docs/CommandGuide/llvm-symbolizer.rst

130 ↗

(On Diff #14660)

Additional method looks like an overkill. Opts is a struct, you can just call

Opts.DsymHints.assign(ClDsymHint.begin(), ClDsymHint.end());

[glider]

Don't you think the tests for commandline args should go into tets/tools/llvm-symbolizer instead?

LLVMSymbolize.cpp

215 ↗

(On Diff #14660)

We probably don't want to try those paths from -dsym-hints that don't end with ".dSYM"

329 ↗

(On Diff #14660)

Agreed.

llvm-symbolizer.cpp

34 ↗

(On Diff #14660)

Done

130 ↗

(On Diff #14660)

Done

[glider]

Updated the diff. Haven't finished the tests yet though.

[glider]

LLVMSymbolize.cpp

215 ↗

(On Diff #14660)

Hmm, the following workflow still doesn't work:

$ clang foo.c -g -c && clang foo.o -g -o foo
$ dsymutil foo -o bar.dSYM

Turns out the DWARF binary for foo is at bar.dSYM/Contents/Resources/DWARF/foo.

329 ↗

(On Diff #14660)

Actually, no. This function needs Opts.DsymHints.

[glider]

Sorry the last comment has been lost in time. The updated diff fixes the problem mentioned in http://reviews.llvm.org/D5705?id=14660#inline-47195

[samsonov]

I'm not sure if adding user-facing Verbosity option is a good idea, in this patch it looks merely like a debugging aid.

If we decide to introduce it, I'd prefer a separate patch, with a careful audit of all existing code and reasonable decisions of what and when to print (for instance, it makes sense to print our steps in attempt to resolve .gnu_debuglink).

docs/CommandGuide/llvm-symbolizer.rst

18

Existing options are already listed below (after EXAMPLE)

31

Please specify that this flag may be provided multiple times and that it's relevant only for Mac OS.

tools/llvm-symbolizer/LLVMSymbolize.cpp

217

Looks like unfinished sentence.

303–346

Looks like this routine is generally usable and should reside somewhere in libLLVMObject. At the very least, add a FIXME about it.

304

dyn_cast may return null. Either handle this, or take MachOObjectFile as an input argument.

319

static

328

I still think this should be a static helper, which should take Opts.DsymHints as an argument. Also, consider checking --dsym_hint values in the main binary (probably, even reporting an error is incorrect value is passed there), so that "Opts.DsymHints" are always reasonable.

330

Variable names should start with capital letter.

334

const auto &path

345

DsymPaths

347–348

Please get rid of Bin/DbgBin here, use local variables with small scope where appropriate instead.

351–352

So, you have this sequence scattered throughout the code (at least three times):

OwningBinary<Binary> B = std::move(BinaryOrErr.get());
Bin = B.getBinary().get();
Obj = getObjectFileFromBinary(Bin, ArchName);

Can it be simplified or moved to a function?

361

just use "else if" here.

363

if (!DbgObj) ?

367

You can use EC.message() - this can be a different kind of error.

tools/llvm-symbolizer/LLVMSymbolize.h

66

BinaryPair is unused now.

91

typedef is not really needed now in C++11 world. ObjectPairForPathArchTy::iterator can be replaced with auto.

[glider]

Addressed the comments.
WDYT is better: a) commit the binaries and .dSYM files for testing to the repository, or b) generate them on the fly?

docs/CommandGuide/llvm-symbolizer.rst

18

Indeed. Sorry, I've missed those.

31

Done.

tools/llvm-symbolizer/LLVMSymbolize.cpp

217

Good catch, fixed.

303–346

Sent http://reviews.llvm.org/D5752 for review

304

Done

319

Done

328

I've moved the check for ".dSYM" extension to the main binary, so this function has become really small now.
I think it's ok to make it a private member, or otherwise I can move it into lookUpDsymFile.

330

Done (hope I've fixed them all)

334

done

345

done

347–348

Moved them 1-2 scopes down.

351–352

I've tried to compactify these a bit.
But moving just these three lines into a separate function doesn't work because B is passed to addOwningBinary() later.
However it's not always correct to include addOwningBinary() into that function, because the former isn't called after every sequence you're talking about.
We won't get much from moving two of these three lines into a function OTOH.

361

Removed Opts.Verbose instead.

363

Fixed

367

Ok, but I've removed Opts.Verbose.

tools/llvm-symbolizer/LLVMSymbolize.h

66

Removed.

91

Removed typedefs except for ObjectPair which is used in several class members' declarations.

[glider]

Addressed Alexey's comments

[samsonov]

I think we should check in .dSYM binaries - IIUC we can't generate these files unless we have dsymutil installed in the system (and we certainly don't have it on Linux).

test/tools/llvm-symbolizer/Inputs/dsym-test.c

2

Please provide a comment with sequence of compiler / dsymutil invocations yielding the all the binaries you check in to Inputs/

[samsonov]

test/tools/llvm-symbolizer/Inputs/dsym-test.c

3

Do you need to add lit.local.cfg to this directory to exclude .c files from testsuite?

tools/llvm-symbolizer/LLVMSymbolize.cpp

100–101

SymbolIterator

326

Is it OK for a binary to not have UUID command? I think that if the object is well-formed, but doesn't have UUID command, you shouldn't use error() wrapper, as it prints error messages to stderr.

333

Probably it's ok to even sink this function down to lookUpDsymFile (I don't see how it can be generally useful).

336

ResourcePath (or just get rid of local variable).

346

This variable is not used.

352–357

if (auto MachObj = dyn_cast<const MachOObjectFile>(Obj))
  DbgObj = ...;

353

Please check that the code works if Obj is nullptr

tools/llvm-symbolizer/LLVMSymbolize.h

93

Thanks for the typedef cleanup. You may want to commit it separately as a cleanup change before the main patch.

128–129

Please define each member on a separate line.

tools/llvm-symbolizer/llvm-symbolizer.cpp

132

You may want to print the invalid flag value here.

[glider]

test/tools/llvm-symbolizer/Inputs/dsym-test.c

2

Done

3

I think no, lit doesn't attempt to run this file.

tools/llvm-symbolizer/LLVMSymbolize.cpp

100–101

Fixed in r219682.

326

No, it's not ok. However this code has changed in the latest version of the patch.

333

Done

336

Done

346

Removed.

352–357

Done

353

It should. I've inserted a return statement just for the case.

tools/llvm-symbolizer/LLVMSymbolize.h

93

Done in r219682.

128–129

Fixed in r219682.

tools/llvm-symbolizer/llvm-symbolizer.cpp

132

Done.

[glider]

Addressed the comments.

[samsonov]

LGTM, once the following minor comments are addressed.

Please run the patch through clang-format-diff before submitting. Thanks for working on this!

tools/llvm-symbolizer/LLVMSymbolize.cpp

320

s/path/Path

351–352

Do you need this check now? Looks like it's enough to check that Obj is a MachOObjectFile (and you won't need "Bin" variable in this case).

355

We still need to cache (nullptr, nullptr) pair in ObjectPairForPathArch. For example, if the path is invalid and provided 50 times, we don't want to print diagnostics 50 times in error() function. So, at least in the way the code is structured now, we'll have to increase the indentation.

[glider]

tools/llvm-symbolizer/LLVMSymbolize.cpp

320

Done

351–352

Removed the check.

355

Added code that puts (nullptr, nullptr) into the map. Don't think increasing the indentation is better here.

[glider]

Fixed the comments.

[glider]

r220004, thank you!

docs/CommandGuide/llvm-symbolizer.rst

 -----------
 
 :program:`llvm-symbolizer` reads object file names and addresses from standard
 input and prints corresponding source code locations to standard output.
 If object file is specified in command line, :program:`llvm-symbolizer` reads
 only addresses from standard input. This
 program uses debug info sections and symbol table in the object files.
 
 EXAMPLE
 --------
 
 .. code-block:: console
 
   $ cat addr.txt
   a.out 0x4004f4
   /tmp/b.out 0x400528
   /tmp/c.so 0x710
   /tmp/mach_universal_binary:i386 0x1f84
   /tmp/mach_universal_binary:x86_64 0x100000f24
   $ llvm-symbolizer < addr.txt
   main
   /tmp/a.cc:4
   
   f(int, int)
   /tmp/b.cc:11
 
   h_inlined_into_g
   /tmp/header.h:2
   g_inlined_into_f
   /tmp/header.h:7

 .. option:: -default-arch
 
  If a binary contains object files for multiple architectures (e.g. it is a
  Mach-O universal binary), symbolize the object file for a given architecture.
  You can also specify architecture by writing ``binary_name:arch_name`` in the
  input (see example above). If architecture is not specified in either way,
  address will not be symbolized. Defaults to empty string.
 
+.. option:: -dsym-hint=<path/to/file.dSYM>
+
+ (Darwin-only flag). If the debug info for a binary isn't present in the default
+ location, look for the debug info at the .dSYM path provided via the
+ ``-dsym-hint`` flag. This flag can be used multiple times.
+
+
 EXIT STATUS
 -----------
 
 :program:`llvm-symbolizer` returns 0. Other exit codes imply internal program error.

test/tools/llvm-symbolizer/Inputs/dsym-test.c

+// clang -c dsym-test.c -g
+// clang dsym-test.o -g -o dsym-test-exe
+// dsymutil dsym-test-exe
+// clang dsym-test.o -g -o dsym-test-exe-second
+// dsymutil dsym-test-exe-second -o dsym-test-exe-differentname.dSYM
+int main() {
+  return 0;
+}

test/tools/llvm-symbolizer/dsym.test

+RUN: echo "%p/Inputs/dsym-test-exe 0x0000000100000f90" > %t.input
+RUN: echo "%p/Inputs/dsym-test-exe-second 0x0000000100000f90" >> %t.input
+RUN: llvm-symbolizer < %t.input | FileCheck %s --check-prefix=CHECK-NOHINT
+RUN: llvm-symbolizer -dsym-hint=%p/Inputs/dsym-test-exe-differentname.dSYM < %t.input | FileCheck %s --check-prefix=CHECK-HINT
+
+CHECK-NOHINT: main
+CHECK-NOHINT: dsym-test.c
+CHECK-NOHINT: main
+CHECK-NOHINT: ??:0:0
+
+CHECK-HINT: main
+CHECK-HINT: dsym-test.c
+CHECK-HINT: main
+CHECK-HINT: dsym-test.c

tools/llvm-symbolizer/LLVMSymbolize.h

 class LLVMSymbolizer {
 public:
   struct Options {
     bool UseSymbolTable : 1;
     FunctionNameKind PrintFunctions;
     bool PrintInlining : 1;
     bool Demangle : 1;
     std::string DefaultArch;
+    std::vector<std::string> DsymHints;
     Options(bool UseSymbolTable = true,
             FunctionNameKind PrintFunctions = FunctionNameKind::LinkageName,
             bool PrintInlining = true, bool Demangle = true,
             std::string DefaultArch = "")
-        : UseSymbolTable(UseSymbolTable), PrintFunctions(PrintFunctions),
-          PrintInlining(PrintInlining), Demangle(Demangle),
-          DefaultArch(DefaultArch) {}
+        : UseSymbolTable(UseSymbolTable),
+          PrintFunctions(PrintFunctions), PrintInlining(PrintInlining),
+          Demangle(Demangle), DefaultArch(DefaultArch) {}
   };
 
   LLVMSymbolizer(const Options &Opts = Options()) : Opts(Opts) {}
   ~LLVMSymbolizer() {
     flush();
   }
 
   // Returns the result of symbolization for module name/offset as
   // a string (possibly containing newlines).
   std::string
   symbolizeCode(const std::string &ModuleName, uint64_t ModuleOffset);
   std::string
   symbolizeData(const std::string &ModuleName, uint64_t ModuleOffset);
   void flush();
   static std::string DemangleName(const std::string &Name);
 private:
-  typedef std::pair<Binary*, Binary*> BinaryPair;
+  typedef std::pair<ObjectFile*, ObjectFile*> ObjectPair;
 
   ModuleInfo *getOrCreateModuleInfo(const std::string &ModuleName);
-  /// \brief Returns pair of pointers to binary and debug binary.
-  BinaryPair getOrCreateBinary(const std::string &Path);
+  ObjectFile *lookUpDsymFile(const std::string &Path, const MachOObjectFile *ExeObj,
+                             const std::string &ArchName);
+
+  /// \brief Returns pair of pointers to object and debug object.
+  ObjectPair getOrCreateObjects(const std::string &Path,
+                                const std::string &ArchName);
   /// \brief Returns a parsed object file for a given architecture in a
   /// universal binary (or the binary itself if it is an object file).
   ObjectFile *getObjectFileFromBinary(Binary *Bin, const std::string &ArchName);
 
   std::string printDILineInfo(DILineInfo LineInfo) const;
 
   // Owns all the parsed binaries and object files.
   SmallVector<std::unique_ptr<Binary>, 4> ParsedBinariesAndObjects;
   SmallVector<std::unique_ptr<MemoryBuffer>, 4> MemoryBuffers;
   void addOwningBinary(OwningBinary<Binary> Bin) {
     ParsedBinariesAndObjects.push_back(std::move(Bin.getBinary()));
     MemoryBuffers.push_back(std::move(Bin.getBuffer()));
   }
 
   // Owns module info objects.
   std::map<std::string, ModuleInfo *> Modules;
-  std::map<std::string, BinaryPair> BinaryForPath;
   std::map<std::pair<MachOUniversalBinary *, std::string>, ObjectFile *>
       ObjectFileForArch;
+  std::map<std::pair<std::string, std::string>, ObjectPair>
+      ObjectPairForPathArch;
 
   Options Opts;
   static const char kBadString[];
 };
 
 class ModuleInfo {
 public:
   ModuleInfo(ObjectFile *Obj, DIContext *DICtx);
struct SymbolDesc {
     uint64_t Addr;
     // If size is 0, assume that symbol occupies the whole memory range up to
     // the following symbol.
     uint64_t Size;
     friend bool operator<(const SymbolDesc &s1, const SymbolDesc &s2) {
       return s1.Addr < s2.Addr;
     }
   };
   std::map<SymbolDesc, StringRef> Functions;
   std::map<SymbolDesc, StringRef> Objects;
 };
 
 } // namespace symbolize
 } // namespace llvm
 
 #endif

tools/llvm-symbolizer/LLVMSymbolize.cpp

 
 bool ModuleInfo::getNameFromSymbolTable(SymbolRef::Type Type, uint64_t Address,
                                         std::string &Name, uint64_t &Addr,
                                         uint64_t &Size) const {
   const auto &SymbolMap = Type == SymbolRef::ST_Function ? Functions : Objects;
   if (SymbolMap.empty())
     return false;
   SymbolDesc SD = { Address, Address };
   auto SymbolIterator = SymbolMap.upper_bound(SD);
   if (SymbolIterator == SymbolMap.begin())
     return false;
   --SymbolIterator;
   if (SymbolIterator->first.Size != 0 &&
       SymbolIterator->first.Addr + SymbolIterator->first.Size <= Address)
     return false;
   Name = SymbolIterator->second.str();
   Addr = SymbolIterator->first.Addr;
   Size = SymbolIterator->first.Size;
std::string LLVMSymbolizer::symbolizeData(const std::string &ModuleName,
   }
   std::stringstream ss;
   ss << Name << "\n" << Start << " " << Size << "\n";
   return ss.str();
 }
 
 void LLVMSymbolizer::flush() {
   DeleteContainerSeconds(Modules);
-  BinaryForPath.clear();
+  ObjectPairForPathArch.clear();
   ObjectFileForArch.clear();
 }
 
-static std::string getDarwinDWARFResourceForPath(const std::string &Path) {
-  StringRef Basename = sys::path::filename(Path);
-  const std::string &DSymDirectory = Path + ".dSYM";
-  SmallString<16> ResourceName = StringRef(DSymDirectory);
+// For Path="/path/to/foo" and Basename="foo" assume that debug info is in
+// /path/to/foo.dSYM/Contents/Resources/DWARF/foo.
+// For Path="/path/to/bar.dSYM" and Basename="foo" assume that debug info is in
+// /path/to/bar.dSYM/Contents/Resources/DWARF/foo.
+static
+std::string getDarwinDWARFResourceForPath(
+    const std::string &Path, const std::string &Basename) {
+  SmallString<16> ResourceName = StringRef(Path);
+  if (sys::path::extension(Path) != ".dSYM") {
+    ResourceName += ".dSYM";
+  }
   sys::path::append(ResourceName, "Contents", "Resources", "DWARF");
   sys::path::append(ResourceName, Basename);
   return ResourceName.str();
 }
 
 static bool checkFileCRC(StringRef Path, uint32_t CRCHash) {
   ErrorOr<std::unique_ptr<MemoryBuffer>> MB =
       MemoryBuffer::getFileOrSTDIN(Path);
llvm::sys::path::append(DebugPath, llvm::sys::path::relative_path(OrigDir),
                           DebuglinkName);
   if (checkFileCRC(DebugPath, CRCHash)) {
     Result = DebugPath.str();
     return true;
   }
   return false;
 }
 
-static bool getGNUDebuglinkContents(const Binary *Bin, std::string &DebugName,
+static bool getGNUDebuglinkContents(const ObjectFile *Obj, std::string &DebugName,
                                     uint32_t &CRCHash) {
-  const ObjectFile *Obj = dyn_cast<ObjectFile>(Bin);
   if (!Obj)
     return false;
   for (const SectionRef &Section : Obj->sections()) {
     StringRef Name;
     Section.getName(Name);
     Name = Name.substr(Name.find_first_not_of("._"));
     if (Name == "gnu_debuglink") {
       StringRef Data;
if (Name == "gnu_debuglink") {
         }
       }
       break;
     }
   }
   return false;
 }
 
-LLVMSymbolizer::BinaryPair
-LLVMSymbolizer::getOrCreateBinary(const std::string &Path) {
-  const auto &I = BinaryForPath.find(Path);
-  if (I != BinaryForPath.end())
-    return I->second;
-  Binary *Bin = nullptr;
-  Binary *DbgBin = nullptr;
-  ErrorOr<OwningBinary<Binary>> BinaryOrErr = createBinary(Path);
-  if (!error(BinaryOrErr.getError())) {
-    OwningBinary<Binary> &ParsedBinary = BinaryOrErr.get();
-    // Check if it's a universal binary.
-    Bin = ParsedBinary.getBinary().get();
-    addOwningBinary(std::move(ParsedBinary));
-    if (Bin->isMachO() || Bin->isMachOUniversalBinary()) {
-      // On Darwin we may find DWARF in separate object file in
-      // resource directory.
-      const std::string &ResourcePath =
-          getDarwinDWARFResourceForPath(Path);
-      BinaryOrErr = createBinary(ResourcePath);
-      std::error_code EC = BinaryOrErr.getError();
-      if (EC != errc::no_such_file_or_directory && !error(EC)) {
-        OwningBinary<Binary> B = std::move(BinaryOrErr.get());
-        DbgBin = B.getBinary().get();
+static
+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());
+}
+
+ObjectFile *LLVMSymbolizer::lookUpDsymFile(const std::string &ExePath,
+    const MachOObjectFile *MachExeObj, const std::string &ArchName) {
+  std::vector<std::string> DsymPaths;
+  StringRef Filename = sys::path::filename(ExePath);
+  DsymPaths.push_back(getDarwinDWARFResourceForPath(ExePath, Filename));
+  for (const auto &Path : Opts.DsymHints) {
+    DsymPaths.push_back(getDarwinDWARFResourceForPath(Path, Filename));
+  }
+  for (const auto &path : DsymPaths) {
+    ErrorOr<OwningBinary<Binary>> BinaryOrErr = createBinary(path);
+      ObjectFile *DbgObj =
+          getObjectFileFromBinary(B.getBinary().get(), ArchName);
+      const MachOObjectFile *MachDbgObj =
+          dyn_cast<const MachOObjectFile>(DbgObj);
+      if (!MachDbgObj) continue;
+      if (darwinDsymMatchesBinary(MachDbgObj, MachExeObj)) {
         addOwningBinary(std::move(B));
-      }
+        return DbgObj; 
+      }
+    }
+  return nullptr;
+}
+
+LLVMSymbolizer::ObjectPair
+LLVMSymbolizer::getOrCreateObjects(const std::string &Path,
+                                   const std::string &ArchName) {
+  const auto &I = ObjectPairForPathArch.find(std::make_pair(Path, ArchName));
+  if (I != ObjectPairForPathArch.end())
+    return I->second;
+  ObjectFile *Obj = nullptr;
+  ObjectFile *DbgObj = nullptr;
+  ErrorOr<OwningBinary<Binary>> BinaryOrErr = createBinary(Path);
+  if (!error(BinaryOrErr.getError())) {
+    OwningBinary<Binary> &B = BinaryOrErr.get();
+    Obj = getObjectFileFromBinary(B.getBinary().get(), ArchName);
+    if (!Obj) {
+      ObjectPair Res = std::make_pair(nullptr, nullptr);
+      ObjectPairForPathArch[std::make_pair(Path, ArchName)] = Res;
+      return Res;
     }
+    addOwningBinary(std::move(B));
+    if (auto MachObj = dyn_cast<const MachOObjectFile>(Obj))
+      DbgObj = lookUpDsymFile(Path, MachObj, ArchName);
     // Try to locate the debug binary using .gnu_debuglink section.
-    if (!DbgBin) {
+    if (!DbgObj) {
       std::string DebuglinkName;
       uint32_t CRCHash;
       std::string DebugBinaryPath;
-      if (getGNUDebuglinkContents(Bin, DebuglinkName, CRCHash) &&
+      if (getGNUDebuglinkContents(Obj, DebuglinkName, CRCHash) &&
           findDebugBinary(Path, DebuglinkName, CRCHash, DebugBinaryPath)) {
         BinaryOrErr = createBinary(DebugBinaryPath);
         if (!error(BinaryOrErr.getError())) {
           OwningBinary<Binary> B = std::move(BinaryOrErr.get());
-          DbgBin = B.getBinary().get();
+          DbgObj = getObjectFileFromBinary(B.getBinary().get(), ArchName);
           addOwningBinary(std::move(B));
         }
       }
     }
   }
-  if (!DbgBin)
-    DbgBin = Bin;
-  BinaryPair Res = std::make_pair(Bin, DbgBin);
-  BinaryForPath[Path] = Res;
+  if (!DbgObj)
+    DbgObj = Obj;
+  ObjectPair Res = std::make_pair(Obj, DbgObj);
+  ObjectPairForPathArch[std::make_pair(Path, ArchName)] = Res;
   return Res;
 }
 
 ObjectFile *
-LLVMSymbolizer::getObjectFileFromBinary(Binary *Bin, const std::string &ArchName) {
+LLVMSymbolizer::getObjectFileFromBinary(Binary *Bin,
+                                        const std::string &ArchName) {
   if (!Bin)
     return nullptr;
   ObjectFile *Res = nullptr;
   if (MachOUniversalBinary *UB = dyn_cast<MachOUniversalBinary>(Bin)) {
     const auto &I = ObjectFileForArch.find(
         std::make_pair(UB, ArchName));
     if (I != ObjectFileForArch.end())
       return I->second;
LLVMSymbolizer::getOrCreateModuleInfo(const std::string &ModuleName) {
   // Verify that substring after colon form a valid arch name.
   if (ColonPos != std::string::npos) {
     std::string ArchStr = ModuleName.substr(ColonPos + 1);
     if (Triple(ArchStr).getArch() != Triple::UnknownArch) {
       BinaryName = ModuleName.substr(0, ColonPos);
       ArchName = ArchStr;
     }
   }
-  BinaryPair Binaries = getOrCreateBinary(BinaryName);
-  ObjectFile *Obj = getObjectFileFromBinary(Binaries.first, ArchName);
-  ObjectFile *DbgObj = getObjectFileFromBinary(Binaries.second, ArchName);
+  ObjectPair Objects = getOrCreateObjects(BinaryName, ArchName);
 
-  if (!Obj) {
+  if (!Objects.first) {
     // Failed to find valid object file.
     Modules.insert(make_pair(ModuleName, (ModuleInfo *)nullptr));
     return nullptr;
   }
-  DIContext *Context = DIContext::getDWARFContext(*DbgObj);
+  DIContext *Context = DIContext::getDWARFContext(*Objects.second);
   assert(Context);
-  ModuleInfo *Info = new ModuleInfo(Obj, Context);
+  ModuleInfo *Info = new ModuleInfo(Objects.first, Context);
   Modules.insert(make_pair(ModuleName, Info));
   return Info;
 }
 
 std::string LLVMSymbolizer::printDILineInfo(DILineInfo LineInfo) const {
   // By default, DILineInfo contains "<invalid>" for function/filename it
   // cannot fetch. We replace it to "??" to make our output closer to addr2line.
   static const std::string kDILineInfoBadString = "<invalid>";

tools/llvm-symbolizer/llvm-symbolizer.cpp

 // to symbolize stack traces in their error reports.
 //
 //===----------------------------------------------------------------------===//
 
 #include "LLVMSymbolize.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
+#include "llvm/Support/FileSystem.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cstdio>
 #include <cstring>
 #include <string>
 
static cl::opt<std::string> ClDefaultArch("default-arch", cl::init(""),
                                           cl::desc("Default architecture "
                                                    "(for multi-arch objects)"));
 
 static cl::opt<std::string>
 ClBinaryName("obj", cl::init(""),
              cl::desc("Path to object file to be symbolized (if not provided, "
                       "object file should be specified for each input line)"));
 
+static cl::list<std::string>
+ClDsymHint("dsym-hint", cl::ZeroOrMore,
+           cl::desc("Path to .dSYM bundles to search for debug info for the "
+                    "object files"));
+
 static bool parseCommand(bool &IsData, std::string &ModuleName,
                          uint64_t &ModuleOffset) {
   const char *kDataCmd = "DATA ";
   const char *kCodeCmd = "CODE ";
   const int kMaxInputStringLength = 1024;
   const char kDelimiters[] = " \n";
   char InputString[kMaxInputStringLength];
   if (!fgets(InputString, sizeof(InputString), stdin))
int main(int argc, char **argv) {
   // Print stack trace if we signal out.
   sys::PrintStackTraceOnErrorSignal();
   PrettyStackTraceProgram X(argc, argv);
   llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
 
   cl::ParseCommandLineOptions(argc, argv, "llvm-symbolizer\n");
   LLVMSymbolizer::Options Opts(ClUseSymbolTable, ClPrintFunctions,
                                ClPrintInlining, ClDemangle, ClDefaultArch);
+  for (const auto &hint : ClDsymHint) {
+    if (sys::path::extension(hint) == ".dSYM") {
+      Opts.DsymHints.push_back(hint);
+    } else {
+      errs() << "Warning: invalid dSYM hint: \"" << hint <<
+                "\" (must have the '.dSYM' extension).\n";
+    }
+  }
   LLVMSymbolizer Symbolizer(Opts);
 
   bool IsData = false;
   std::string ModuleName;
   uint64_t ModuleOffset;
   while (parseCommand(IsData, ModuleName, ModuleOffset)) {
     std::string Result =
         IsData ? Symbolizer.symbolizeData(ModuleName, ModuleOffset)
                : Symbolizer.symbolizeCode(ModuleName, ModuleOffset);
     outs() << Result << "\n";
     outs().flush();
   }
   return 0;
 }