[NFC] add new function is64Bit for SymbolicFile class

[DiggerLin]

Summary

since the class 'SymbolicFile ' do not have a is64Bit() API , when we need to check whether a SymbolicFile object is 64bit or not. we need to write a function to do it, it maybe cause duplication code.

[DiggerLin]

run git format

[jhenderson]

Some nits, but this basically looks fine so far. Do we have testing that exercises each of the new methods?

llvm/include/llvm/Object/MachO.h

740

I'm not sure there's a need to move the declaration?

llvm/include/llvm/Object/SymbolicFile.h

161

I think it would be better to make this a pure virtual function and force every implementation to specify the bitness of the object file (even if it's always 32-bit). Otherwise, when a new format comes along, it would be easy to forget to implement this function.

llvm/include/llvm/Object/TapiFile.h

51–53

Please leave these methods in the order they were in before.

[DiggerLin]

address comment .

[MaskRay]

llvm/include/llvm/Object/SymbolicFile.h

161

This can be marked done now.

llvm/include/llvm/Object/TapiFile.h

51–53

This can be marked done now.

[jhenderson]

LGTM too.

[DiggerLin]

llvm/include/llvm/Object/MachO.h

740

just move the all the override API together.

llvm/include/llvm/Object/COFF.h

void getRelocationTypeName(DataRefImpl Rel,
                              SmallVectorImpl<char> &Result) const override;
 
 public:
   basic_symbol_iterator symbol_begin() const override;
   basic_symbol_iterator symbol_end() const override;
   section_iterator section_begin() const override;
   section_iterator section_end() const override;
 
+  bool is64Bit() const override { return false; }
+
   const coff_section *getCOFFSection(const SectionRef &Section) const;
   COFFSymbolRef getCOFFSymbol(const DataRefImpl &Ref) const;
   COFFSymbolRef getCOFFSymbol(const SymbolRef &Symbol) const;
   const coff_relocation *getCOFFRelocation(const RelocationRef &Reloc) const;
   unsigned getSectionID(SectionRef Sec) const;
   unsigned getSymbolSectionID(SymbolRef Sym) const;
 
   uint8_t getBytesInAddress() const override;

llvm/include/llvm/Object/COFFImportFile.h

public:
   }
 
   basic_symbol_iterator symbol_end() const override {
     DataRefImpl Symb;
     Symb.p = isData() ? 1 : 2;
     return BasicSymbolRef(Symb, this);
   }
 
