[llvm-objdump] Create ObjectFile specific dumpers

[MaskRay]

Summary

We pay the one-off boilerplate overhead to create *Dumper classes that derive
from objdump::Dumper a la llvm-readobj. This has two primary advantages.

First, a lot object file format specific code can be moved from
llvm-objdump.cpp to *Dump.cpp files. Refactor printPrivateHeaders as
an example.

Second, with the introduction of ELFDumper<ELFT>, we can simplify
a few dispatch functions in ELFDump.cpp.

In addition, the ObjectFile specific dumpers contains a ObjectFile specific
reference so that we can remove a lot of cast<*ObjectFile>(Obj).

[MaskRay]

drop an unneeded change. Change an instance in MachoDump.cpp

[mtrofin]

lgtm, some nits.

llvm/tools/llvm-objdump/COFFDump.cpp

40

(Comment for discussion, not blocking this patch) should ObjDumper be reused by both readobj and objdump - this was prompted by my going to initially suggest - also for a potential future patch - renaming Dumper to something more specific (like ObjDumper) - then realized the name was taken. Or maybe one could be ObjDumper and the other ReadObjDumper?

Anyway, this can go offline on discourse.

llvm/tools/llvm-objdump/ELFDump.cpp

44

does this buy much - looks like objdump::createELFDumper below would just look about the same, and (subjectively) even maybe a bit more clear?

[MaskRay]

Thanks for the review. There are recently a lot of XCOFF llvm-objdump patches and I unfortunately don't have much time reading them, but a pattern I noticed is that llvm-objdump.cpp gets more and more object file format specific functions, which is probably not a good sign.

I'll land this patch soon to hopefully help object file format specific functions reside in *Dump.cpp` files. I think @jhenderson would agree with the direction and am happy to address his post-commit suggestions.

llvm/tools/llvm-objdump/COFFDump.cpp

40

Thank you for bring up the topic. I prefer a different name Dumper for llvm-objdump because:

• llvm::ObjDumper is taken by llvm-readobj.
• We cannot reuse llvm::ObjDumper for llvm-objdump, so a separate class is needed.
• llvm::objdump::ObjDumper is probably not a good idea, considering that we do using namespace llvm;

Therefore, I picked llvm::objdump::Dumper for now.

Classes like ELFDumper in an unnamed namespace do not suffer ODR violation problems, so name collision is fine.

I agree that renaming llvm::ObjDumper to be something like llvm::ReadObjDumper or adding to a new namespace makes sense. That change should be a separate refactoring for llvm-readobj.

llvm/tools/llvm-objdump/ELFDump.cpp

44

This function is entirely used for the template argument deduction, so that I don't need to do return createDumper<Dumper<ELF32LE>>(*O); below, with the risk of making a template argument mistake...

[jhenderson]

I just got back from camping for the past week or so. Will take a look at this in the next few days.

[jhenderson]

This is definitely a big step in the right direction for llvm-objdump, in my opinion, and I look forward to further work in this area. My one concern with this patch is the Mach-O-specific parameter being passed into printPrivateHeaders, as that feels a bit ugly to me. I wonder if we could create the Mach-O dumper somehow with that parameter set in some manner? It would then no longer be a parameter of printPrivateHeaders that impacts all tools. Alternatively, there could be some other mechanism to give the dumper subclasses access to various configuration parameters.

llvm/tools/llvm-objdump/COFFDump.cpp

40

I'd love for there to be a way to share more llvm-readobj and llvm-objdump code. However, my suspicion is that it isn't that easy to do because the two have different outputs for most (all?) of their options, at least for ELF. Perhaps sharing a virtual interface, but having app-specific dumpers (which are then further specialized in some manner by file format) would be a nice thing, but I'm not sure how much it would give us.

Either way, llvm::objdump::Dumper seems like a reasonable name for me. We could make the llvm-readobj version llvm::readobj::Dumper and create a readobj namespace for similarity, but I don't think that bit is necessary.

[MaskRay]

In D155045#4532319, @jhenderson wrote:

