[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

218

Looks like unfinished sentence.

304–375

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

305

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

320

static

329

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.

331

Variable names should start with capital letter.

335

const auto &path

346

DsymPaths

362

just use "else if" here.

368

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

376–377

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

380–381

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?

391

if (!DbgObj) ?

tools/llvm-symbolizer/LLVMSymbolize.h

66

BinaryPair is unused now.

93

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

218

Good catch, fixed.

304–375

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

305

Done

320

Done

329

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.

331

Done (hope I've fixed them all)

335

done

346

done

362

Removed Opts.Verbose instead.

368

Ok, but I've removed Opts.Verbose.

376–377

Moved them 1-2 scopes down.

380–381

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.

391

Fixed

tools/llvm-symbolizer/LLVMSymbolize.h

66

Removed.

93

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

1

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

2

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

tools/llvm-symbolizer/LLVMSymbolize.cpp

101

SymbolIterator

327

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.

334

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

337

ResourcePath (or just get rid of local variable).

347

This variable is not used.

383

Please check that the code works if Obj is nullptr

386

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

tools/llvm-symbolizer/LLVMSymbolize.h

95

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

130

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

1

Done

2

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

tools/llvm-symbolizer/LLVMSymbolize.cpp

101

Fixed in r219682.

327

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

334

Done

337

Done

347

Removed.

383

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

386

Done

tools/llvm-symbolizer/LLVMSymbolize.h

95

Done in r219682.

130

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

321

s/path/Path

385

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.

385–386

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).

[glider]

tools/llvm-symbolizer/LLVMSymbolize.cpp

321

Done

385

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

385–386

Removed the check.

[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

+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);
+
+  void populateDsymPaths(const std::string &ExePath,
+                         std::vector<std::string> &OutPaths);
+  /// \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.
-  typedef std::map<std::string, ModuleInfo *> ModuleMapTy;
-  ModuleMapTy Modules;
-  typedef std::map<std::string, BinaryPair> BinaryMapTy;
-  BinaryMapTy BinaryForPath;
-  typedef std::map<std::pair<MachOUniversalBinary *, std::string>, ObjectFile *>
-      ObjectFileForArchMapTy;
-  ObjectFileForArchMapTy ObjectFileForArch;
+  std::map<std::string, ModuleInfo *> Modules;
+  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;
     }
   };
-  typedef std::map<SymbolDesc, StringRef> SymbolMapTy;
-  SymbolMapTy Functions;
-  SymbolMapTy Objects;
+  std::map<SymbolDesc, StringRef> Functions, Objects;
 };
 
 } // namespace symbolize
 } // namespace llvm
 
 #endif

tools/llvm-symbolizer/LLVMSymbolize.cpp