+  bool is64Bit() const override { return false; }
+
   const coff_import_header *getCOFFImportHeader() const {
     return reinterpret_cast<const object::coff_import_header *>(
         Data.getBufferStart());
   }
 
 private:
   bool isData() const {
     return getCOFFImportHeader()->getType() == COFF::IMPORT_DATA;

llvm/include/llvm/Object/ELFObjectFile.h

public:
 
   const Elf_Shdr *getSection(DataRefImpl Sec) const {
     return reinterpret_cast<const Elf_Shdr *>(Sec.p);
   }
 
   basic_symbol_iterator symbol_begin() const override;
   basic_symbol_iterator symbol_end() const override;
 
+  bool is64Bit() const override { return getBytesInAddress() == 8; }
+
   elf_symbol_iterator dynamic_symbol_begin() const;
   elf_symbol_iterator dynamic_symbol_end() const;
 
   section_iterator section_begin() const override;
   section_iterator section_end() const override;
 
   Expected<int64_t> getRelocationAddend(DataRefImpl Rel) const override;
 

llvm/include/llvm/Object/IRObjectFile.h

 
 public:
   ~IRObjectFile() override;
   void moveSymbolNext(DataRefImpl &Symb) const override;
   Error printSymbolName(raw_ostream &OS, DataRefImpl Symb) const override;
   Expected<uint32_t> getSymbolFlags(DataRefImpl Symb) const override;
   basic_symbol_iterator symbol_begin() const override;
   basic_symbol_iterator symbol_end() const override;
-
+  bool is64Bit() const override {
+    return Triple(getTargetTriple()).isArch64Bit();
+  }
   StringRef getTargetTriple() const;
 
   static bool classof(const Binary *v) {
     return v->isIR();
   }
 
   using module_iterator =
       pointee_iterator<std::vector<std::unique_ptr<Module>>::const_iterator,

llvm/include/llvm/Object/MachO.h

public:
   section_iterator getRelocationRelocatedSection(relocation_iterator Rel) const;
 
   // TODO: Would be useful to have an iterator based version
   // of the load command interface too.
 
   basic_symbol_iterator symbol_begin() const override;
   basic_symbol_iterator symbol_end() const override;
 
+  bool is64Bit() const override;
+
   // MachO specific.
   symbol_iterator getSymbolByIndex(unsigned Index) const;
   uint64_t getSymbolIndex(DataRefImpl Symb) const;
 
   section_iterator section_begin() const override;
   section_iterator section_end() const override;
 
   uint8_t getBytesInAddress() const override;
public:
   Expected<std::pair<size_t, std::vector<ChainedFixupsSegment>>>
   getChainedFixupsSegments() const;
   ArrayRef<uint8_t> getDyldExportsTrie() const;
 
   SmallVector<uint64_t> getFunctionStarts() const;
   ArrayRef<uint8_t> getUuid() const;
 
   StringRef getStringTableData() const;
-  bool is64Bit() const;
+
   void ReadULEB128s(uint64_t Index, SmallVectorImpl<uint64_t> &Out) const;
 
   static StringRef guessLibraryShortName(StringRef Name, bool &isFramework,
                                          StringRef &Suffix);
 
   static Triple::ArchType getArch(uint32_t CPUType, uint32_t CPUSubType);
   static Triple getArchTriple(uint32_t CPUType, uint32_t CPUSubType,
                               const char **McpuDefault = nullptr,

llvm/include/llvm/Object/SymbolicFile.h

public:
   virtual Error printSymbolName(raw_ostream &OS, DataRefImpl Symb) const = 0;
 
   virtual Expected<uint32_t> getSymbolFlags(DataRefImpl Symb) const = 0;
 
   virtual basic_symbol_iterator symbol_begin() const = 0;
 
   virtual basic_symbol_iterator symbol_end() const = 0;
 
+  virtual bool is64Bit() const = 0;
+
   // convenience wrappers.
   using basic_symbol_iterator_range = iterator_range<basic_symbol_iterator>;
   basic_symbol_iterator_range symbols() const {
     return basic_symbol_iterator_range(symbol_begin(), symbol_end());
   }
 
   // construction aux.
   static Expected<std::unique_ptr<SymbolicFile>>

llvm/include/llvm/Object/TapiFile.h

public:
   Error printSymbolName(raw_ostream &OS, DataRefImpl DRI) const override;
 
   Expected<uint32_t> getSymbolFlags(DataRefImpl DRI) const override;
 
   basic_symbol_iterator symbol_begin() const override;
 
   basic_symbol_iterator symbol_end() const override;
 
   static bool classof(const Binary *v) { return v->isTapiFile(); }
 
-  bool is64Bit() { return MachO::is64Bit(Arch); }
+  bool is64Bit() const override { return MachO::is64Bit(Arch); }
 
 private:
   struct Symbol {
     StringRef Prefix;
     StringRef Name;
     uint32_t Flags;
 
     constexpr Symbol(StringRef Prefix, StringRef Name, uint32_t Flags)

llvm/include/llvm/Object/Wasm.h

public:
 
   Expected<uint32_t> getSymbolFlags(DataRefImpl Symb) const override;
 
   basic_symbol_iterator symbol_begin() const override;
 
   basic_symbol_iterator symbol_end() const override;
   Expected<StringRef> getSymbolName(DataRefImpl Symb) const override;
 
+  bool is64Bit() const override { return false; }
+
   Expected<uint64_t> getSymbolAddress(DataRefImpl Symb) const override;
   uint64_t getWasmSymbolValue(const WasmSymbol &Sym) const;
   uint64_t getSymbolValueImpl(DataRefImpl Symb) const override;
   uint32_t getSymbolAlignment(DataRefImpl Symb) const override;
   uint64_t getCommonSymbolSizeImpl(DataRefImpl Symb) const override;
   Expected<SymbolRef::Type> getSymbolType(DataRefImpl Symb) const override;
   Expected<section_iterator> getSymbolSection(DataRefImpl Symb) const override;
   uint32_t getSymbolSectionId(SymbolRef Sym) const;

llvm/include/llvm/Object/XCOFFObjectFile.h

public:
   static constexpr uint64_t InvalidRelocOffset =
       std::numeric_limits<uint64_t>::max();
 
   // Interface inherited from base classes.
   void moveSymbolNext(DataRefImpl &Symb) const override;
   Expected<uint32_t> getSymbolFlags(DataRefImpl Symb) const override;
   basic_symbol_iterator symbol_begin() const override;
   basic_symbol_iterator symbol_end() const override;
-
+  bool is64Bit() const override;
   Expected<StringRef> getSymbolName(DataRefImpl Symb) const override;
   Expected<uint64_t> getSymbolAddress(DataRefImpl Symb) const override;
   uint64_t getSymbolValueImpl(DataRefImpl Symb) const override;
   uint32_t getSymbolAlignment(DataRefImpl Symb) const override;
   uint64_t getCommonSymbolSizeImpl(DataRefImpl Symb) const override;
   Expected<SymbolRef::Type> getSymbolType(DataRefImpl Symb) const override;
   Expected<section_iterator> getSymbolSection(DataRefImpl Symb) const override;
 
public:
   StringRef getFileFormatName() const override;
   Triple::ArchType getArch() const override;
   Expected<SubtargetFeatures> getFeatures() const override;
   Expected<uint64_t> getStartAddress() const override;
   StringRef mapDebugSectionName(StringRef Name) const override;
   bool isRelocatableObject() const override;
 
   // Below here is the non-inherited interface.
-  bool is64Bit() const;
+
   Expected<StringRef> getRawData(const char *Start, uint64_t Size,
                                  StringRef Name) const;
 
   const XCOFFAuxiliaryHeader32 *auxiliaryHeader32() const;
   const XCOFFAuxiliaryHeader64 *auxiliaryHeader64() const;
 
   const void *getPointerToSymbolTable() const { return SymbolTblPtr; }
 

llvm/tools/llvm-ar/llvm-ar.cpp

 
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/BinaryFormat/Magic.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/ArchiveWriter.h"
-#include "llvm/Object/COFFImportFile.h"
-#include "llvm/Object/ELFObjectFile.h"
-#include "llvm/Object/IRObjectFile.h"
-#include "llvm/Object/MachO.h"
-#include "llvm/Object/ObjectFile.h"
 #include "llvm/Object/SymbolicFile.h"
-#include "llvm/Object/TapiFile.h"
-#include "llvm/Object/Wasm.h"
-#include "llvm/Object/XCOFFObjectFile.h"
 #include "llvm/Support/Chrono.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/Host.h"
static bool shouldCreateArchive(ArchiveOperation Op) {
   case QuickAppend:
   case ReplaceOrInsert:
     return true;
   }
 
   llvm_unreachable("Missing entry in covered switch.");
 }
 
-static bool is64BitSymbolicFile(SymbolicFile &Obj) {
-  if (auto *IRObj = dyn_cast<IRObjectFile>(&Obj))
-    return Triple(IRObj->getTargetTriple()).isArch64Bit();
-  if (isa<COFFObjectFile>(Obj) || isa<COFFImportFile>(Obj))
-    return false;
-  if (XCOFFObjectFile *XCOFFObj = dyn_cast<XCOFFObjectFile>(&Obj))
-    return XCOFFObj->is64Bit();
-  if (isa<WasmObjectFile>(Obj))
-    return false;
-  if (TapiFile *Tapi = dyn_cast<TapiFile>(&Obj))
-    return Tapi->is64Bit();
-  if (MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(&Obj))
-    return MachO->is64Bit();
-  if (ELFObjectFileBase *ElfO = dyn_cast<ELFObjectFileBase>(&Obj))
-    return ElfO->getBytesInAddress() == 8;
-
-  fail("unsupported file format");
-}
-
 static bool isValidInBitMode(Binary &Bin) {
   if (BitMode == BitModeTy::Bit32_64 || BitMode == BitModeTy::Any)
     return true;
 
   if (SymbolicFile *SymFile = dyn_cast<SymbolicFile>(&Bin)) {
-    bool Is64Bit = is64BitSymbolicFile(*SymFile);
+    bool Is64Bit = SymFile->is64Bit();
     if ((Is64Bit && (BitMode == BitModeTy::Bit32)) ||
         (!Is64Bit && (BitMode == BitModeTy::Bit64)))
       return false;
   }
   // In AIX "ar", non-object files are always considered to have a valid bit
   // mode.
   return true;
 }

llvm/tools/llvm-nm/llvm-nm.cpp

 }
 
 bool operator>(const NMSymbol &A, const NMSymbol &B) { return B < A; }
 bool operator==(const NMSymbol &A, const NMSymbol &B) {
   return !(A < B) && !(B < A);
 }
 } // anonymous namespace
 