This is definitely a big step in the right direction for llvm-objdump, in my opinion, and I look forward to further work in this area. My one concern with this patch is the Mach-O-specific parameter being passed into printPrivateHeaders, as that feels a bit ugly to me. I wonder if we could create the Mach-O dumper somehow with that parameter set in some manner? It would then no longer be a parameter of printPrivateHeaders that impacts all tools. Alternatively, there could be some other mechanism to give the dumper subclasses access to various configuration parameters.

Thank you for the comment! D.printPrivateHeaders(FirstPrivateHeader); is indeed hackish to get things done. I'll check how it can be improved.

llvm/tools/llvm-objdump/COFFDump.cpp

 using namespace llvm::Win64EH;
 
 namespace {
 template <typename T> struct EnumEntry {
   T Value;
   StringRef Name;
 };
 
-class COFFDumper {
+class COFFDumper : public Dumper {
 public:
-  explicit COFFDumper(const llvm::object::COFFObjectFile &Obj) : Obj(Obj) {
+  explicit COFFDumper(const llvm::object::COFFObjectFile &O)
+      : Dumper(O), Obj(O) {
     Is64 = !Obj.getPE32Header();
   }
 
   template <class PEHeader> void printPEHeader(const PEHeader &Hdr) const;
+  void printPrivateHeaders(bool MachOOnlyFirst) override;
 
 private:
   template <typename T> FormattedNumber formatAddr(T V) const {
     return format_hex_no_prefix(V, Is64 ? 16 : 8);
   }
 
   uint32_t getBaseOfData(const void *Hdr) const {
     return Is64 ? 0 : static_cast<const pe32_header *>(Hdr)->BaseOfData;
   }
 
   const llvm::object::COFFObjectFile &Obj;
   bool Is64;
 };
 } // namespace
 
+std::unique_ptr<Dumper>
+objdump::createCOFFDumper(const object::COFFObjectFile &Obj) {
+  return std::make_unique<COFFDumper>(Obj);
+}
+
 constexpr EnumEntry<uint16_t> PEHeaderMagic[] = {
     {uint16_t(COFF::PE32Header::PE32), "PE32"},
     {uint16_t(COFF::PE32Header::PE32_PLUS), "PE32+"},
 };
 
 constexpr EnumEntry<COFF::WindowsSubsystem> PEWindowsSubsystem[] = {
     {COFF::IMAGE_SUBSYSTEM_UNKNOWN, "unspecified"},
     {COFF::IMAGE_SUBSYSTEM_NATIVE, "NT native"},
void objdump::printCOFFUnwindInfo(const COFFObjectFile *Obj) {
 
   for (const RuntimeFunction &RF : RFs) {
     uint64_t SectionOffset =
         std::distance(RFs.begin(), &RF) * sizeof(RuntimeFunction);
     printRuntimeFunctionRels(Obj, RF, SectionOffset, Rels);
   }
 }
 
-void objdump::printCOFFFileHeader(const COFFObjectFile &Obj) {
+void COFFDumper::printPrivateHeaders(bool MachOOnlyFirst) {
   COFFDumper CD(Obj);
   const uint16_t Cha = Obj.getCharacteristics();
   outs() << "Characteristics 0x" << Twine::utohexstr(Cha) << '\n';
 #define FLAG(F, Name)                                                          \
   if (Cha & F)                                                                 \
     outs() << '\t' << Name << '\n';
   FLAG(COFF::IMAGE_FILE_RELOCS_STRIPPED, "relocations stripped");
   FLAG(COFF::IMAGE_FILE_EXECUTABLE_IMAGE, "executable");

llvm/tools/llvm-objdump/ELFDump.h

 namespace objdump {
 
 Error getELFRelocationValueString(const object::ELFObjectFileBase *Obj,
                                   const object::RelocationRef &Rel,
                                   llvm::SmallVectorImpl<char> &Result);
 uint64_t getELFSectionLMA(const object::ELFSectionRef &Sec);
 
 void printELFFileHeader(const object::ObjectFile *O);
-void printELFDynamicSection(const object::ObjectFile *Obj);
-void printELFSymbolVersionInfo(const object::ObjectFile *Obj);
 
 } // namespace objdump
 } // namespace llvm
 
 #endif

llvm/tools/llvm-objdump/ELFDump.cpp

 #include "llvm/Support/Format.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 using namespace llvm::object;
 using namespace llvm::objdump;
 
+namespace {
+template <typename ELFT> class ELFDumper : public Dumper {
+public:
+  ELFDumper(const ELFObjectFile<ELFT> &O) : Dumper(O), Obj(O) {}
+  void printPrivateHeaders(bool MachOOnlyFirst) override;
+
+private:
+  const ELFObjectFile<ELFT> &Obj;
+
+  const ELFFile<ELFT> &getELFFile() const { return Obj.getELFFile(); }
+  void printDynamicSection();
+  void printProgramHeaders();
+  void printSymbolVersion();
+};
+} // namespace
+
+template <class ELFT>
+static std::unique_ptr<Dumper> createDumper(const ELFObjectFile<ELFT> &Obj) {
+  return std::make_unique<ELFDumper<ELFT>>(Obj);
+}
+
+std::unique_ptr<Dumper>
+objdump::createELFDumper(const object::ELFObjectFileBase &Obj) {
+  if (const auto *O = dyn_cast<ELF32LEObjectFile>(&Obj))
+    return createDumper(*O);
+  if (const auto *O = dyn_cast<ELF32BEObjectFile>(&Obj))
+    return createDumper(*O);
+  if (const auto *O = dyn_cast<ELF64LEObjectFile>(&Obj))
+    return createDumper(*O);
+  return createDumper(cast<ELF64BEObjectFile>(Obj));
+}
+
 template <class ELFT>
 static Expected<StringRef> getDynamicStrTab(const ELFFile<ELFT> &Elf) {
   auto DynamicEntriesOrError = Elf.dynamicEntries();
   if (!DynamicEntriesOrError)
     return DynamicEntriesOrError.takeError();
 
   for (const typename ELFT::Dyn &Dyn : *DynamicEntriesOrError) {
     if (Dyn.d_tag == ELF::DT_STRTAB) {
uint64_t objdump::getELFSectionLMA(const object::ELFSectionRef &Sec) {
   else if (const auto *ELFObj = dyn_cast<ELF32BEObjectFile>(Sec.getObject()))
     return getSectionLMA(ELFObj->getELFFile(), Sec);
   else if (const auto *ELFObj = dyn_cast<ELF64LEObjectFile>(Sec.getObject()))
     return getSectionLMA(ELFObj->getELFFile(), Sec);
   const auto *ELFObj = cast<ELF64BEObjectFile>(Sec.getObject());
   return getSectionLMA(ELFObj->getELFFile(), Sec);
 }
 
-template <class ELFT>
-static void printDynamicSection(const ELFFile<ELFT> &Elf, StringRef Filename) {
+template <class ELFT> void ELFDumper<ELFT>::printDynamicSection() {
+  const ELFFile<ELFT> &Elf = getELFFile();
   auto DynamicEntriesOrErr = Elf.dynamicEntries();
   if (!DynamicEntriesOrErr) {
-    reportWarning(toString(DynamicEntriesOrErr.takeError()), Filename);
+    reportWarning(toString(DynamicEntriesOrErr.takeError()), Obj.getFileName());
     return;
   }
   ArrayRef<typename ELFT::Dyn> DynamicEntries = *DynamicEntriesOrErr;
 
   // Find the maximum tag name length to format the value column properly.
   size_t MaxLen = 0;
   for (const typename ELFT::Dyn &Dyn : DynamicEntries)
     MaxLen = std::max(MaxLen, Elf.getDynamicTagAsString(Dyn.d_tag).size());
if (Dyn.d_tag == ELF::DT_NEEDED || Dyn.d_tag == ELF::DT_RPATH ||
         Dyn.d_tag == ELF::DT_RUNPATH || Dyn.d_tag == ELF::DT_SONAME ||
         Dyn.d_tag == ELF::DT_AUXILIARY || Dyn.d_tag == ELF::DT_FILTER) {
       Expected<StringRef> StrTabOrErr = getDynamicStrTab(Elf);
       if (StrTabOrErr) {
         const char *Data = StrTabOrErr.get().data();
         outs() << (Data + Dyn.d_un.d_val) << "\n";
         continue;
       }
-      reportWarning(toString(StrTabOrErr.takeError()), Filename);
+      reportWarning(toString(StrTabOrErr.takeError()), Obj.getFileName());
       consumeError(StrTabOrErr.takeError());
     }
     outs() << format(Fmt, (uint64_t)Dyn.d_un.d_val);
   }
 }
 
-template <class ELFT>
-static void printProgramHeaders(const ELFFile<ELFT> &Obj, StringRef FileName) {
+template <class ELFT> void ELFDumper<ELFT>::printProgramHeaders() {
   outs() << "\nProgram Header:\n";
-  auto ProgramHeaderOrError = Obj.program_headers();
+  auto ProgramHeaderOrError = getELFFile().program_headers();
   if (!ProgramHeaderOrError) {
     reportWarning("unable to read program headers: " +
                       toString(ProgramHeaderOrError.takeError()),
-                  FileName);
+                  Obj.getFileName());
     return;
   }
 
   for (const typename ELFT::Phdr &Phdr : *ProgramHeaderOrError) {
     switch (Phdr.p_type) {
     case ELF::PT_DYNAMIC:
       outs() << " DYNAMIC ";
       break;
while (BufAux) {
       outs() << StringRef(StrTab.drop_front(Verdaux->vda_name).data()) << '\n';
       BufAux = Verdaux->vda_next ? BufAux + Verdaux->vda_next : nullptr;
       ++VerdauxIndex;
     }
     Buf = Verdef->vd_next ? Buf + Verdef->vd_next : nullptr;
   }
 }
 
-template <class ELFT>
-static void printSymbolVersionInfo(const ELFFile<ELFT> &Elf,
-                                   StringRef FileName) {
+template <class ELFT> void ELFDumper<ELFT>::printSymbolVersion() {
+  const ELFFile<ELFT> &Elf = getELFFile();
+  StringRef FileName = Obj.getFileName();
   ArrayRef<typename ELFT::Shdr> Sections =
       unwrapOrError(Elf.sections(), FileName);
   for (const typename ELFT::Shdr &Shdr : Sections) {
     if (Shdr.sh_type != ELF::SHT_GNU_verneed &&
         Shdr.sh_type != ELF::SHT_GNU_verdef)
       continue;
 
     ArrayRef<uint8_t> Contents =
         unwrapOrError(Elf.getSectionContents(Shdr), FileName);
     const typename ELFT::Shdr *StrTabSec =
         unwrapOrError(Elf.getSection(Shdr.sh_link), FileName);
     StringRef StrTab = unwrapOrError(Elf.getStringTable(*StrTabSec), FileName);
 
     if (Shdr.sh_type == ELF::SHT_GNU_verneed)
       printSymbolVersionDependency<ELFT>(FileName, Elf, Shdr);
     else
       printSymbolVersionDefinition<ELFT>(Shdr, Contents, StrTab);
   }
 }
 
-void objdump::printELFFileHeader(const object::ObjectFile *Obj) {
-  if (const auto *ELFObj = dyn_cast<ELF32LEObjectFile>(Obj))
-    printProgramHeaders(ELFObj->getELFFile(), Obj->getFileName());
-  else if (const auto *ELFObj = dyn_cast<ELF32BEObjectFile>(Obj))
-    printProgramHeaders(ELFObj->getELFFile(), Obj->getFileName());
-  else if (const auto *ELFObj = dyn_cast<ELF64LEObjectFile>(Obj))
-    printProgramHeaders(ELFObj->getELFFile(), Obj->getFileName());
-  else if (const auto *ELFObj = dyn_cast<ELF64BEObjectFile>(Obj))
-    printProgramHeaders(ELFObj->getELFFile(), Obj->getFileName());
-}
-
-void objdump::printELFDynamicSection(const object::ObjectFile *Obj) {
-  if (const auto *ELFObj = dyn_cast<ELF32LEObjectFile>(Obj))
-    printDynamicSection(ELFObj->getELFFile(), Obj->getFileName());
-  else if (const auto *ELFObj = dyn_cast<ELF32BEObjectFile>(Obj))
-    printDynamicSection(ELFObj->getELFFile(), Obj->getFileName());
-  else if (const auto *ELFObj = dyn_cast<ELF64LEObjectFile>(Obj))
-    printDynamicSection(ELFObj->getELFFile(), Obj->getFileName());
-  else if (const auto *ELFObj = dyn_cast<ELF64BEObjectFile>(Obj))
-    printDynamicSection(ELFObj->getELFFile(), Obj->getFileName());
-}
-
-void objdump::printELFSymbolVersionInfo(const object::ObjectFile *Obj) {
-  if (const auto *ELFObj = dyn_cast<ELF32LEObjectFile>(Obj))
-    printSymbolVersionInfo(ELFObj->getELFFile(), Obj->getFileName());
-  else if (const auto *ELFObj = dyn_cast<ELF32BEObjectFile>(Obj))
-    printSymbolVersionInfo(ELFObj->getELFFile(), Obj->getFileName());
-  else if (const auto *ELFObj = dyn_cast<ELF64LEObjectFile>(Obj))
-    printSymbolVersionInfo(ELFObj->getELFFile(), Obj->getFileName());
-  else if (const auto *ELFObj = dyn_cast<ELF64BEObjectFile>(Obj))
-    printSymbolVersionInfo(ELFObj->getELFFile(), Obj->getFileName());
+template <class ELFT> void ELFDumper<ELFT>::printPrivateHeaders(bool) {
+  printProgramHeaders();
+  printDynamicSection();
+  printSymbolVersion();
 }

llvm/tools/llvm-objdump/MachODump.cpp

bool operator()(const SymbolRef &A, const SymbolRef &B) {
     SymbolRef::Type BType = *BTypeOrErr;
     uint64_t AAddr =
         (AType != SymbolRef::ST_Function) ? 0 : cantFail(A.getValue());
     uint64_t BAddr =
         (BType != SymbolRef::ST_Function) ? 0 : cantFail(B.getValue());
     return AAddr < BAddr;
   }
 };
+
+class MachODumper : public Dumper {
+  const object::MachOObjectFile &Obj;
+
+public:
+  MachODumper(const object::MachOObjectFile &O) : Dumper(O), Obj(O) {}
+  void printPrivateHeaders(bool OnlyFirst) override;
+};
 } // namespace
 
+std::unique_ptr<Dumper>
+objdump::createMachODumper(const object::MachOObjectFile &Obj) {
+  return std::make_unique<MachODumper>(Obj);
+}
+
 // Types for the storted data in code table that is built before disassembly
 // and the predicate function to sort them.
 typedef std::pair<uint64_t, DiceRef> DiceTableEntry;
 typedef std::vector<DiceTableEntry> DiceTable;
 typedef DiceTable::iterator dice_table_iterator;
 
 #ifdef LLVM_HAVE_LIBXAR
 namespace {

 
 // ProcessMachO() is passed a single opened Mach-O file, which may be an
 // archive member and or in a slice of a universal file.  It prints the
 // the file name and header info and then processes it according to the
 // command line options.
 static void ProcessMachO(StringRef Name, MachOObjectFile *MachOOF,
                          StringRef ArchiveMemberName = StringRef(),
                          StringRef ArchitectureName = StringRef()) {
-  Dumper D(*MachOOF);
+  std::unique_ptr<Dumper> D = createMachODumper(*MachOOF);
+
   // If we are doing some processing here on the Mach-O file print the header
   // info.  And don't print it otherwise like in the case of printing the
   // UniversalHeaders or ArchiveHeaders.
   if (Disassemble || Relocations || PrivateHeaders || ExportsTrie || Rebase ||
       Bind || SymbolTable || LazyBind || WeakBind || IndirectSymbols ||
       DataInCode || FunctionStartsType != FunctionStartsMode::None ||
       LinkOptHints || ChainedFixups || DyldInfo || DylibsUsed || DylibId ||
       Rpaths || ObjcMetaData || (!FilterSections.empty())) {
if (DyldInfo)
     PrintDyldInfo(MachOOF);
   if (ChainedFixups)
     PrintChainedFixups(MachOOF);
   if (DylibsUsed)
     PrintDylibs(MachOOF, false);
   if (DylibId)
     PrintDylibs(MachOOF, true);
   if (SymbolTable)
-    D.printSymbolTable(ArchiveName, ArchitectureName);
+    D->printSymbolTable(ArchiveName, ArchitectureName);
   if (UnwindInfo)
     printMachOUnwindInfo(MachOOF);
   if (PrivateHeaders) {
     printMachOFileHeader(MachOOF);
     printMachOLoadCommands(MachOOF);
   }
   if (FirstPrivateHeader)
     printMachOFileHeader(MachOOF);
static void PrintMachHeader(const MachOObjectFile *Obj, bool verbose) {
   }
 }
 
 void objdump::printMachOFileHeader(const object::ObjectFile *Obj) {
   const MachOObjectFile *file = cast<const MachOObjectFile>(Obj);
   PrintMachHeader(file, Verbose);
 }
 
+void MachODumper::printPrivateHeaders(bool OnlyFirst) {
+  printMachOFileHeader(&Obj);
+  if (!OnlyFirst)
+    printMachOLoadCommands(&Obj);
+}
+
 void objdump::printMachOLoadCommands(const object::ObjectFile *Obj) {
   const MachOObjectFile *file = cast<const MachOObjectFile>(Obj);
   uint32_t filetype = 0;
   uint32_t cputype = 0;
   if (file->is64Bit()) {
     MachO::mach_header_64 H_64;
     H_64 = file->getHeader64();
     filetype = H_64.filetype;

llvm/tools/llvm-objdump/WasmDump.cpp

 #include "WasmDump.h"
 
 #include "llvm-objdump.h"
 #include "llvm/Object/Wasm.h"
 
 using namespace llvm;
 using namespace llvm::object;
 
-void objdump::printWasmFileHeader(const object::ObjectFile *Obj) {
-  const auto *File = cast<const WasmObjectFile>(Obj);
+namespace {
+class WasmDumper : public objdump::Dumper {
+  const WasmObjectFile &Obj;
+
+public:
+  WasmDumper(const WasmObjectFile &O) : Dumper(O), Obj(O) {}
+  void printPrivateHeaders(bool MachOOnlyFirst) override;
+};
+} // namespace
+
+std::unique_ptr<objdump::Dumper>
+objdump::createWasmDumper(const object::WasmObjectFile &Obj) {
+  return std::make_unique<WasmDumper>(Obj);
+}
 
+void WasmDumper::printPrivateHeaders(bool) {
   outs() << "Program Header:\n";
   outs() << "Version: 0x";
-  outs().write_hex(File->getHeader().Version);
+  outs().write_hex(Obj.getHeader().Version);
   outs() << "\n";
 }
 
 Error objdump::getWasmRelocationValueString(const WasmObjectFile *Obj,
                                             const RelocationRef &RelRef,
                                             SmallVectorImpl<char> &Result) {
   const wasm::WasmRelocation &Rel = Obj->getWasmRelocation(RelRef);
   symbol_iterator SI = RelRef.getSymbol();

llvm/tools/llvm-objdump/XCOFFDump.cpp

 #include "llvm/Support/FormattedStream.h"
 #include <algorithm>
 
 using namespace llvm;
 using namespace llvm::object;
 using namespace llvm::XCOFF;
 using namespace llvm::support;
 
+namespace {
+class XCOFFDumper : public objdump::Dumper {
+public:
+  XCOFFDumper(const object::XCOFFObjectFile &O) : Dumper(O) {}
+  void printPrivateHeaders(bool MachOOnlyFirst) override;
+};
+} // namespace
+
+std::unique_ptr<objdump::Dumper>
+objdump::createXCOFFDumper(const object::XCOFFObjectFile &Obj) {
+  return std::make_unique<XCOFFDumper>(Obj);
+}
+
+void XCOFFDumper::printPrivateHeaders(bool) {}
+
 Error objdump::getXCOFFRelocationValueString(const XCOFFObjectFile &Obj,
                                              const RelocationRef &Rel,
                                              SmallVectorImpl<char> &Result) {
   symbol_iterator SymI = Rel.getSymbol();
   if (SymI == Obj.symbol_end())
     return make_error<GenericBinaryError>(
         "invalid symbol reference in relocation entry",
         object_error::parse_failed);

llvm/tools/llvm-objdump/llvm-objdump.h

 #include "llvm/DebugInfo/DIContext.h"
 #include "llvm/MC/MCDisassembler/MCDisassembler.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/DataTypes.h"
 #include "llvm/Support/FormattedStream.h"
+#include <memory>
 
 namespace llvm {
 class StringRef;
 class Twine;
 
 namespace opt {
 class Arg;
 } // namespace opt
 
 namespace object {
 class RelocationRef;
 struct VersionEntry;
+
+class COFFObjectFile;
+class ELFObjectFileBase;
+class MachOObjectFile;
+class WasmObjectFile;
+class XCOFFObjectFile;
 } // namespace object
 
 namespace objdump {
 
 enum DebugVarsFormat { DVDisabled, DVUnicode, DVASCII, DVInvalid };
 
 extern bool ArchiveHeaders;
 extern int DbgIndent;

 extern StringSet<> FoundSectionSet;
 
 class Dumper {
   const object::ObjectFile &O;
   StringSet<> Warnings;
 
 public:
   Dumper(const object::ObjectFile &O) : O(O) {}
+  virtual ~Dumper() {}
 
   void reportUniqueWarning(Error Err);
   void reportUniqueWarning(const Twine &Msg);
 
+  virtual void printPrivateHeaders(bool MachOOnlyFirst);
   void printSymbolTable(StringRef ArchiveName,
                         StringRef ArchitectureName = StringRef(),
                         bool DumpDynamic = false);
   void printSymbol(const object::SymbolRef &Symbol,
                    ArrayRef<object::VersionEntry> SymbolVersions,
                    StringRef FileName, StringRef ArchiveName,
                    StringRef ArchitectureName, bool DumpDynamic);
   void printRelocations();
 };
 
+std::unique_ptr<Dumper> createCOFFDumper(const object::COFFObjectFile &Obj);
+std::unique_ptr<Dumper> createELFDumper(const object::ELFObjectFileBase &Obj);
+std::unique_ptr<Dumper> createMachODumper(const object::MachOObjectFile &Obj);
+std::unique_ptr<Dumper> createWasmDumper(const object::WasmObjectFile &Obj);
+std::unique_ptr<Dumper> createXCOFFDumper(const object::XCOFFObjectFile &Obj);
+
 // Various helper functions.
 
 /// Creates a SectionFilter with a standard predicate that conditionally skips
 /// sections when the --section objdump flag is provided.
 ///
 /// Idx is an optional output parameter that keeps track of which section index
 /// this is. This may be different than the actual section number, as some
 /// sections may be filtered (e.g. symbol tables).

llvm/tools/llvm-objdump/llvm-objdump.cpp

void Dumper::reportUniqueWarning(Error Err) {
   reportUniqueWarning(toString(std::move(Err)));
 }
 
 void Dumper::reportUniqueWarning(const Twine &Msg) {
   if (Warnings.insert(StringRef(Msg.str())).second)
     reportWarning(Msg, O.getFileName());
 }
 
+static Expected<std::unique_ptr<Dumper>> createDumper(const ObjectFile &Obj) {
+  if (const auto *O = dyn_cast<COFFObjectFile>(&Obj))
+    return createCOFFDumper(*O);
+  if (const auto *O = dyn_cast<ELFObjectFileBase>(&Obj))
+    return createELFDumper(*O);
+  if (const auto *O = dyn_cast<MachOObjectFile>(&Obj))
+    return createMachODumper(*O);
+  if (const auto *O = dyn_cast<WasmObjectFile>(&Obj))
+    return createWasmDumper(*O);
+  if (const auto *O = dyn_cast<XCOFFObjectFile>(&Obj))
+    return createXCOFFDumper(*O);
+
+  return createStringError(errc::invalid_argument,
+                           "unsupported object file format");
+}
+
 namespace {
 struct FilterResult {
   // True if the section should not be skipped.
   bool Keep;
 
   // True if the index counter should be incremented, even if the section should
   // be skipped. For example, sections may be skipped if they are not included
   // in the --section flag, but we still want those to count toward the section
static void printFaultMaps(const ObjectFile *Obj) {
   StringRef FaultMapContents =
       unwrapOrError(FaultMapSection->getContents(), Obj->getFileName());
   FaultMapParser FMP(FaultMapContents.bytes_begin(),
                      FaultMapContents.bytes_end());
 
   outs() << FMP;
 }
 
-static void printPrivateFileHeaders(const ObjectFile *O, bool OnlyFirst) {
-  if (O->isELF()) {
-    printELFFileHeader(O);
-    printELFDynamicSection(O);
-    printELFSymbolVersionInfo(O);
-    return;
-  }
-  if (O->isCOFF())
-    return printCOFFFileHeader(cast<object::COFFObjectFile>(*O));
-  if (O->isWasm())
-    return printWasmFileHeader(O);
-  if (O->isMachO()) {
-    printMachOFileHeader(O);
-    if (!OnlyFirst)
-      printMachOLoadCommands(O);
-    return;
-  }
-  reportError(O->getFileName(), "Invalid/Unsupported object file format");
+void Dumper::printPrivateHeaders(bool) {
+  reportError(O.getFileName(), "Invalid/Unsupported object file format");
 }
 
 static void printFileHeaders(const ObjectFile *O) {
   if (!O->isELF() && !O->isCOFF())
     reportError(O->getFileName(), "Invalid/Unsupported object file format");
 
   Triple::ArchType AT = O->getArch();
   outs() << "architecture: " << Triple::getArchTypeName(AT) << "\n";
else
     reportWarning("no section overlaps the range [0x" +
                       Twine::utohexstr(Start) + ",0x" + Twine::utohexstr(Stop) +
                       ") specified by --start-address/--stop-address",
                   Obj->getFileName());
 }
 
 static void dumpObject(ObjectFile *O, const Archive *A = nullptr,
                        const Archive::Child *C = nullptr) {
-  Dumper D(*O);
+  Expected<std::unique_ptr<Dumper>> DumperOrErr = createDumper(*O);
+  if (!DumperOrErr) {
+    reportError(DumperOrErr.takeError(), O->getFileName(),
+                A ? A->getFileName() : "");
+    return;
+  }
+  Dumper &D = **DumperOrErr;
 
   // Avoid other output when using a raw option.
   if (!RawClangAST) {
     outs() << '\n';
     if (A)
       outs() << A->getFileName() << "(" << O->getFileName() << ")";
     else
       outs() << O->getFileName();
     outs() << ":\tfile format " << O->getFileFormatName().lower() << "\n";
   }
 
   if (HasStartAddressFlag || HasStopAddressFlag)
     checkForInvalidStartStopAddress(O, StartAddress, StopAddress);
 
   // TODO: Change print* free functions to Dumper member functions to utilitize
   // stateful functions like reportUniqueWarning.
 
   // Note: the order here matches GNU objdump for compatability.
   StringRef ArchiveName = A ? A->getFileName() : "";
   if (ArchiveHeaders && !MachOOpt && C)
     printArchiveChild(ArchiveName, *C);
   if (FileHeaders)
     printFileHeaders(O);
   if (PrivateHeaders || FirstPrivateHeader)
-    printPrivateFileHeaders(O, FirstPrivateHeader);
+    D.printPrivateHeaders(FirstPrivateHeader);
   if (SectionHeaders)
     printSectionHeaders(*O);
   if (SymbolTable)
     D.printSymbolTable(ArchiveName);
   if (DynamicSymbolTable)
     D.printSymbolTable(ArchiveName, /*ArchitectureName=*/"",
                        /*DumpDynamic=*/true);
   if (DwarfDumpType != DIDT_Null) {