[DWARF] Introduce Dump Options

[sgravani]

Summary

I'm working on making the llvm-dwarfdump output more flexible, e.g. adding verbose, brief mode etc.
This commit introduces a structure that holds all the flags that control the pretty printing of dwarf output.

[dblaikie]

include/llvm/DebugInfo/DIContext.h

155

Use non-static data member initializers rather than a user-defined ctor.

tools/llvm-dwarfdump/llvm-dwarfdump.cpp

99

Doubt the comment needs to change - the code seems pretty self explanatory.

tools/llvm-objdump/MachODump.cpp

1273

similarly here (code seems self explanatory)

Though, equally, in this and the toher case, you could use: '{DwarfDumpType, true /* DumpEH */, false /* SummarizeTypes */}" if you like

tools/llvm-objdump/llvm-objdump.cpp

2066

similarly here

[sgravani]

1. Replace user-defined ctor with non-static member initializers for struct DIDumpOptions.
2. Revert comments for dumping the complete DWARF structure to their initial form.

[aprantl]

Thanks. I can commit this for you.

include/llvm/DebugInfo/DIContext.h

enum DIDumpType {
   DIDT_AppleTypes,
   DIDT_AppleNamespaces,
   DIDT_AppleObjC,
   DIDT_CUIndex,
   DIDT_GdbIndex,
   DIDT_TUIndex,
 };
 