-static char isSymbolList64Bit(SymbolicFile &Obj) {
-  if (auto *IRObj = dyn_cast<IRObjectFile>(&Obj))
-    return Triple(IRObj->getTargetTriple()).isArch64Bit();
-  if (isa<COFFObjectFile>(Obj) || isa<COFFImportFile>(Obj))
-    return false;
-  if (XCOFFObjectFile *XCOFFObj = dyn_cast<XCOFFObjectFile>(&Obj))
-    return XCOFFObj->is64Bit();
-  if (isa<WasmObjectFile>(Obj))
-    return false;
-  if (TapiFile *Tapi = dyn_cast<TapiFile>(&Obj))
-    return Tapi->is64Bit();
-  if (MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(&Obj))
-    return MachO->is64Bit();
-  return cast<ELFObjectFileBase>(Obj).getBytesInAddress() == 8;
-}
-
 static StringRef CurrentFilename;
 
 static char getSymbolNMTypeChar(IRObjectFile &Obj, basic_symbol_iterator I);
 
 // darwinPrintSymbol() is used to print a symbol from a Mach-O file when the
 // the OutputFormat is darwin or we are printing Mach-O symbols in hex.  For
 // the darwin format it produces the same output as darwin's nm(1) -m output
 // and when printing Mach-O symbols in hex it produces the same output as