void ModuleInfo::addSymbol(const SymbolRef &Symbol) {
   StringRef SymbolName;
   if (error(Symbol.getName(SymbolName)))
     return;
   // Mach-O symbol table names have leading underscore, skip it.
   if (Module->isMachO() && SymbolName.size() > 0 && SymbolName[0] == '_')
     SymbolName = SymbolName.drop_front();
   // FIXME: If a function has alias, there are two entries in symbol table
   // with same address size. Make sure we choose the correct one.
-  SymbolMapTy &M = SymbolType == SymbolRef::ST_Function ? Functions : Objects;
+  auto &SymbolMap =
+      SymbolType == SymbolRef::ST_Function ? Functions : Objects;
   SymbolDesc SD = { SymbolAddress, SymbolSize };
-  M.insert(std::make_pair(SD, SymbolName));
+  SymbolMap.insert(std::make_pair(SD, SymbolName));
 }
 
 bool ModuleInfo::getNameFromSymbolTable(SymbolRef::Type Type, uint64_t Address,
                                         std::string &Name, uint64_t &Addr,
                                         uint64_t &Size) const {
-  const SymbolMapTy &M = Type == SymbolRef::ST_Function ? Functions : Objects;
-  if (M.empty())
+  const auto &SymbolMap = Type == SymbolRef::ST_Function ? Functions : Objects;
+  if (SymbolMap.empty())
     return false;
   SymbolDesc SD = { Address, Address };
-  SymbolMapTy::const_iterator it = M.upper_bound(SD);
-  if (it == M.begin())
+  auto symbol_iterator = SymbolMap.upper_bound(SD);
+  if (symbol_iterator == SymbolMap.begin())
     return false;
-  --it;
-  if (it->first.Size != 0 && it->first.Addr + it->first.Size <= Address)
+  --symbol_iterator;
+  if (symbol_iterator->first.Size != 0 &&
+      symbol_iterator->first.Addr + symbol_iterator->first.Size <= Address)
     return false;
-  Name = it->second.str();
-  Addr = it->first.Addr;
-  Size = it->first.Size;
+  Name = symbol_iterator->second.str();
+  Addr = symbol_iterator->first.Addr;
+  Size = symbol_iterator->first.Size;
   return true;
 }
 
 DILineInfo ModuleInfo::symbolizeCode(
     uint64_t ModuleOffset, const LLVMSymbolizer::Options &Opts) const {
   DILineInfo LineInfo;
   if (DebugInfoContext) {
     LineInfo = DebugInfoContext->getLineInfoForAddress(
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) {
-  BinaryMapTy::iterator 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();
+#if 0
+ErrorOr<MachO::uuid_command> getUuidFromObjectFile(const ObjectFile *Obj) {
+  const MachOObjectFile *file = dyn_cast<const MachOObjectFile>(Obj);
+  MachOObjectFile::LoadCommandInfo Command = file->getFirstLoadCommandInfo();
+  MachO::mach_header Header = file->getHeader();
+  unsigned ncmds = Header.ncmds;
+  for (unsigned i = 0;; ++i) {
+    if (Command.C.cmd == MachO::LC_UUID)
+      return file->getUuidCommand(Command);
+    if (i == ncmds - 1)
+      break;
+    else
+      Command = file->getNextLoadCommandInfo(Command);
+  }
+  return object_error::parse_failed;
+}
+#endif
+
+static
+bool darwinDsymMatchesBinary(const MachOObjectFile *DbgObj,
+                             const MachOObjectFile *Obj) {
+  ErrorOr<MachO::uuid_command> dbg_uuid_or_error = DbgObj->findAndGetUuidCommand();
+  ErrorOr<MachO::uuid_command> bin_uuid_or_error = Obj->findAndGetUuidCommand();
+  if (error(dbg_uuid_or_error.getError()) ||
+      error(bin_uuid_or_error.getError()))
+    return false;
+  return !memcmp(&(dbg_uuid_or_error.get()), &(bin_uuid_or_error.get()),
+                 sizeof(MachO::uuid_command));
+}
+
+void LLVMSymbolizer::populateDsymPaths(const std::string &ExePath,
+                                       std::vector<std::string> &OutPaths) {
+  StringRef Filename = sys::path::filename(ExePath);
+  const std::string &resource_path =
+      getDarwinDWARFResourceForPath(ExePath, Filename);
+  OutPaths.push_back(resource_path);
+  for (const auto &path : Opts.DsymHints) {
+    OutPaths.push_back(getDarwinDWARFResourceForPath(path, Filename));
+  }
+}
+
+ObjectFile *LLVMSymbolizer::lookUpDsymFile(const std::string &ExePath,
+    const MachOObjectFile *MachExeObj, const std::string &ArchName) {
+  ObjectFile *result = nullptr;
+  std::vector<std::string> DsymPaths;
+  populateDsymPaths(ExePath, DsymPaths);
+  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 result;
+
+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();
+    Binary *Bin = B.getBinary().get();
+    Obj = getObjectFileFromBinary(Bin, ArchName);
+    addOwningBinary(std::move(B));
+    if (Bin->isMachO() || Bin->isMachOUniversalBinary()) {
+      const MachOObjectFile *MachObj = dyn_cast<const MachOObjectFile>(Obj);
+      if (MachObj)
+        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)) {
-    ObjectFileForArchMapTy::iterator I = ObjectFileForArch.find(
-        std::make_pair(UB, ArchName));
+    const auto &I = ObjectFileForArch.find(std::make_pair(UB, ArchName));
     if (I != ObjectFileForArch.end())
       return I->second;
     ErrorOr<std::unique_ptr<ObjectFile>> ParsedObj =
         UB->getObjectForArch(Triple(ArchName).getArch());
     if (ParsedObj) {
       Res = ParsedObj.get().get();
       ParsedBinariesAndObjects.push_back(std::move(ParsedObj.get()));
     }
     ObjectFileForArch[std::make_pair(UB, ArchName)] = Res;
   } else if (Bin->isObject()) {
     Res = cast<ObjectFile>(Bin);
   }
   return Res;
 }
 
 ModuleInfo *
 LLVMSymbolizer::getOrCreateModuleInfo(const std::string &ModuleName) {
-  ModuleMapTy::iterator I = Modules.find(ModuleName);
+  const auto &I = Modules.find(ModuleName);
   if (I != Modules.end())
     return I->second;
   std::string BinaryName = ModuleName;
   std::string ArchName = Opts.DefaultArch;
   size_t ColonPos = ModuleName.find_last_of(':');
   // 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: dSYM 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;
 }