[NFC][XCOFF] Using crtp to refactor the xcoff section header

[DiggerLin]

Summary

According to https://reviews.llvm.org/D68575#inline-617586, I create a NFC patch for it.

1. Using crtp to refactor the xcoff section header
2. Move the define of SectionFlagsReservedMask and SectionFlagsTypeMask from XCOFFDumper.cpp to XCOFFObjectFile.h

[jasonliu]

General comments about the direction of this patch:
Previous comments(https://reviews.llvm.org/D68575#inline-617586) suggests to put those two constant value into XCOFF.h.
I guess the reason for that is we want all the other component of in llvm to be able to use that those two constant value. For example, XCOFFObjectWriter.
But this patch currently put those two values in XCOFFObjectFile.h. The headers in llvm/Object seems to be strictly used only by all the llvm tooling that has an interest in the object itself, but not used by the llvm backend at all.

I think the direction suggested in D68575 makes more sense, as those two constant values are more related to object format, and we would want to use them in more than llvm toolings.

[DiggerLin]

In D69131#1719155, @jasonliu wrote:

General comments about the direction of this patch:
Previous comments(https://reviews.llvm.org/D68575#inline-617586) suggests to put those two constant value into XCOFF.h.
I guess the reason for that is we want all the other component of in llvm to be able to use that those two constant value. For example, XCOFFObjectWriter.
But this patch currently put those two values in XCOFFObjectFile.h. The headers in llvm/Object seems to be strictly used only by all the llvm tooling that has an interest in the object itself, but not used by the llvm backend at all.

I think the direction suggested in D68575 makes more sense, as those two constant values are more related to object format, and we would want to use them in more than llvm toolings.

if both xcoffobjectfilewriter.cpp and xcoffobjectfile.cpp use these two constant, I agreed to put them in the xcoff.h but I do not think we will use them in the xcoffobjectfilewriter.cpp(that is means they only use in xcoff decode tools, if only use in the xcoff decode tool, it is better to put them in the xcoffobjectfile.h).

[hubert.reinterpretcast]

LGTM with minor comments.

llvm/include/llvm/Object/XCOFFObjectFile.h

50–63

Typo: s/Setion/Section/;
Since the base class does not represent a section header by itself, name this something like XCOFFSectionHeaderBase.

llvm/lib/Object/XCOFFObjectFile.cpp

49

s/Explict/Explicitly/;
s/class/classes/;

54

Typo: s/Setion/Section/;

59

Same comment.

llvm/include/llvm/Object/XCOFFObjectFile.h

struct XCOFFFileHeader64 {
   support::big32_t TimeStamp;
 
   support::ubig64_t SymbolTableOffset; // File offset to symbol table.
   support::ubig16_t AuxHeaderSize;
   support::ubig16_t Flags;
   support::ubig32_t NumberOfSymTableEntries;
 };
 
-struct XCOFFSectionHeader32 {
+template <typename T> struct XCOFFSectionHeader {
+  // Least significant 3 bits are reserved.
+  static constexpr unsigned SectionFlagsReservedMask = 0x7;
+
+  // The low order 16 bits of section flags denotes the section type.
+  static constexpr unsigned SectionFlagsTypeMask = 0xffffu;
+
+public:
+  StringRef getName() const;
+  uint16_t getSectionType() const;
+  bool isReservedSectionType() const;
+};
+
+struct XCOFFSectionHeader32 : XCOFFSectionHeader<XCOFFSectionHeader32> {
   char Name[XCOFF::NameSize];
   support::ubig32_t PhysicalAddress;
   support::ubig32_t VirtualAddress;
   support::ubig32_t SectionSize;
   support::ubig32_t FileOffsetToRawData;
   support::ubig32_t FileOffsetToRelocationInfo;
   support::ubig32_t FileOffsetToLineNumberInfo;
   support::ubig16_t NumberOfRelocations;
   support::ubig16_t NumberOfLineNumbers;
   support::big32_t Flags;
-
-  StringRef getName() const;
 };
 
-struct XCOFFSectionHeader64 {
+struct XCOFFSectionHeader64 : XCOFFSectionHeader<XCOFFSectionHeader64> {
   char Name[XCOFF::NameSize];
   support::ubig64_t PhysicalAddress;
   support::ubig64_t VirtualAddress;
   support::ubig64_t SectionSize;
   support::big64_t FileOffsetToRawData;
   support::big64_t FileOffsetToRelocationInfo;
   support::big64_t FileOffsetToLineNumberInfo;
   support::ubig32_t NumberOfRelocations;
   support::ubig32_t NumberOfLineNumbers;
   support::big32_t Flags;
   char Padding[4];
-
-  StringRef getName() const;
 };
 
 struct XCOFFSymbolEntry {
   enum { NAME_IN_STR_TBL_MAGIC = 0x0 };
   typedef struct {
     support::big32_t Magic; // Zero indicates name in string table.
     support::ubig32_t Offset;
   } NameInStrTblType;

llvm/lib/Object/XCOFFObjectFile.cpp

 
 static StringRef generateXCOFFFixedNameStringRef(const char *Name) {
   auto NulCharPtr =
       static_cast<const char *>(memchr(Name, '\0', XCOFF::NameSize));
   return NulCharPtr ? StringRef(Name, NulCharPtr - Name)
                     : StringRef(Name, XCOFF::NameSize);
 }
 
+// Explictly instantiate template classes.
+template struct XCOFFSectionHeader<XCOFFSectionHeader32>;
+template struct XCOFFSectionHeader<XCOFFSectionHeader64>;
+
+template <typename T> StringRef XCOFFSectionHeader<T>::getName() const {
+  const T &DerivedXCOFFSectionHeader = static_cast<const T &>(*this);
+  return generateXCOFFFixedNameStringRef(DerivedXCOFFSectionHeader.Name);
+}
+
+template <typename T> uint16_t XCOFFSectionHeader<T>::getSectionType() const {
+  const T &DerivedXCOFFSectionHeader = static_cast<const T &>(*this);
+  return DerivedXCOFFSectionHeader.Flags & SectionFlagsTypeMask;
+}
+
+template <typename T>
+bool XCOFFSectionHeader<T>::isReservedSectionType() const {
+  return getSectionType() & SectionFlagsReservedMask;
+}
+
 bool XCOFFRelocation32::isRelocationSigned() const {
   return Info & XR_SIGN_INDICATOR_MASK;
 }
 
 bool XCOFFRelocation32::isFixupIndicated() const {
   return Info & XR_FIXUP_INDICATOR_MASK;
 }
 

 }
 
 Expected<std::unique_ptr<ObjectFile>>
 ObjectFile::createXCOFFObjectFile(MemoryBufferRef MemBufRef,
                                   unsigned FileType) {
   return XCOFFObjectFile::create(FileType, MemBufRef);
 }
 
-StringRef XCOFFSectionHeader32::getName() const {
-  return generateXCOFFFixedNameStringRef(Name);
-}
-
-StringRef XCOFFSectionHeader64::getName() const {
-  return generateXCOFFFixedNameStringRef(Name);
-}
-
 XCOFF::StorageClass XCOFFSymbolRef::getStorageClass() const {
   return OwningObjectPtr->toSymbolEntry(SymEntDataRef)->StorageClass;
 }
 
 uint8_t XCOFFSymbolRef::getNumberOfAuxEntries() const {
   return OwningObjectPtr->toSymbolEntry(SymEntDataRef)->NumberOfAuxEntries;
 }
 

llvm/tools/llvm-readobj/XCOFFDumper.cpp

 private:
   template <typename T> void printSectionHeaders(ArrayRef<T> Sections);
   template <typename T> void printGenericSectionHeader(T &Sec) const;
   template <typename T> void printOverflowSectionHeader(T &Sec) const;
   void printFileAuxEnt(const XCOFFFileAuxEnt *AuxEntPtr);
   void printCsectAuxEnt32(const XCOFFCsectAuxEnt32 *AuxEntPtr);
   void printSectAuxEntForStat(const XCOFFSectAuxEntForStat *AuxEntPtr);
   void printSymbol(const SymbolRef &);
-
-  // Least significant 3 bits are reserved.
-  static constexpr unsigned SectionFlagsReservedMask = 0x7;
-
-  // The low order 16 bits of section flags denotes the section type.
-  static constexpr unsigned SectionFlagsTypeMask = 0xffffu;
-
   void printRelocations(ArrayRef<XCOFFSectionHeader32> Sections);
   const XCOFFObjectFile &Obj;
 };
 } // anonymous namespace
 
 void XCOFFDumper::printFileHeaders() {
   DictScope DS(W, "FileHeader");
   W.printHex("Magic", Obj.getMagic());

 void XCOFFDumper::printSectionHeaders(ArrayRef<T> Sections) {
   ListScope Group(W, "Sections");
 
   uint16_t Index = 1;
   for (const T &Sec : Sections) {
     DictScope SecDS(W, "Section");
 
     W.printNumber("Index", Index++);
-
-    uint16_t SectionType = Sec.Flags & SectionFlagsTypeMask;
+    uint16_t SectionType = Sec.getSectionType();
     switch (SectionType) {
     case XCOFF::STYP_OVRFLO:
       printOverflowSectionHeader(Sec);
       break;
     case XCOFF::STYP_LOADER:
     case XCOFF::STYP_EXCEPT:
     case XCOFF::STYP_TYPCHK:
       // TODO The interpretation of loader, exception and type check section
       // headers are different from that of generic section headers. We will
       // implement them later. We interpret them as generic section headers for
       // now.
     default:
       printGenericSectionHeader(Sec);
       break;
     }
-    // For now we just dump the section type portion of the flags.
-    if (SectionType & SectionFlagsReservedMask)
+    if (Sec.isReservedSectionType())
       W.printHex("Flags", "Reserved", SectionType);
     else
       W.printEnum("Type", SectionType, makeArrayRef(SectionTypeFlagsNames));
   }
 
   if (opts::SectionRelocations)
     report_fatal_error("Dumping section relocations is unimplemented");