tools/llvm-dwarfdump/llvm-dwarfdump.cpp

   1 //===-- llvm-dwarfdump.cpp - Debug info dumping utility for llvm ----------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This program is a utility that works like "dwarfdump".
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "llvm/ADT/STLExtras.h"
  15 #include "llvm/ADT/StringSet.h"
  16 #include "llvm/ADT/Triple.h"
  17 #include "llvm/DebugInfo/DIContext.h"
  18 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
  19 #include "llvm/Object/Archive.h"
  20 #include "llvm/Object/MachOUniversal.h"
  21 #include "llvm/Object/ObjectFile.h"
  22 #include "llvm/Support/CommandLine.h"
  23 #include "llvm/Support/Debug.h"
  24 #include "llvm/Support/Format.h"
  25 #include "llvm/Support/InitLLVM.h"
  26 #include "llvm/Support/MemoryBuffer.h"
  27 #include "llvm/Support/Path.h"
  28 #include "llvm/Support/Regex.h"
  29 #include "llvm/Support/TargetSelect.h"
  30 #include "llvm/Support/ToolOutputFile.h"
  31 #include "llvm/Support/WithColor.h"
  32 #include "llvm/Support/raw_ostream.h"
  33
  34 using namespace llvm;
  35 using namespace object;
  36
  37 /// Parser for options that take an optional offest argument.
  38 /// @{
  39 struct OffsetOption {
  40   uint64_t Val = 0;
  41   bool HasValue = false;
  42   bool IsRequested = false;
  43 };
  44
  45 namespace llvm {
  46 namespace cl {
  47 template <>
  48 class parser<OffsetOption> final : public basic_parser<OffsetOption> {
  49 public:
  50   parser(Option &O) : basic_parser(O) {}
  51
  52   /// Return true on error.
  53   bool parse(Option &O, StringRef ArgName, StringRef Arg, OffsetOption &Val) {
  54     if (Arg == "") {
  55       Val.Val = 0;
  56       Val.HasValue = false;
  57       Val.IsRequested = true;
  58       return false;
  59     }
  60     if (Arg.getAsInteger(0, Val.Val))
  61       return O.error("'" + Arg + "' value invalid for integer argument!");
  62     Val.HasValue = true;
  63     Val.IsRequested = true;
  64     return false;
  65   }
  66
  67   enum ValueExpected getValueExpectedFlagDefault() const {
  68     return ValueOptional;
  69   }
  70
  71   void printOptionInfo(const Option &O, size_t GlobalWidth) const {
  72     outs() << "  -" << O.ArgStr;
  73     Option::printHelpStr(O.HelpStr, GlobalWidth, getOptionWidth(O));
  74   }
  75
  76   void printOptionDiff(const Option &O, OffsetOption V, OptVal Default,
  77                        size_t GlobalWidth) const {
  78     printOptionName(O, GlobalWidth);
  79     outs() << "[=offset]";
  80   }
  81
  82   // An out-of-line virtual method to provide a 'home' for this class.
  83   void anchor() override {};
  84 };
  85 } // cl
  86 } // llvm
  87
  88 /// @}
  89 /// Command line options.
  90 /// @{
  91
  92 namespace {
  93 using namespace cl;
  94
  95 OptionCategory DwarfDumpCategory("Specific Options");
  96 static opt<bool> Help("h", desc("Alias for -help"), Hidden,
  97                       cat(DwarfDumpCategory));
  98 static list<std::string>
  99     InputFilenames(Positional, desc("<input object files or .dSYM bundles>"),
 100                    ZeroOrMore, cat(DwarfDumpCategory));
 101
 102 cl::OptionCategory SectionCategory("Section-specific Dump Options",
 103                                    "These control which sections are dumped. "
 104                                    "Where applicable these parameters take an "
 105                                    "optional =<offset> argument to dump only "
 106                                    "the entry at the specified offset.");
 107
 108 static opt<bool> DumpAll("all", desc("Dump all debug info sections"),
 109                          cat(SectionCategory));
 110 static alias DumpAllAlias("a", desc("Alias for -all"), aliasopt(DumpAll));
 111
 112 // Options for dumping specific sections.
 113 static unsigned DumpType = DIDT_Null;
 114 static std::array<llvm::Optional<uint64_t>, (unsigned)DIDT_ID_Count>
 115     DumpOffsets;
 116 #define HANDLE_DWARF_SECTION(ENUM_NAME, ELF_NAME, CMDLINE_NAME)                \
 117   static opt<OffsetOption> Dump##ENUM_NAME(                                    \
 118       CMDLINE_NAME, desc("Dump the " ELF_NAME " section"),                     \
 119       cat(SectionCategory));
 120 #include "llvm/BinaryFormat/Dwarf.def"
 121 #undef HANDLE_DWARF_SECTION
 122
 123 static alias DumpDebugFrameAlias("eh-frame", desc("Alias for -debug-frame"),
 124                                  NotHidden, cat(SectionCategory),
 125                                  aliasopt(DumpDebugFrame));
 126 static list<std::string>
 127     ArchFilters("arch",
 128                 desc("Dump debug information for the specified CPU "
 129                      "architecture only. Architectures may be specified by "
 130                      "name or by number. This option can be specified "
 131                      "multiple times, once for each desired architecture."),
 132                 cat(DwarfDumpCategory));
 133 static opt<bool>
 134     Diff("diff",
 135          desc("Emit diff-friendly output by omitting offsets and addresses."),
 136          cat(DwarfDumpCategory));
 137 static list<std::string>
 138     Find("find",
 139          desc("Search for the exact match for <name> in the accelerator tables "
 140               "and print the matching debug information entries. When no "
 141               "accelerator tables are available, the slower but more complete "
 142               "-name option can be used instead."),
 143          value_desc("name"), cat(DwarfDumpCategory));
 144 static alias FindAlias("f", desc("Alias for -find."), aliasopt(Find));
 145 static opt<bool>
 146     IgnoreCase("ignore-case",
 147                desc("Ignore case distinctions in when searching by name."),
 148                value_desc("i"), cat(DwarfDumpCategory));
 149 static alias IgnoreCaseAlias("i", desc("Alias for -ignore-case."),
 150                              aliasopt(IgnoreCase));
 151 static list<std::string> Name(
 152     "name",
 153     desc("Find and print all debug info entries whose name (DW_AT_name "
 154          "attribute) matches the exact text in <pattern>.  When used with the "
 155          "the -regex option <pattern> is interpreted as a regular expression."),
 156     value_desc("pattern"), cat(DwarfDumpCategory));
 157 static alias NameAlias("n", desc("Alias for -name"), aliasopt(Name));
 158 static opt<unsigned long long> Lookup("lookup",
 159            desc("Lookup <address> in the debug information and print out any "
 160                 "available file, function, block and line table details."),
 161            value_desc("address"), cat(DwarfDumpCategory));
 162 static opt<std::string>
 163     OutputFilename("out-file", cl::init(""),
 164                    cl::desc("Redirect output to the specified file."),
 165                    cl::value_desc("filename"));
 166 static alias OutputFilenameAlias("o", desc("Alias for -out-file."),
 167                                  aliasopt(OutputFilename),
 168                                  cat(DwarfDumpCategory));
 169 static opt<bool>
 170     UseRegex("regex",
 171              desc("Treat any <pattern> strings as regular expressions when "
 172                   "searching instead of just as an exact string match."),
 173              cat(DwarfDumpCategory));
 174 static alias RegexAlias("x", desc("Alias for -regex"), aliasopt(UseRegex));
 175 static opt<bool>
 176     ShowChildren("show-children",
 177                  desc("Show a debug info entry's children when selectively "
 178                       "printing with the =<offset> option."),
 179                  cat(DwarfDumpCategory));
 180 static alias ShowChildrenAlias("c", desc("Alias for -show-children."),
 181                                aliasopt(ShowChildren));
 182 static opt<bool>
 183     ShowParents("show-parents",
 184                 desc("Show a debug info entry's parents when selectively "
 185                      "printing with the =<offset> option."),
 186                 cat(DwarfDumpCategory));
 187 static alias ShowParentsAlias("p", desc("Alias for -show-parents."),
 188                               aliasopt(ShowParents));
 189 static opt<bool>
 190     ShowForm("show-form",
 191              desc("Show DWARF form types after the DWARF attribute types."),
 192              cat(DwarfDumpCategory));
 193 static alias ShowFormAlias("F", desc("Alias for -show-form."),
 194                            aliasopt(ShowForm), cat(DwarfDumpCategory));
 195 static opt<unsigned> RecurseDepth(
 196     "recurse-depth",
 197     desc("Only recurse to a depth of N when displaying debug info entries."),
 198     cat(DwarfDumpCategory), init(-1U), value_desc("N"));
 199 static alias RecurseDepthAlias("r", desc("Alias for -recurse-depth."),
 200                                aliasopt(RecurseDepth));
 201
 202 static opt<bool>
 203     SummarizeTypes("summarize-types",
 204                    desc("Abbreviate the description of type unit entries."),
 205                    cat(DwarfDumpCategory));
 206 static cl::opt<bool>
 207     Statistics("statistics",
 208                cl::desc("Emit JSON-formatted debug info quality metrics."),
 209                cat(DwarfDumpCategory));
 210 static opt<bool> Verify("verify", desc("Verify the DWARF debug info."),
 211                         cat(DwarfDumpCategory));
 212 static opt<bool> Quiet("quiet", desc("Use with -verify to not emit to STDOUT."),
 213                        cat(DwarfDumpCategory));
 214 static opt<bool> DumpUUID("uuid", desc("Show the UUID for each architecture."),
 215                           cat(DwarfDumpCategory));
 216 static alias DumpUUIDAlias("u", desc("Alias for -uuid."), aliasopt(DumpUUID));
 217 static opt<bool> Verbose("verbose",
 218                          desc("Print more low-level encoding details."),
 219                          cat(DwarfDumpCategory));
 220 static alias VerboseAlias("v", desc("Alias for -verbose."), aliasopt(Verbose),
 221                           cat(DwarfDumpCategory));
 222 } // namespace
 223 /// @}
 224 //===----------------------------------------------------------------------===//
 225
 226 static void error(StringRef Prefix, std::error_code EC) {
 227   if (!EC)
 228     return;
 229   WithColor::error() << Prefix << ": " << EC.message() << "\n";
 230   exit(1);
 231 }
 232
 233 static DIDumpOptions getDumpOpts() {
 234   DIDumpOptions DumpOpts;
 235   DumpOpts.DumpType = DumpType;
 236   DumpOpts.RecurseDepth = RecurseDepth;
 237   DumpOpts.ShowAddresses = !Diff;
 238   DumpOpts.ShowChildren = ShowChildren;
 239   DumpOpts.ShowParents = ShowParents;
 240   DumpOpts.ShowForm = ShowForm;
 241   DumpOpts.SummarizeTypes = SummarizeTypes;
 242   DumpOpts.Verbose = Verbose;
 243   // In -verify mode, print DIEs without children in error messages.
 244   if (Verify)
 245     return DumpOpts.noImplicitRecursion();
 246   return DumpOpts;
 247 }
 248
 249 static uint32_t getCPUType(MachOObjectFile &MachO) {
 250   if (MachO.is64Bit())
 251     return MachO.getHeader64().cputype;
 252   else
 253     return MachO.getHeader().cputype;
 254 }
 255
 256 /// Return true if the object file has not been filtered by an --arch option.
 257 static bool filterArch(ObjectFile &Obj) {
 258   if (ArchFilters.empty())
 259     return true;
 260
 261   if (auto *MachO = dyn_cast<MachOObjectFile>(&Obj)) {
 262     std::string ObjArch =
 263         Triple::getArchTypeName(MachO->getArchTriple().getArch());
 264
 265     for (auto Arch : ArchFilters) {
 266       // Match name.
 267       if (Arch == ObjArch)
 268         return true;
 269
 270       // Match architecture number.
 271       unsigned Value;
 272       if (!StringRef(Arch).getAsInteger(0, Value))
 273         if (Value == getCPUType(*MachO))
 274           return true;
 275     }
 276   }
 277   return false;
 278 }
 279
 280 using HandlerFn = std::function<bool(ObjectFile &, DWARFContext &DICtx, Twine,
 281                                      raw_ostream &)>;
 282
 283 /// Print only DIEs that have a certain name.
 284 static bool filterByName(const StringSet<> &Names, DWARFDie Die,
 285                          StringRef NameRef, raw_ostream &OS) {
 286   std::string Name =
 287       (IgnoreCase && !UseRegex) ? NameRef.lower() : NameRef.str();
 288   if (UseRegex) {
 289     // Match regular expression.
 290     for (auto Pattern : Names.keys()) {
 291       Regex RE(Pattern, IgnoreCase ? Regex::IgnoreCase : Regex::NoFlags);
 292       std::string Error;
 293       if (!RE.isValid(Error)) {
 294         errs() << "error in regular expression: " << Error << "\n";
 295         exit(1);
 296       }
 297       if (RE.match(Name)) {
 298         Die.dump(OS, 0, getDumpOpts());
 299         return true;
 300       }
 301     }
 302   } else if (Names.count(Name)) {
 303     // Match full text.
 304     Die.dump(OS, 0, getDumpOpts());
 305     return true;
 306   }
 307   return false;
 308 }
 309
 310 /// Print only DIEs that have a certain name.
 311 static void filterByName(const StringSet<> &Names,
 312                          DWARFContext::unit_iterator_range CUs,
 313                          raw_ostream &OS) {
 314   for (const auto &CU : CUs)
 315     for (const auto &Entry : CU->dies()) {
 316       DWARFDie Die = {CU.get(), &Entry};
 317       if (const char *Name = Die.getName(DINameKind::ShortName))
 318         if (filterByName(Names, Die, Name, OS))
 319           continue;
 320       if (const char *Name = Die.getName(DINameKind::LinkageName))
 321         filterByName(Names, Die, Name, OS);
 322     }
 323 }
 324
 325 static void getDies(DWARFContext &DICtx, const AppleAcceleratorTable &Accel,
 326                     StringRef Name, SmallVectorImpl<DWARFDie> &Dies) {
 327   for (const auto &Entry : Accel.equal_range(Name)) {
 328     if (llvm::Optional<uint64_t> Off = Entry.getDIESectionOffset()) {
 329       if (DWARFDie Die = DICtx.getDIEForOffset(*Off))
 330         Dies.push_back(Die);
 331     }
 332   }
 333 }
 334
 335 static DWARFDie toDie(const DWARFDebugNames::Entry &Entry,
 336                       DWARFContext &DICtx) {
 337   llvm::Optional<uint64_t> CUOff = Entry.getCUOffset();
 338   llvm::Optional<uint64_t> Off = Entry.getDIEUnitOffset();
 339   if (!CUOff || !Off)
 340     return DWARFDie();
 341
 342   DWARFCompileUnit *CU = DICtx.getCompileUnitForOffset(*CUOff);
 343   if (!CU)
 344     return DWARFDie();
 345
 346   if (llvm::Optional<uint64_t> DWOId = CU->getDWOId()) {
 347     // This is a skeleton unit. Look up the DIE in the DWO unit.
 348     CU = DICtx.getDWOCompileUnitForHash(*DWOId);
 349     if (!CU)
 350       return DWARFDie();
 351   }
 352
 353   return CU->getDIEForOffset(CU->getOffset() + *Off);
 354 }
 355
 356 static void getDies(DWARFContext &DICtx, const DWARFDebugNames &Accel,
 357                     StringRef Name, SmallVectorImpl<DWARFDie> &Dies) {
 358   for (const auto &Entry : Accel.equal_range(Name)) {
 359     if (DWARFDie Die = toDie(Entry, DICtx))
 360       Dies.push_back(Die);
 361   }
 362 }
 363
 364 /// Print only DIEs that have a certain name.
 365 static void filterByAccelName(ArrayRef<std::string> Names, DWARFContext &DICtx,
 366                               raw_ostream &OS) {
 367   SmallVector<DWARFDie, 4> Dies;
 368   for (const auto &Name : Names) {
 369     getDies(DICtx, DICtx.getAppleNames(), Name, Dies);
 370     getDies(DICtx, DICtx.getAppleTypes(), Name, Dies);
 371     getDies(DICtx, DICtx.getAppleNamespaces(), Name, Dies);
 372     getDies(DICtx, DICtx.getDebugNames(), Name, Dies);
 373   }
 374   llvm::sort(Dies);
 375   Dies.erase(std::unique(Dies.begin(), Dies.end()), Dies.end());
 376
 377   for (DWARFDie Die : Dies)
 378     Die.dump(OS, 0, getDumpOpts());
 379 }
 380
 381 /// Handle the --lookup option and dump the DIEs and line info for the given
 382 /// address.
 383 static bool lookup(DWARFContext &DICtx, uint64_t Address, raw_ostream &OS) {
 384   auto DIEsForAddr = DICtx.getDIEsForAddress(Lookup);
 385
 386   if (!DIEsForAddr)
 387     return false;
 388
 389   DIDumpOptions DumpOpts = getDumpOpts();
 390   DumpOpts.RecurseDepth = 0;
 391   DIEsForAddr.CompileUnit->dump(OS, DumpOpts);
 392   if (DIEsForAddr.FunctionDIE) {
 393     DIEsForAddr.FunctionDIE.dump(OS, 2, DumpOpts);
 394     if (DIEsForAddr.BlockDIE)
 395       DIEsForAddr.BlockDIE.dump(OS, 4, DumpOpts);
 396   }
 397
 398   if (DILineInfo LineInfo = DICtx.getLineInfoForAddress(Lookup))
 399     LineInfo.dump(OS);
 400
 401   return true;
 402 }
 403
 404 bool collectStatsForObjectFile(ObjectFile &Obj, DWARFContext &DICtx,
 405                                Twine Filename, raw_ostream &OS);
 406
 407 static bool dumpObjectFile(ObjectFile &Obj, DWARFContext &DICtx, Twine Filename,
 408                            raw_ostream &OS) {
 409   logAllUnhandledErrors(DICtx.loadRegisterInfo(Obj), errs(),
 410                         Filename.str() + ": ");
 411   // The UUID dump already contains all the same information.
 412   if (!(DumpType & DIDT_UUID) || DumpType == DIDT_All)
 413     OS << Filename << ":\tfile format " << Obj.getFileFormatName() << '\n';
 414
 415   // Handle the --lookup option.
 416   if (Lookup)
 417     return lookup(DICtx, Lookup, OS);
 418
 419   // Handle the --name option.
 420   if (!Name.empty()) {
 421     StringSet<> Names;
 422     for (auto name : Name)
 423       Names.insert((IgnoreCase && !UseRegex) ? StringRef(name).lower() : name);
 424
 425     filterByName(Names, DICtx.normal_units(), OS);
 426     filterByName(Names, DICtx.dwo_units(), OS);
 427     return true;
 428   }
 429
 430   // Handle the --find option and lower it to --debug-info=<offset>.
 431   if (!Find.empty()) {
 432     filterByAccelName(Find, DICtx, OS);
 433     return true;
 434   }
 435
 436   // Dump the complete DWARF structure.
 437   DICtx.dump(OS, getDumpOpts(), DumpOffsets);
 438   return true;
 439 }
 440
 441 static bool verifyObjectFile(ObjectFile &Obj, DWARFContext &DICtx,
 442                              Twine Filename, raw_ostream &OS) {
 443   // Verify the DWARF and exit with non-zero exit status if verification
 444   // fails.
 445   raw_ostream &stream = Quiet ? nulls() : OS;
 446   stream << "Verifying " << Filename.str() << ":\tfile format "
 447   << Obj.getFileFormatName() << "\n";
 448   bool Result = DICtx.verify(stream, getDumpOpts());
 449   if (Result)
 450     stream << "No errors.\n";
 451   else
 452     stream << "Errors detected.\n";
 453   return Result;
 454 }
 455
 456 static bool handleBuffer(StringRef Filename, MemoryBufferRef Buffer,
 457                          HandlerFn HandleObj, raw_ostream &OS);
 458
 459 static bool handleArchive(StringRef Filename, Archive &Arch,
 460                           HandlerFn HandleObj, raw_ostream &OS) {
 461   bool Result = true;
 462   Error Err = Error::success();
 463   for (auto Child : Arch.children(Err)) {
 464     auto BuffOrErr = Child.getMemoryBufferRef();
 465     error(Filename, errorToErrorCode(BuffOrErr.takeError()));
 466     auto NameOrErr = Child.getName();
 467     error(Filename, errorToErrorCode(NameOrErr.takeError()));
 468     std::string Name = (Filename + "(" + NameOrErr.get() + ")").str();
 469     Result &= handleBuffer(Name, BuffOrErr.get(), HandleObj, OS);
 470   }
 471   error(Filename, errorToErrorCode(std::move(Err)));
 472
 473   return Result;
 474 }
 475
 476 static bool handleBuffer(StringRef Filename, MemoryBufferRef Buffer,
 477                          HandlerFn HandleObj, raw_ostream &OS) {
 478   Expected<std::unique_ptr<Binary>> BinOrErr = object::createBinary(Buffer);
 479   error(Filename, errorToErrorCode(BinOrErr.takeError()));
 480
 481   bool Result = true;
 482   if (auto *Obj = dyn_cast<ObjectFile>(BinOrErr->get())) {
 483     if (filterArch(*Obj)) {
 484       std::unique_ptr<DWARFContext> DICtx = DWARFContext::create(*Obj);
 485       Result = HandleObj(*Obj, *DICtx, Filename, OS);
 486     }
 487   }
 488   else if (auto *Fat = dyn_cast<MachOUniversalBinary>(BinOrErr->get()))
 489     for (auto &ObjForArch : Fat->objects()) {
 490       std::string ObjName =
 491           (Filename + "(" + ObjForArch.getArchFlagName() + ")").str();
 492       if (auto MachOOrErr = ObjForArch.getAsObjectFile()) {
 493         auto &Obj = **MachOOrErr;
 494         if (filterArch(Obj)) {
 495           std::unique_ptr<DWARFContext> DICtx = DWARFContext::create(Obj);
 496           Result &= HandleObj(Obj, *DICtx, ObjName, OS);
 497         }
 498         continue;
 499       } else
 500         consumeError(MachOOrErr.takeError());
 501       if (auto ArchiveOrErr = ObjForArch.getAsArchive()) {
 502         error(ObjName, errorToErrorCode(ArchiveOrErr.takeError()));
 503         Result &= handleArchive(ObjName, *ArchiveOrErr.get(), HandleObj, OS);
 504         continue;
 505       } else
 506         consumeError(ArchiveOrErr.takeError());
 507     }
 508   else if (auto *Arch = dyn_cast<Archive>(BinOrErr->get()))
 509     Result = handleArchive(Filename, *Arch, HandleObj, OS);
 510   return Result;
 511 }
 512
 513 static bool handleFile(StringRef Filename, HandlerFn HandleObj,
 514                        raw_ostream &OS) {
 515   ErrorOr<std::unique_ptr<MemoryBuffer>> BuffOrErr =
 516   MemoryBuffer::getFileOrSTDIN(Filename);
 517   error(Filename, BuffOrErr.getError());
 518   std::unique_ptr<MemoryBuffer> Buffer = std::move(BuffOrErr.get());
 519   return handleBuffer(Filename, *Buffer, HandleObj, OS);
 520 }
 521
 522 /// If the input path is a .dSYM bundle (as created by the dsymutil tool),
 523 /// replace it with individual entries for each of the object files inside the
 524 /// bundle otherwise return the input path.
 525 static std::vector<std::string> expandBundle(const std::string &InputPath) {
 526   std::vector<std::string> BundlePaths;
 527   SmallString<256> BundlePath(InputPath);
 528   // Normalize input path. This is necessary to accept `bundle.dSYM/`.
 529   sys::path::remove_dots(BundlePath);
 530   // Manually open up the bundle to avoid introducing additional dependencies.
 531   if (sys::fs::is_directory(BundlePath) &&
 532       sys::path::extension(BundlePath) == ".dSYM") {
 533     std::error_code EC;
 534     sys::path::append(BundlePath, "Contents", "Resources", "DWARF");
 535     for (sys::fs::directory_iterator Dir(BundlePath, EC), DirEnd;
 536          Dir != DirEnd && !EC; Dir.increment(EC)) {
 537       const std::string &Path = Dir->path();
 538       sys::fs::file_status Status;
 539       EC = sys::fs::status(Path, Status);
 540       error(Path, EC);
 541       switch (Status.type()) {
 542       case sys::fs::file_type::regular_file:
 543       case sys::fs::file_type::symlink_file:
 544       case sys::fs::file_type::type_unknown:
 545         BundlePaths.push_back(Path);
 546         break;
 547       default: /*ignore*/;
 548       }
 549     }
 550     error(BundlePath, EC);
 551   }
 552   if (!BundlePaths.size())
 553     BundlePaths.push_back(InputPath);
 554   return BundlePaths;
 555 }
 556
 557 int main(int argc, char **argv) {
 558   InitLLVM X(argc, argv);
 559
 560   llvm::InitializeAllTargetInfos();
 561   llvm::InitializeAllTargetMCs();
 562
 563   HideUnrelatedOptions({&DwarfDumpCategory, &SectionCategory, &ColorCategory});
 564   cl::ParseCommandLineOptions(
 565       argc, argv,
 566       "pretty-print DWARF debug information in object files"
 567       " and debug info archives.\n");
 568
 569   if (Help) {
 570     PrintHelpMessage(/*Hidden =*/false, /*Categorized =*/true);
 571     return 0;
 572   }
 573
 574   // FIXME: Audit interactions between these two options and make them
 575   //        compatible.
 576   if (Diff && Verbose) {
 577     WithColor::error() << "incompatible arguments: specifying both -diff and "
 578                           "-verbose is currently not supported";
 579     return 0;
 580   }
 581
 582   std::unique_ptr<ToolOutputFile> OutputFile;
 583   if (!OutputFilename.empty()) {
 584     std::error_code EC;
 585     OutputFile = llvm::make_unique<ToolOutputFile>(OutputFilename, EC,
 586                                                      sys::fs::F_None);
 587     error("Unable to open output file" + OutputFilename, EC);
 588     // Don't remove output file if we exit with an error.
 589     OutputFile->keep();
 590   }
 591
 592   raw_ostream &OS = OutputFile ? OutputFile->os() : outs();
 593   bool OffsetRequested = false;
 594
 595   // Defaults to dumping all sections, unless brief mode is specified in which
 596   // case only the .debug_info section in dumped.
 597 #define HANDLE_DWARF_SECTION(ENUM_NAME, ELF_NAME, CMDLINE_NAME)                \
 598   if (Dump##ENUM_NAME.IsRequested) {                                           \
 599     DumpType |= DIDT_##ENUM_NAME;                                              \
 600     if (Dump##ENUM_NAME.HasValue) {                                            \
 601       DumpOffsets[DIDT_ID_##ENUM_NAME] = Dump##ENUM_NAME.Val;                  \
 602       OffsetRequested = true;                                                  \
 603     }                                                                          \
 604   }
 605 #include "llvm/BinaryFormat/Dwarf.def"
 606 #undef HANDLE_DWARF_SECTION
 607   if (DumpUUID)
 608     DumpType |= DIDT_UUID;
 609   if (DumpAll)
 610     DumpType = DIDT_All;
 611   if (DumpType == DIDT_Null) {
 612     if (Verbose)
 613       DumpType = DIDT_All;
 614     else
 615       DumpType = DIDT_DebugInfo;
 616   }
 617
 618   // Unless dumping a specific DIE, default to --show-children.
 619   if (!ShowChildren && !Verify && !OffsetRequested && Name.empty() && Find.empty())
 620     ShowChildren = true;
 621
 622   // Defaults to a.out if no filenames specified.
 623   if (InputFilenames.empty())
 624     InputFilenames.push_back("a.out");
 625
 626   // Expand any .dSYM bundles to the individual object files contained therein.
 627   std::vector<std::string> Objects;
 628   for (const auto &F : InputFilenames) {
 629     auto Objs = expandBundle(F);
 630     Objects.insert(Objects.end(), Objs.begin(), Objs.end());
 631   }
 632
 633   if (Verify) {
 634     // If we encountered errors during verify, exit with a non-zero exit status.
 635     if (!all_of(Objects, [&](std::string Object) {
 636           return handleFile(Object, verifyObjectFile, OS);
 637         }))
 638       exit(1);
 639   } else if (Statistics)
 640     for (auto Object : Objects)
 641       handleFile(Object, collectStatsForObjectFile, OS);
 642   else
 643     for (auto Object : Objects)
 644       handleFile(Object, dumpObjectFile, OS);
 645
 646   return EXIT_SUCCESS;
 647 }