[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

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

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

llvm-symbolizer.cpp

34

Please update docs/CommandGuide/llvm-symbolizer.rst

130

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

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

329

Agreed.

llvm-symbolizer.cpp

34

Done

130

Done

[glider]

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

[glider]

LLVMSymbolize.cpp

215

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

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 ↗

(On Diff #14727)

Existing options are already listed below (after EXAMPLE)

31 ↗

(On Diff #14727)

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

tools/llvm-symbolizer/LLVMSymbolize.cpp

216 ↗

(On Diff #14727)

Looks like unfinished sentence.

303 ↗

(On Diff #14727)

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

304 ↗

(On Diff #14727)

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

319 ↗

(On Diff #14727)

static

328 ↗

(On Diff #14727)

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 ↗

(On Diff #14727)

Variable names should start with capital letter.

334 ↗

(On Diff #14727)

const auto &path

345 ↗

(On Diff #14727)

DsymPaths

361 ↗

(On Diff #14727)

just use "else if" here.

367 ↗

(On Diff #14727)

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

379 ↗

(On Diff #14727)

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

387 ↗

(On Diff #14727)

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?

394 ↗

(On Diff #14727)

if (!DbgObj) ?

tools/llvm-symbolizer/LLVMSymbolize.h

67 ↗

(On Diff #14727)

BinaryPair is unused now.

99 ↗

(On Diff #14727)

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 ↗

(On Diff #14727)

Indeed. Sorry, I've missed those.

31 ↗

(On Diff #14727)

Done.

tools/llvm-symbolizer/LLVMSymbolize.cpp

216 ↗

(On Diff #14727)

Good catch, fixed.

303 ↗

(On Diff #14727)

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

304 ↗

(On Diff #14727)

Done

319 ↗

(On Diff #14727)

Done

328 ↗

(On Diff #14727)

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 ↗

(On Diff #14727)

Done (hope I've fixed them all)

334 ↗

(On Diff #14727)

done

345 ↗

(On Diff #14727)

done

361 ↗

(On Diff #14727)

Removed Opts.Verbose instead.

367 ↗

(On Diff #14727)

Ok, but I've removed Opts.Verbose.

379 ↗

(On Diff #14727)

Moved them 1-2 scopes down.

387 ↗

(On Diff #14727)

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.

394 ↗

(On Diff #14727)

Fixed

tools/llvm-symbolizer/LLVMSymbolize.h

67 ↗

(On Diff #14727)

Removed.

99 ↗

(On Diff #14727)

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 ↗

(On Diff #14804)

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 ↗

(On Diff #14804)

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

tools/llvm-symbolizer/LLVMSymbolize.cpp

101 ↗

(On Diff #14804)

SymbolIterator

327 ↗

(On Diff #14804)

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 ↗

(On Diff #14804)

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

337 ↗

(On Diff #14804)

ResourcePath (or just get rid of local variable).

347 ↗

(On Diff #14804)

This variable is not used.

383 ↗

(On Diff #14804)

Please check that the code works if Obj is nullptr

386 ↗

(On Diff #14804)

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

tools/llvm-symbolizer/LLVMSymbolize.h

95 ↗

(On Diff #14804)

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

130 ↗

(On Diff #14804)

Please define each member on a separate line.

tools/llvm-symbolizer/llvm-symbolizer.cpp

132 ↗

(On Diff #14804)

You may want to print the invalid flag value here.

[glider]

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

1 ↗

(On Diff #14804)

Done

2 ↗

(On Diff #14804)

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

tools/llvm-symbolizer/LLVMSymbolize.cpp

101 ↗

(On Diff #14804)

Fixed in r219682.

327 ↗

(On Diff #14804)

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

334 ↗

(On Diff #14804)

Done

337 ↗

(On Diff #14804)

Done

347 ↗

(On Diff #14804)

Removed.

383 ↗

(On Diff #14804)

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

386 ↗

(On Diff #14804)

Done

tools/llvm-symbolizer/LLVMSymbolize.h

95 ↗

(On Diff #14804)

Done in r219682.

130 ↗

(On Diff #14804)

Fixed in r219682.

tools/llvm-symbolizer/llvm-symbolizer.cpp

132 ↗

(On Diff #14804)

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 ↗

(On Diff #14868)

s/path/Path

356 ↗

(On Diff #14868)

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.

358 ↗

(On Diff #14868)

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

320 ↗

(On Diff #14868)

Done

356 ↗

(On Diff #14868)

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

358 ↗

(On Diff #14868)

Removed the check.

[glider]

Fixed the comments.

[glider]

r220004, thank you!

LLVMSymbolize.h

 
 namespace symbolize {
 
 class ModuleInfo;
 
 class LLVMSymbolizer {
 public:
   struct Options {
+    bool Verbose : 1;
     bool UseSymbolTable : 1;
     FunctionNameKind PrintFunctions;
     bool PrintInlining : 1;
     bool Demangle : 1;
     std::string DefaultArch;
-    Options(bool UseSymbolTable = true,
+    std::vector<std::string> DsymHints;
+    Options(bool Verbose = false, 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) {}
+        : Verbose(Verbose), UseSymbolTable(UseSymbolTable),
+          PrintFunctions(PrintFunctions), PrintInlining(PrintInlining),
+          Demangle(Demangle), DefaultArch(DefaultArch) {}
+    void InitDsymHints(const std::vector<std::string>::iterator &HintBegin,
+                       const std::vector<std::string>::iterator &HintEnd) {
+      DsymHints.assign(HintBegin, HintEnd);
+    }
   };
 
   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);
+  void populateDsymPaths(std::vector<std::string> &Paths, const std::string &ExePath);
+  ObjectFile *lookUpDsymFile(const std::string &Path, ObjectFile *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.
   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;
+  typedef std::map<std::pair<std::string, std::string>, ObjectPair>
+      ObjectPairForPathArchTy;
+  ObjectPairForPathArchTy ObjectPairForPathArch;
 
   Options Opts;
   static const char kBadString[];
 };
 
 class ModuleInfo {
 public:
   ModuleInfo(ObjectFile *Obj, DIContext *DICtx);

LLVMSymbolize.cpp

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();
 }
 
+// For /path/to/foo and /path/to/foo.dSYM assume that debug info is in
+// /path/to/foo.dSYM/Contents/Resources/DWARF/foo.
 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);
+  SmallString<16> DsymDirectory;
+  if (sys::path::extension(Path) == ".dSYM") {
+    DsymDirectory = Path;
+  } else {
+    DsymDirectory = Path + ".dSYM";
+  }
+  StringRef Basename = sys::path::filename(DsymDirectory);
+  SmallString<16> ResourceName = StringRef(DsymDirectory);
   sys::path::append(ResourceName, "Contents", "Resources", "DWARF");
   sys::path::append(ResourceName, Basename);
+  sys::path::replace_extension(ResourceName, "");
   return ResourceName.str();
 }
 
 static bool checkFileCRC(StringRef Path, uint32_t CRCHash) {
   ErrorOr<std::unique_ptr<MemoryBuffer>> MB =
       MemoryBuffer::getFileOrSTDIN(Path);
   if (!MB)
     return false;
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())
+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;
+}
+
+bool darwinDsymMatchesBinary(const ObjectFile *DbgObj, const ObjectFile *Obj) {
+  ErrorOr<MachO::uuid_command> dbg_uuid_or_error = getUuidFromObjectFile(DbgObj);
+  ErrorOr<MachO::uuid_command> bin_uuid_or_error = getUuidFromObjectFile(Obj);
+  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(std::vector<std::string> &Paths, const std::string &ExePath) {
+  const std::string &ResourcePath =
+      getDarwinDWARFResourceForPath(ExePath);
+  Paths.push_back(ResourcePath);
+  for (const std::string &path : Opts.DsymHints) {
+    if (sys::path::extension(path) == ".dSYM")
+      Paths.push_back(getDarwinDWARFResourceForPath(path));
+  }
+}
+
+ObjectFile *LLVMSymbolizer::lookUpDsymFile(const std::string &ExePath,
+    ObjectFile *ExeObj, const std::string &ArchName) {
+  ObjectFile *result = nullptr;
+  // On Darwin we may find DWARF in separate object file in
+  // resource directory.
+  std::vector<std::string> dsym_paths;
+  populateDsymPaths(dsym_paths, ExePath);
+  for (const auto &path : dsym_paths) {
+    ErrorOr<OwningBinary<Binary>> BinaryOrErr = createBinary(path);
+    if (Opts.Verbose)
+      errs() << "Trying dSYM path: " << path << "\n";
+    std::error_code EC = BinaryOrErr.getError();
+    if (EC != errc::no_such_file_or_directory && !error(EC)) {
+      OwningBinary<Binary> B = std::move(BinaryOrErr.get());
+      Binary *DbgBin = B.getBinary().get();
+      ObjectFile *DbgObj = getObjectFileFromBinary(DbgBin, ArchName);
+      if (darwinDsymMatchesBinary(DbgObj, ExeObj)) {
+        addOwningBinary(std::move(B));
+        if (Opts.Verbose)
+          errs() << "Ok!\n";
+        return DbgObj; 
+      } else {
+        if (Opts.Verbose)
+          errs() << "Error: UUID mismatch!\n";
+      }
+    } else {
+      if (Opts.Verbose)
+        errs() << "Error: no such file\n";
+    }
+  }
+  return result;
+}
+
+LLVMSymbolizer::ObjectPair
+LLVMSymbolizer::getOrCreateObjects(const std::string &Path, const std::string &ArchName) {
+  ObjectPairForPathArchTy::iterator I =
+      ObjectPairForPathArch.find(std::make_pair(Path, ArchName));
+  if (I != ObjectPairForPathArch.end())
     return I->second;
   Binary *Bin = nullptr;
   Binary *DbgBin = nullptr;
+  ObjectFile *Obj = nullptr;
+  ObjectFile *DbgObj = 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();
+    Obj = getObjectFileFromBinary(Bin, ArchName);
     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();
-        addOwningBinary(std::move(B));
-      }
+      DbgObj = lookUpDsymFile(Path, Obj, ArchName);
     }
     // Try to locate the debug binary using .gnu_debuglink section.
     if (!DbgBin) {
       std::string DebuglinkName;
       uint32_t CRCHash;
       std::string DebugBinaryPath;
       if (getGNUDebuglinkContents(Bin, 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(DbgBin, 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) {
   if (!Bin)
     return nullptr;
   ObjectFile *Res = nullptr;
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>";

llvm-symbolizer.cpp

 #include <cstdio>
 #include <cstring>
 #include <string>
 
 using namespace llvm;
 using namespace symbolize;
 
 static cl::opt<bool>
+ClVerbose("v", cl::init(false), cl::desc("Verbose mode"));
+
+static cl::opt<bool>
 ClUseSymbolTable("use-symbol-table", cl::init(true),
                  cl::desc("Prefer names in symbol table to names "
                           "in debug info"));
 
 static cl::opt<FunctionNameKind> ClPrintFunctions(
     "functions", cl::init(FunctionNameKind::LinkageName),
     cl::desc("Print function name for a given address:"),
     cl::values(clEnumValN(FunctionNameKind::None, "none", "omit function name"),
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,
+  LLVMSymbolizer::Options Opts(ClVerbose, ClUseSymbolTable, ClPrintFunctions,
                                ClPrintInlining, ClDemangle, ClDefaultArch);
+  Opts.InitDsymHints(ClDsymHint.begin(), ClDsymHint.end());
   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;
 }