+/// DIDumpOptions - container for dump options that control which debug information will be dumped
+struct DIDumpOptions {
+    DIDumpType DumpType;
+    bool DumpEH;
+    bool SummarizeTypes;
+
+    DIDumpOptions() : DumpType(DIDT_All), DumpEH(false), SummarizeTypes(false) {}
+};
+
 class DIContext {
 public:
   enum DIContextKind {
     CK_DWARF,
     CK_PDB
   };
 
   DIContext(DIContextKind K) : Kind(K) {}
   virtual ~DIContext() = default;
 
   DIContextKind getKind() const { return Kind; }
 
-  virtual void dump(raw_ostream &OS, DIDumpType DumpType = DIDT_All,
-                    bool DumpEH = false, bool SummarizeTypes = false) = 0;
+  virtual void dump(raw_ostream &OS, DIDumpOptions DumpOpts) = 0;
 
   virtual bool verify(raw_ostream &OS, DIDumpType DumpType = DIDT_All) {
     // No verifier? Just say things went well.
     return true;
   }
   virtual DILineInfo getLineInfoForAddress(uint64_t Address,
       DILineInfoSpecifier Specifier = DILineInfoSpecifier()) = 0;
   virtual DILineInfoTable getLineInfoForAddressRange(uint64_t Address,

include/llvm/DebugInfo/DWARF/DWARFContext.h

public:
   DWARFContext() : DIContext(CK_DWARF) {}
   DWARFContext(DWARFContext &) = delete;
   DWARFContext &operator=(DWARFContext &) = delete;
 
   static bool classof(const DIContext *DICtx) {
     return DICtx->getKind() == CK_DWARF;
   }
 
-  void dump(raw_ostream &OS, DIDumpType DumpType = DIDT_All,
-            bool DumpEH = false, bool SummarizeTypes = false) override;
+  void dump(raw_ostream &OS, DIDumpOptions DumpOpts) override;
 
   bool verify(raw_ostream &OS, DIDumpType DumpType = DIDT_All) override;
 
   typedef DWARFUnitSection<DWARFCompileUnit>::iterator_range cu_iterator_range;
   typedef DWARFUnitSection<DWARFTypeUnit>::iterator_range tu_iterator_range;
   typedef iterator_range<decltype(TUs)::iterator> tu_section_iterator_range;
 
   /// Get compile units in this context.

include/llvm/DebugInfo/PDB/PDBContext.h

PDBContext(const object::COFFObjectFile &Object,
                std::unique_ptr<IPDBSession> PDBSession);
     PDBContext(PDBContext &) = delete;
     PDBContext &operator=(PDBContext &) = delete;
 
     static bool classof(const DIContext *DICtx) {
       return DICtx->getKind() == CK_PDB;
     }
 
-    void dump(raw_ostream &OS, DIDumpType DumpType = DIDT_All,
-              bool DumpEH = false, bool SummarizeTypes = false) override;
+    void dump(raw_ostream &OS, DIDumpOptions DIDumpOpts) override;
 
     DILineInfo getLineInfoForAddress(
         uint64_t Address,
         DILineInfoSpecifier Specifier = DILineInfoSpecifier()) override;
     DILineInfoTable getLineInfoForAddressRange(
         uint64_t Address, uint64_t Size,
         DILineInfoSpecifier Specifier = DILineInfoSpecifier()) override;
     DIInliningInfo getInliningInfoForAddress(

lib/DebugInfo/DWARF/DWARFContext.cpp

static void dumpAccelSection(raw_ostream &OS, StringRef Name,
   DataExtractor StrData(StringSection, LittleEndian, 0);
   OS << "\n." << Name << " contents:\n";
   DWARFAcceleratorTable Accel(AccelSection, StrData, Section.Relocs);
   if (!Accel.extract())
     return;
   Accel.dump(OS);
 }
 
-void DWARFContext::dump(raw_ostream &OS, DIDumpType DumpType, bool DumpEH,
-                        bool SummarizeTypes) {
+void DWARFContext::dump(raw_ostream &OS, DIDumpOptions DumpOpts){
+
+  DIDumpType DumpType = DumpOpts.DumpType;
+  bool DumpEH = DumpOpts.DumpEH;
+  bool SummarizeTypes = DumpOpts.SummarizeTypes;
+
   if (DumpType == DIDT_All || DumpType == DIDT_Abbrev) {
     OS << ".debug_abbrev contents:\n";
     getDebugAbbrev()->dump(OS);
   }
 
   if (DumpType == DIDT_All || DumpType == DIDT_AbbrevDwo)
     if (const DWARFDebugAbbrev *D = getDebugAbbrevDWO()) {
       OS << "\n.debug_abbrev.dwo contents:\n";

lib/DebugInfo/PDB/PDBContext.cpp

 PDBContext::PDBContext(const COFFObjectFile &Object,
                        std::unique_ptr<IPDBSession> PDBSession)
     : DIContext(CK_PDB), Session(std::move(PDBSession)) {
   ErrorOr<uint64_t> ImageBase = Object.getImageBase();
   if (ImageBase)
     Session->setLoadAddress(ImageBase.get());
 }
 
-void PDBContext::dump(raw_ostream &OS, DIDumpType DumpType, bool DumpEH,
-                      bool SummarizeTypes) {}
+void PDBContext::dump(raw_ostream &OS, DIDumpOptions DumpOpts){}
 
 DILineInfo PDBContext::getLineInfoForAddress(uint64_t Address,
                                              DILineInfoSpecifier Specifier) {
   DILineInfo Result;
   Result.FunctionName = getFunctionName(Address, Specifier.FNKind);
 
   uint32_t Length = 1;
   std::unique_ptr<PDBSymbol> Symbol =

tools/llvm-dwarfdump/llvm-dwarfdump.cpp

static void error(StringRef Filename, std::error_code EC) {
   exit(1);
 }
 
 static void DumpObjectFile(ObjectFile &Obj, Twine Filename) {
   std::unique_ptr<DIContext> DICtx(new DWARFContextInMemory(Obj));
 
   outs() << Filename.str() << ":\tfile format " << Obj.getFileFormatName()
          << "\n\n";
-  // Dump the complete DWARF structure.
-  DICtx->dump(outs(), DumpType, false, SummarizeTypes);
+
+  // Dump the DWARF structure. DumpOpts controls the information to be dumped.
+  DIDumpOptions DumpOpts;
+  DumpOpts.DumpType = DumpType;
+  DumpOpts.SummarizeTypes = SummarizeTypes;       
+  DICtx->dump(outs(), DumpOpts);
 }
 
 static void DumpInput(StringRef Filename) {
   ErrorOr<std::unique_ptr<MemoryBuffer>> BuffOrErr =
       MemoryBuffer::getFileOrSTDIN(Filename);
   error(Filename, BuffOrErr.getError());
   std::unique_ptr<MemoryBuffer> Buff = std::move(BuffOrErr.get());
 

tools/llvm-objdump/MachODump.cpp

if (Bind)
     printBindTable(MachOOF);
   if (LazyBind)
     printLazyBindTable(MachOOF);
   if (WeakBind)
     printWeakBindTable(MachOOF);
 
   if (DwarfDumpType != DIDT_Null) {
     std::unique_ptr<DIContext> DICtx(new DWARFContextInMemory(*MachOOF));
-    // Dump the complete DWARF structure.
-    DICtx->dump(outs(), DwarfDumpType, true /* DumpEH */);
+    // Dump the DWARF structure. DumpOpts controls the information to be dumped.
+    DIDumpOptions DumpOpts;
+    DumpOpts.DumpType = DwarfDumpType;
+    DumpOpts.DumpEH = true;
+    DICtx->dump(outs(), DumpOpts);
   }
 }
 
 // printUnknownCPUType() helps print_fat_headers for unknown CPU's.
 static void printUnknownCPUType(uint32_t cputype, uint32_t cpusubtype) {
   outs() << "    cputype (" << cputype << ")\n";
   outs() << "    cpusubtype (" << cpusubtype << ")\n";
 }

tools/llvm-objdump/llvm-objdump.cpp

static void DumpObject(ObjectFile *o, const Archive *a = nullptr) {
   if (WeakBind)
     printWeakBindTable(o);
   if (RawClangAST)
     printRawClangAST(o);
   if (PrintFaultMaps)
     printFaultMaps(o);
   if (DwarfDumpType != DIDT_Null) {
     std::unique_ptr<DIContext> DICtx(new DWARFContextInMemory(*o));
-    // Dump the complete DWARF structure.
-    DICtx->dump(outs(), DwarfDumpType, true /* DumpEH */);
+    // Dump the DWARF structure. DumpOpts controls the information to be dumped.
+    DIDumpOptions DumpOpts;
+    DumpOpts.DumpType = DwarfDumpType;
+    DumpOpts.DumpEH = true;
+    DICtx->dump(outs(), DumpOpts);
   }
 }
 
 static void DumpObject(const COFFImportFile *I, const Archive *A) {
   StringRef ArchiveName = A ? A->getFileName() : "";
 
   // Avoid other output when using a raw option.
   if (!RawClangAST)