[dsymutil] Add support for outputting assembly

[JDevlieghere]

Summary

When implementing the DWARF accelerator tables in dsymutil I ran into an assertion in the assembler. Debugging these kind of issues is a lot easier when looking at the assembly instead of debugging the assembler itself. Since it's only a matter of creating an AsmStreamer instead of a MCObjectStreamer it made sense to turn this into a (hidden) dsymutil feature.

[friss]

I used this trick myself while developing llvm-dsymutil. Makes sense to make it easier to achieve.

[thegameg]

LGTM

llvm/trunk/test/tools/dsymutil/X86/assembly-output.test

+RUN: dsymutil -S -f -oso-prepend-path=%p/.. %p/../Inputs/basic.macho.x86_64 -o - | FileCheck %s
+
+CHECK:  .section __DWARF

llvm/trunk/tools/dsymutil/DwarfLinker.cpp

void DwarfLinker::reportWarning(const Twine &Warning, const DebugMapObject &DMO,
   DIE->dump(errs(), 6 /* Indent */, DumpOpts);
 }
 
 bool DwarfLinker::createStreamer(const Triple &TheTriple,
                                  raw_fd_ostream &OutFile) {
   if (Options.NoOutput)
     return true;
 
-  Streamer = llvm::make_unique<DwarfStreamer>(OutFile);
+  Streamer = llvm::make_unique<DwarfStreamer>(OutFile, Options);
   return Streamer->init(TheTriple);
 }
 
 /// Recursive helper to build the global DeclContext information and
 /// gather the child->parent relationships in the original compile unit.
 ///
 /// \return true when this DIE and all of its children are only
 /// forward declarations to types defined in external clang modules
