[dwarfdump] Add support for redirecting output to a file

[JDevlieghere]

Summary

This patch adds the -o and --out-file options for compatibility with
Darwin's dwarfdump.

[aprantl]

LGTM with inline comments addressed.
Thanks!

tools/llvm-dwarfdump/llvm-dwarfdump.cpp

134 ↗

(On Diff #116155)

Not a nativer speaker, but IMO "to the specified file" sounds marginally better.

332 ↗

(On Diff #116155)

I think this needs to come before error since error is noreturn?

[dblaikie]

tools/llvm-dwarfdump/llvm-dwarfdump.cpp

371 ↗

(On Diff #116155)

Just capture all by reference for locally scoped lambdas

llvm/trunk/test/tools/llvm-dwarfdump/X86/brief.s

 # RUN: llvm-mc %s -filetype obj -triple x86_64-apple-darwin -o - \
 # RUN: | llvm-dwarfdump --debug-info --debug-line - \
 # RUN: | FileCheck %s
+# RUN: llvm-mc %s -filetype obj -triple x86_64-apple-darwin -o - \
+# RUN: | llvm-dwarfdump --debug-info --debug-line - -o %t
+# RUN: cat %t | FileCheck %s
 
 # CHECK-NOT: .debug_abbrev contents:
 #
 # CHECK: .debug_info contents:
 # CHECK: DW_TAG_compile_unit
 # CHECK-NOT: DW_FORM
 # CHECK: DW_AT_name        ("brief.c")
 # CHECK: DW_AT_name      ("main")

llvm/trunk/tools/llvm-dwarfdump/llvm-dwarfdump.cpp

 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/TargetSelect.h"
+#include "llvm/Support/ToolOutputFile.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cstring>
 #include <string>
 #include <system_error>
 
 using namespace llvm;
 using namespace object;
ArchFilters("arch",
                 desc("Dump debug information for the specified CPU "
                      "architecture only. Architectures may be specified by "
                      "name or by number. This option can be specified "
                      "multiple times, once for each desired architecture."),
                 cat(DwarfDumpCategory));
 static opt<bool> DumpUUID("uuid", desc("Show the UUID for each architecture"),
                           cat(DwarfDumpCategory));
 static alias DumpUUIDAlias("u", desc("Alias for -uuid"), aliasopt(DumpUUID));
-
+static opt<std::string>
+    OutputFilename("out-file", cl::init(""),
+                   cl::desc("Redirect output to the specified file"),
+                   cl::value_desc("filename"));
+static alias OutputFilenameAlias("o", desc("Alias for -out-file"),
+                                 aliasopt(OutputFilename),
+                                 cat(DwarfDumpCategory));
 static opt<bool>
     ShowChildren("show-children",
                  desc("Show a debug info entry's children when selectively "
                       "printing with the =<offset> option"),
                  cat(DwarfDumpCategory));
 static alias ShowChildrenAlias("c", desc("Alias for -show-children"),
                                aliasopt(ShowChildren));
 static opt<bool>
static opt<bool> Verbose("verbose",
                          desc("Print more low-level encoding details"),
                          cat(DwarfDumpCategory));
 static alias VerboseAlias("v", desc("Alias for -verbose"), aliasopt(Verbose),
                           cat(DwarfDumpCategory));
 } // namespace
 /// @}
 //===----------------------------------------------------------------------===//
 
-
-static void error(StringRef Filename, std::error_code EC) {
+static void error(StringRef Prefix, std::error_code EC) {
   if (!EC)
     return;
-  errs() << Filename << ": " << EC.message() << "\n";
+  errs() << Prefix << ": " << EC.message() << "\n";
   exit(1);
 }
 
 static DIDumpOptions getDumpOpts() {
   DIDumpOptions DumpOpts;
   DumpOpts.DumpType = DumpType;
   DumpOpts.RecurseDepth = RecurseDepth;
   DumpOpts.ShowChildren = ShowChildren;
for (auto Arch : ArchFilters) {
       if (!StringRef(Arch).getAsInteger(0, Value))
         if (Value == getCPUType(*MachO))
           return true;
     }
   }
   return false;
 }
 
-using HandlerFn = std::function<bool(ObjectFile &, DWARFContext &DICtx, Twine)>;
+using HandlerFn = std::function<bool(ObjectFile &, DWARFContext &DICtx, Twine,
+                                     raw_ostream &)>;
 
-static bool dumpObjectFile(ObjectFile &Obj, DWARFContext &DICtx,
-                           Twine Filename) {
+static bool dumpObjectFile(ObjectFile &Obj, DWARFContext &DICtx, Twine Filename,
+                           raw_ostream &OS) {
   logAllUnhandledErrors(DICtx.loadRegisterInfo(Obj), errs(),
                         Filename.str() + ": ");
   // The UUID dump already contains all the same information.
   if (!(DumpType & DIDT_UUID) || DumpType == DIDT_All)
-    outs() << Filename << ":\tfile format " << Obj.getFileFormatName() << '\n';
+    OS << Filename << ":\tfile format " << Obj.getFileFormatName() << '\n';
 
   // Dump the complete DWARF structure.
-  DICtx.dump(outs(), getDumpOpts(), DumpOffsets);
+  DICtx.dump(OS, getDumpOpts(), DumpOffsets);
   return true;
 }
 
 static bool verifyObjectFile(ObjectFile &Obj, DWARFContext &DICtx,
-                             Twine Filename) {
+                             Twine Filename, raw_ostream &OS) {
   // Verify the DWARF and exit with non-zero exit status if verification
   // fails.
-  raw_ostream &stream = Quiet ? nulls() : outs();
+  raw_ostream &stream = Quiet ? nulls() : OS;
   stream << "Verifying " << Filename.str() << ":\tfile format "
   << Obj.getFileFormatName() << "\n";
   bool Result = DICtx.verify(stream, getDumpOpts());
   if (Result)
     stream << "No errors.\n";
   else
     stream << "Errors detected.\n";
   return Result;
 }
 
 static bool handleBuffer(StringRef Filename, MemoryBufferRef Buffer,
-                         HandlerFn HandleObj);
+                         HandlerFn HandleObj, raw_ostream &OS);
 
 static bool handleArchive(StringRef Filename, Archive &Arch,
-                          HandlerFn HandleObj) {
+                          HandlerFn HandleObj, raw_ostream &OS) {
   bool Result = true;
   Error Err = Error::success();
   for (auto Child : Arch.children(Err)) {
     auto BuffOrErr = Child.getMemoryBufferRef();
     error(Filename, errorToErrorCode(BuffOrErr.takeError()));
     auto NameOrErr = Child.getName();
     error(Filename, errorToErrorCode(NameOrErr.takeError()));
     std::string Name = (Filename + "(" + NameOrErr.get() + ")").str();
-    Result &= handleBuffer(Name, BuffOrErr.get(), HandleObj);
+    Result &= handleBuffer(Name, BuffOrErr.get(), HandleObj, OS);
   }
   error(Filename, errorToErrorCode(std::move(Err)));
 
   return Result;
 }
 
 static bool handleBuffer(StringRef Filename, MemoryBufferRef Buffer,
-                         HandlerFn HandleObj) {
+                         HandlerFn HandleObj, raw_ostream &OS) {
   Expected<std::unique_ptr<Binary>> BinOrErr = object::createBinary(Buffer);
   error(Filename, errorToErrorCode(BinOrErr.takeError()));
 
   bool Result = true;
   if (auto *Obj = dyn_cast<ObjectFile>(BinOrErr->get())) {
     if (filterArch(*Obj)) {
       std::unique_ptr<DWARFContext> DICtx = DWARFContext::create(*Obj);
-      Result = HandleObj(*Obj, *DICtx, Filename);
+      Result = HandleObj(*Obj, *DICtx, Filename, OS);
     }
   }
   else if (auto *Fat = dyn_cast<MachOUniversalBinary>(BinOrErr->get()))
     for (auto &ObjForArch : Fat->objects()) {
       std::string ObjName =
           (Filename + "(" + ObjForArch.getArchFlagName() + ")").str();
       if (auto MachOOrErr = ObjForArch.getAsObjectFile()) {
         auto &Obj = **MachOOrErr;
         if (filterArch(Obj)) {
           std::unique_ptr<DWARFContext> DICtx = DWARFContext::create(Obj);
-          Result &= HandleObj(Obj, *DICtx, ObjName);
+          Result &= HandleObj(Obj, *DICtx, ObjName, OS);
         }
         continue;
       } else
         consumeError(MachOOrErr.takeError());
       if (auto ArchiveOrErr = ObjForArch.getAsArchive()) {
         error(ObjName, errorToErrorCode(ArchiveOrErr.takeError()));
-        Result &= handleArchive(ObjName, *ArchiveOrErr.get(), HandleObj);
+        Result &= handleArchive(ObjName, *ArchiveOrErr.get(), HandleObj, OS);
         continue;
       } else
         consumeError(ArchiveOrErr.takeError());
     }
   else if (auto *Arch = dyn_cast<Archive>(BinOrErr->get()))
-    Result = handleArchive(Filename, *Arch, HandleObj);
+    Result = handleArchive(Filename, *Arch, HandleObj, OS);
   return Result;
 }
 
-static bool handleFile(StringRef Filename, HandlerFn HandleObj) {
+static bool handleFile(StringRef Filename, HandlerFn HandleObj,
+                       raw_ostream &OS) {
   ErrorOr<std::unique_ptr<MemoryBuffer>> BuffOrErr =
   MemoryBuffer::getFileOrSTDIN(Filename);
   error(Filename, BuffOrErr.getError());
   std::unique_ptr<MemoryBuffer> Buffer = std::move(BuffOrErr.get());
-  return handleBuffer(Filename, *Buffer, HandleObj);
+  return handleBuffer(Filename, *Buffer, HandleObj, OS);
 }
 
 /// If the input path is a .dSYM bundle (as created by the dsymutil tool),
 /// replace it with individual entries for each of the object files inside the
 /// bundle otherwise return the input path.
 static std::vector<std::string> expandBundle(const std::string &InputPath) {
   std::vector<std::string> BundlePaths;
   SmallString<256> BundlePath(InputPath);
cl::ParseCommandLineOptions(
       "pretty-print DWARF debug information in object files"
       " and debug info archives.\n");
 
   if (Help) {
     PrintHelpMessage(/*Hidden =*/false, /*Categorized =*/true);
     return 0;
   }
 
+  std::unique_ptr<tool_output_file> OutputFile;
+  if (!OutputFilename.empty()) {
+    std::error_code EC;
+    OutputFile =
+        make_unique<tool_output_file>(OutputFilename, EC, sys::fs::F_None);
+    error("Unable to open output file" + OutputFilename, EC);
+    // Don't remove output file if we exit with an error.
+    OutputFile->keep();
+  }
+
+  raw_ostream &OS = OutputFile ? OutputFile->os() : outs();
+
   // Defaults to dumping all sections, unless brief mode is specified in which
   // case only the .debug_info section in dumped.
 #define HANDLE_DWARF_SECTION(ENUM_NAME, ELF_NAME, CMDLINE_NAME)                \
   if (Dump##ENUM_NAME.IsRequested) {                                           \
     DumpType |= DIDT_##ENUM_NAME;                                              \
     if (Dump##ENUM_NAME.HasValue)                                              \
       DumpOffsets[DIDT_ID_##ENUM_NAME] = Dump##ENUM_NAME.Val;                  \
   }
#undef HANDLE_DWARF_SECTION
   std::vector<std::string> Objects;
   for (const auto &F : InputFilenames) {
     auto Objs = expandBundle(F);
     Objects.insert(Objects.end(), Objs.begin(), Objs.end());
   }
 
   if (Verify) {
     // If we encountered errors during verify, exit with a non-zero exit status.
-    if (!std::all_of(Objects.begin(), Objects.end(), [](std::string Object) {
-          return handleFile(Object, verifyObjectFile);
+    if (!std::all_of(Objects.begin(), Objects.end(), [&](std::string Object) {
+          return handleFile(Object, verifyObjectFile, OS);
         }))
       exit(1);
   } else
     for (auto Object : Objects)
-      handleFile(Object, dumpObjectFile);
+      handleFile(Object, dumpObjectFile, OS);
 
   return EXIT_SUCCESS;
 }