[llvm-objdump] Remove bool MachOOnlyFirst from printPrivateHeaders after D155045. NFC

[MaskRay]

Summary

Mach-O can just use the global variable FirstPrivateHeader.
If we ever manage to remove global variables, we can add a Config
variable to Dumper. Either case, the parameter is not needed.

[jhenderson]

Thanks! LGTM.

llvm/tools/llvm-objdump/COFFDump.cpp

 class COFFDumper : public Dumper {
 public:
   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;
+  void printPrivateHeaders() 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;
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 COFFDumper::printPrivateHeaders(bool MachOOnlyFirst) {
+void COFFDumper::printPrivateHeaders() {
   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.cpp

 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;
+  void printPrivateHeaders() override;
   void printDynamicRelocations() override;
 
 private:
   const ELFObjectFile<ELFT> &Obj;
 
   const ELFFile<ELFT> &getELFFile() const { return Obj.getELFFile(); }
   void printDynamicSection();
   void printProgramHeaders();
for (const typename ELFT::Shdr &Shdr : Sections) {
 
     if (Shdr.sh_type == ELF::SHT_GNU_verneed)
       printSymbolVersionDependency<ELFT>(FileName, Elf, Shdr);
     else
       printSymbolVersionDefinition<ELFT>(Shdr, Contents, StrTab);
   }
 }
 
-template <class ELFT> void ELFDumper<ELFT>::printPrivateHeaders(bool) {
+template <class ELFT> void ELFDumper<ELFT>::printPrivateHeaders() {
   printProgramHeaders();
   printDynamicSection();
   printSymbolVersion();
 }

llvm/tools/llvm-objdump/MachODump.cpp

struct SymbolSorter {
   }
 };
 
 class MachODumper : public Dumper {
   const object::MachOObjectFile &Obj;
 
 public:
   MachODumper(const object::MachOObjectFile &O) : Dumper(O), Obj(O) {}
-  void printPrivateHeaders(bool OnlyFirst) override;
+  void printPrivateHeaders() override;
 };
 } // namespace
 
 std::unique_ptr<Dumper>
 objdump::createMachODumper(const object::MachOObjectFile &Obj) {
   return std::make_unique<MachODumper>(Obj);
 }
 
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) {
+void MachODumper::printPrivateHeaders() {
   printMachOFileHeader(&Obj);
-  if (!OnlyFirst)
+  if (!FirstPrivateHeader)
     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()) {

llvm/tools/llvm-objdump/WasmDump.cpp

 using namespace llvm::object;
 
 namespace {
 class WasmDumper : public objdump::Dumper {
   const WasmObjectFile &Obj;
 
 public:
   WasmDumper(const WasmObjectFile &O) : Dumper(O), Obj(O) {}
-  void printPrivateHeaders(bool MachOOnlyFirst) override;
+  void printPrivateHeaders() override;
 };
 } // namespace
 
 std::unique_ptr<objdump::Dumper>
 objdump::createWasmDumper(const object::WasmObjectFile &Obj) {
   return std::make_unique<WasmDumper>(Obj);
 }
 
-void WasmDumper::printPrivateHeaders(bool) {
+void WasmDumper::printPrivateHeaders() {
   outs() << "Program Header:\n";
   outs() << "Version: 0x";
   outs().write_hex(Obj.getHeader().Version);
   outs() << "\n";
 }
 
 Error objdump::getWasmRelocationValueString(const WasmObjectFile *Obj,
                                             const RelocationRef &RelRef,

llvm/tools/llvm-objdump/XCOFFDump.cpp

 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;
+  void printPrivateHeaders() 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

 
 public:
   Dumper(const object::ObjectFile &O) : O(O) {}
   virtual ~Dumper() {}
 
   void reportUniqueWarning(Error Err);
   void reportUniqueWarning(const Twine &Msg);
 
-  virtual void printPrivateHeaders(bool MachOOnlyFirst);
+  virtual void printPrivateHeaders();
   virtual void printDynamicRelocations() {}
   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);

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

static void printFaultMaps(const ObjectFile *Obj) {
   StringRef FaultMapContents =
       unwrapOrError(FaultMapSection->getContents(), Obj->getFileName());
   FaultMapParser FMP(FaultMapContents.bytes_begin(),
                      FaultMapContents.bytes_end());
 
   outs() << FMP;
 }
 
-void Dumper::printPrivateHeaders(bool) {
+void Dumper::printPrivateHeaders() {
   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();
static void dumpObject(ObjectFile *O, const Archive *A = nullptr,
 
   // 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)
-    D.printPrivateHeaders(FirstPrivateHeader);
+    D.printPrivateHeaders();
   if (SectionHeaders)
     printSectionHeaders(*O);
   if (SymbolTable)
     D.printSymbolTable(ArchiveName);
   if (DynamicSymbolTable)
     D.printSymbolTable(ArchiveName, /*ArchitectureName=*/"",
                        /*DumpDynamic=*/true);
   if (DwarfDumpType != DIDT_Null) {