for (unsigned i = 0, e = NumObjects; i != e; ++i) {
       // Then mark all the DIEs that need to be present in the linked output
       // and collect some information about them.
       // Note that this loop can not be merged with the previous one because
       // cross-cu references require the ParentIdx to be setup for every CU in
       // the object file before calling this.
       if (LLVM_UNLIKELY(Options.Update)) {
         for (auto &CurrentUnit : LinkContext.CompileUnits)
           CurrentUnit->markEverythingAsKept();
-        Streamer->copyInvariantDebugSection(*LinkContext.ObjectFile, Options);
+        Streamer->copyInvariantDebugSection(*LinkContext.ObjectFile);
       } else {
         for (auto &CurrentUnit : LinkContext.CompileUnits)
           lookForDIEsToKeep(LinkContext.RelocMgr, LinkContext.Ranges,
                             LinkContext.CompileUnits,
                             CurrentUnit->getOrigUnit().getUnitDIE(),
                             LinkContext.DMO, *CurrentUnit, 0);
       }
 

llvm/trunk/tools/dsymutil/DwarfStreamer.h

 //===- tools/dsymutil/DwarfStreamer.h - Dwarf Streamer ----------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "CompileUnit.h"
 #include "DebugMap.h"
+#include "LinkUtils.h"
 #include "NonRelocatableStringpool.h"
 #include "llvm/CodeGen/AccelTable.h"
 #include "llvm/CodeGen/AsmPrinter.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugLine.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugRangeList.h"
 #include "llvm/MC/MCAsmBackend.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCCodeEmitter.h"

 #include "llvm/Target/TargetOptions.h"
 
 #ifndef LLVM_TOOLS_DSYMUTIL_DWARFSTREAMER_H
 #define LLVM_TOOLS_DSYMUTIL_DWARFSTREAMER_H
 
 namespace llvm {
 namespace dsymutil {
 
-struct LinkOptions;
-
 /// The Dwarf streaming logic.
 ///
 /// All interactions with the MC layer that is used to build the debug
 /// information binary representation are handled in this class.
 class DwarfStreamer {
 public:
-  DwarfStreamer(raw_fd_ostream &OutFile) : OutFile(OutFile) {}
+  DwarfStreamer(raw_fd_ostream &OutFile, LinkOptions Options)
+      : OutFile(OutFile), Options(std::move(Options)) {}
+
   bool init(Triple TheTriple);
 
   /// Dump the file to the disk.
   bool finish(const DebugMap &);
 
   AsmPrinter &getAsmPrinter() const { return *Asm; }
 
   /// Set the current output section to debug_info and change
public:
 
   /// Emit the line table described in \p Rows into the debug_line section.
   void emitLineTableForUnit(MCDwarfLineTableParams Params,
                             StringRef PrologueBytes, unsigned MinInstLength,
                             std::vector<DWARFDebugLine::Row> &Rows,
                             unsigned AdddressSize);
 
   /// Copy over the debug sections that are not modified when updating.
-  void copyInvariantDebugSection(const object::ObjectFile &Obj, LinkOptions &);
+  void copyInvariantDebugSection(const object::ObjectFile &Obj);
 
   uint32_t getLineSectionSize() const { return LineSectionSize; }
 
   /// Emit the .debug_pubnames contribution for \p Unit.
   void emitPubNamesForUnit(const CompileUnit &Unit);
 
   /// Emit the .debug_pubtypes contribution for \p Unit.
   void emitPubTypesForUnit(const CompileUnit &Unit);
private:
   /// @{
   std::unique_ptr<MCRegisterInfo> MRI;
   std::unique_ptr<MCAsmInfo> MAI;
   std::unique_ptr<MCObjectFileInfo> MOFI;
   std::unique_ptr<MCContext> MC;
   MCAsmBackend *MAB; // Owned by MCStreamer
   std::unique_ptr<MCInstrInfo> MII;
   std::unique_ptr<MCSubtargetInfo> MSTI;
+  MCInstPrinter *MIP; // Owned by AsmPrinter
   MCCodeEmitter *MCE; // Owned by MCStreamer
   MCStreamer *MS;     // Owned by AsmPrinter
   std::unique_ptr<TargetMachine> TM;
   std::unique_ptr<AsmPrinter> Asm;
   /// @}
 
   /// The file we stream the linked Dwarf to.
   raw_fd_ostream &OutFile;
 
+  LinkOptions Options;
+
   uint32_t RangesSectionSize;
   uint32_t LocSectionSize;
   uint32_t LineSectionSize;
   uint32_t FrameSectionSize;
 
   /// Emit the pubnames or pubtypes section contribution for \p
   /// Unit into \p Sec. The data is provided in \p Names.
   void emitPubSectionForUnit(MCSection *Sec, StringRef Name,
                              const CompileUnit &Unit,
                              const std::vector<CompileUnit::AccelInfo> &Names);
 };
 
 } // end namespace dsymutil
 } // end namespace llvm
 
 #endif // LLVM_TOOLS_DSYMUTIL_DWARFSTREAMER_H

llvm/trunk/tools/dsymutil/DwarfStreamer.cpp

bool DwarfStreamer::init(Triple TheTriple) {
   MOFI.reset(new MCObjectFileInfo);
   MC.reset(new MCContext(MAI.get(), MRI.get(), MOFI.get()));
   MOFI->InitMCObjectFileInfo(TheTriple, /*PIC*/ false, *MC);
 
   MSTI.reset(TheTarget->createMCSubtargetInfo(TripleName, "", ""));
   if (!MSTI)
     return error("no subtarget info for target " + TripleName, Context);
 
-  MCTargetOptions Options;
-  MAB = TheTarget->createMCAsmBackend(*MSTI, *MRI, Options);
+  MCTargetOptions MCOptions = InitMCTargetOptionsFromFlags();
+  MAB = TheTarget->createMCAsmBackend(*MSTI, *MRI, MCOptions);
   if (!MAB)
     return error("no asm backend for target " + TripleName, Context);
 
   MII.reset(TheTarget->createMCInstrInfo());
   if (!MII)
     return error("no instr info info for target " + TripleName, Context);
 
   MCE = TheTarget->createMCCodeEmitter(*MII, *MRI, *MC);
   if (!MCE)
     return error("no code emitter for target " + TripleName, Context);
 
-  MCTargetOptions MCOptions = InitMCTargetOptionsFromFlags();
+  switch (Options.FileType) {
+  case OutputFileType::Assembly: {
+    MIP = TheTarget->createMCInstPrinter(TheTriple, MAI->getAssemblerDialect(),
+                                         *MAI, *MII, *MRI);
+    MS = TheTarget->createAsmStreamer(
+        *MC, llvm::make_unique<formatted_raw_ostream>(OutFile), true, true, MIP,
+        std::unique_ptr<MCCodeEmitter>(MCE), std::unique_ptr<MCAsmBackend>(MAB),
+        true);
+    break;
+  }
+  case OutputFileType::Object: {
     MS = TheTarget->createMCObjectStreamer(
         TheTriple, *MC, std::unique_ptr<MCAsmBackend>(MAB),
         MAB->createObjectWriter(OutFile), std::unique_ptr<MCCodeEmitter>(MCE),
         *MSTI, MCOptions.MCRelaxAll, MCOptions.MCIncrementalLinkerCompatible,
         /*DWARFMustBeAtTheEnd*/ false);
+    break;
+  }
+  }
+
   if (!MS)
     return error("no object streamer for target " + TripleName, Context);
 
   // Finally create the AsmPrinter we'll use to emit the DIEs.
   TM.reset(TheTarget->createTargetMachine(TripleName, "", "", TargetOptions(),
                                           None));
   if (!TM)
     return error("no target machine for target " + TripleName, Context);
 
   Asm.reset(TheTarget->createAsmPrinter(*TM, std::unique_ptr<MCStreamer>(MS)));
   if (!Asm)
     return error("no asm printer for target " + TripleName, Context);
 
   RangesSectionSize = 0;
   LocSectionSize = 0;
   LineSectionSize = 0;
   FrameSectionSize = 0;
 
   return true;
 }
 
 bool DwarfStreamer::finish(const DebugMap &DM) {
   bool Result = true;
-  if (DM.getTriple().isOSDarwin() && !DM.getBinaryPath().empty())
+  if (DM.getTriple().isOSDarwin() && !DM.getBinaryPath().empty() &&
+      Options.FileType == OutputFileType::Object)
     Result = MachOUtils::generateDsymCompanion(DM, *MS, OutFile);
   else
     MS->Finish();
   return Result;
 }
 
 void DwarfStreamer::switchToDebugInfoSection(unsigned DwarfVersion) {
   MS->SwitchSection(MOFI->getDwarfInfoSection());

 static void emitSectionContents(const object::ObjectFile &Obj,
                                 StringRef SecName, MCStreamer *MS) {
   StringRef Contents;
   if (auto Sec = getSectionByName(Obj, SecName))
     if (!Sec->getContents(Contents))
       MS->EmitBytes(Contents);
 }
 
-void DwarfStreamer::copyInvariantDebugSection(const object::ObjectFile &Obj,
-                                              LinkOptions &Options) {
+void DwarfStreamer::copyInvariantDebugSection(const object::ObjectFile &Obj) {
   MS->SwitchSection(MC->getObjectFileInfo()->getDwarfLineSection());
   emitSectionContents(Obj, "debug_line", MS);
 
   MS->SwitchSection(MC->getObjectFileInfo()->getDwarfLocSection());
   emitSectionContents(Obj, "debug_loc", MS);
 
   MS->SwitchSection(MC->getObjectFileInfo()->getDwarfRangesSection());
   emitSectionContents(Obj, "debug_ranges", MS);

llvm/trunk/tools/dsymutil/LinkUtils.h

 
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/WithColor.h"
 #include <string>
 
 namespace llvm {
 namespace dsymutil {
 
+enum class OutputFileType {
+  Object,
+  Assembly,
+};
+
 struct LinkOptions {
   /// Verbosity
   bool Verbose = false;
 
   /// Skip emitting output
   bool NoOutput = false;
 
   /// Do not unique types according to ODR
   bool NoODR = false;
 
   /// Update
   bool Update = false;
 
   /// Minimize
   bool Minimize = false;
 
   /// Do not check swiftmodule timestamp
   bool NoTimestamp = false;
 
   /// Number of threads.
   unsigned Threads = 1;
 
+  // Output file type.
+  OutputFileType FileType = OutputFileType::Object;
+
   /// -oso-prepend-path
   std::string PrependPath;
 
   LinkOptions() = default;
 };
 
 inline void warn(Twine Warning, Twine Context = {}) {
   WithColor::warning() << Warning + "\n";

llvm/trunk/tools/dsymutil/dsymutil.cpp

OutputFileOpt("o",
                   desc("Specify the output file. default: <input file>.dwarf"),
                   value_desc("filename"), cat(DsymCategory));
 
 static opt<std::string> OsoPrependPath(
     "oso-prepend-path",
     desc("Specify a directory to prepend to the paths of object files."),
     value_desc("path"), cat(DsymCategory));
 
+static opt<bool> Assembly(
+    "S",
+    desc("Output textual assembly instead of a binary dSYM companion file."),
+    init(false), cat(DsymCategory), cl::Hidden);
+
 static opt<bool> DumpStab(
     "symtab",
     desc("Dumps the symbol table found in executable or object file(s) and\n"
          "exits."),
     init(false), cat(DsymCategory));
 static alias DumpStabA("s", desc("Alias for --symtab"), aliasopt(DumpStab));
 
 static opt<bool> FlatOut("flat",
static Expected<LinkOptions> getOptions() {
   Options.Verbose = Verbose;
   Options.NoOutput = NoOutput;
   Options.NoODR = NoODR;
   Options.Minimize = Minimize;
   Options.Update = Update;
   Options.NoTimestamp = NoTimestamp;
   Options.PrependPath = OsoPrependPath;
 
+  if (Assembly)
+    Options.FileType = OutputFileType::Assembly;
+
   if (Options.Update && std::find(InputFiles.begin(), InputFiles.end(), "-") !=
                             InputFiles.end()) {
     // FIXME: We cannot use stdin for an update because stdin will be
     // consumed by the BinaryHolder during the debugmap parsing, and
     // then we will want to consume it again in DwarfLinker. If we
     // used a unique BinaryHolder object that could cache multiple
     // binaries this restriction would go away.
     return make_error<StringError>(