static void printSymbolList(SymbolicFile &Obj,
                             StringRef ArchiveName, StringRef ArchitectureName) {
   if (!PrintFileName) {
     if ((OutputFormat == bsd || OutputFormat == posix ||
          OutputFormat == just_symbols) &&
         MultipleFiles && printName) {
       outs() << '\n' << CurrentFilename << ":\n";
     } else if (OutputFormat == sysv) {
       outs() << "\n\nSymbols from " << CurrentFilename << ":\n\n";
-      if (isSymbolList64Bit(Obj))
+      if (Obj.is64Bit())
         outs() << "Name                  Value           Class        Type"
                << "         Size             Line  Section\n";
       else
         outs() << "Name                  Value   Class        Type"
                << "         Size     Line  Section\n";
     }
   }
 
   const char *printBlanks, *printDashes, *printFormat;
-  if (isSymbolList64Bit(Obj)) {
+  if (Obj.is64Bit()) {
     printBlanks = "                ";
     printDashes = "----------------";
     switch (AddressRadix) {
     case Radix::o:
       printFormat = OutputFormat == posix ? "%" PRIo64 : "%016" PRIo64;
       break;
     case Radix::x:
       printFormat = OutputFormat == posix ? "%" PRIx64 : "%016" PRIx64;

 static bool shouldDump(SymbolicFile &Obj) {
   // The -X option is currently only implemented for XCOFF, ELF, and IR object
   // files. The option isn't fundamentally impossible with other formats, just
   // isn't implemented.
   if (!isa<XCOFFObjectFile>(Obj) && !isa<ELFObjectFileBase>(Obj) &&
       !isa<IRObjectFile>(Obj))
     return true;
 
-  return isSymbolList64Bit(Obj) ? BitMode != BitModeTy::Bit32
-                                : BitMode != BitModeTy::Bit64;
+  return Obj.is64Bit() ? BitMode != BitModeTy::Bit32
 }
 
 static void getXCOFFExports(XCOFFObjectFile *XCOFFObj,
                             std::vector<NMSymbol> &SymbolList,
                             StringRef ArchiveName) {
   // Skip Shared object file.
   if (XCOFFObj->getFlags() & XCOFF::F_SHROBJ)
     return;