[XCOFF] llvm-readobj support decoding the loader section header field for XCOFF object file.

[DiggerLin]

Summary

according to https://www.ibm.com/docs/en/aix/7.2?topic=formats-xcoff-object-file-format#XCOFF__vra3i31ejbau
we add a new option --loader-section-header for llvm-readobj to decode the decode the loader section header field of XCOFF object file.

[jhenderson]

Please don't forget to update the documentation for new options.

I'm going to be on paid time off next week, and don't have the time to look at this today. I will look at it at some point after I get back.

[DiggerLin]

In D134883#3826203, @jhenderson wrote:

Please don't forget to update the documentation for new options.

I'm going to be on paid time off next week, and don't have the time to look at this today. I will look at it at some point after I get back.

Enjoy your vacation!

[jhenderson]

llvm/include/llvm/Object/XCOFFObjectFile.h

198

Reading the code, it seems like the CRTP (and therefore this base class) are unnecessary. In your lambda where you print the fields, you can use the common subclass memeber fields directly, because you've provided the input parameter type of the lamdba as auto.

llvm/tools/llvm-readobj/XCOFFDumper.cpp

166

Nit: don't start functions with a blank line.

169

Nit: Lambdas are function objects. The consensus is that their names should be written like variables, because they are passed around like them (i.e. PrintLoadSecHeaderCommon).

[DiggerLin]

address James' comment.

[jhenderson]

One more suggestion. I thought I made this in the previous version of the patch, but apparently not.

llvm/tools/llvm-readobj/llvm-readobj.cpp

514–515

This is a very odd way of getting it to print a specific part of the loader section. It would be much more normal to pass in booleans into printLoaderSection, rather than modifying the state of the dumper to ensure it does print it. Take a look at the printSymbols call for example.

[DiggerLin]

llvm/include/llvm/Object/XCOFFObjectFile.h

198

thanks, good idea.

llvm/tools/llvm-readobj/llvm-readobj.cpp

514–515

thanks

[DiggerLin]

address comment.

[jhenderson]

Looks good. Probably worth an XCOFF developer taking a quick look too, for more file-format specific aspects of this.

[Esme]

This comment was removed by Esme.

llvm/test/tools/llvm-readobj/XCOFF/loader-section-header.test

25

Nit: trailing whitespace in this line.

[Esme]

LGTM. Thanks for your work.

llvm/docs/CommandGuide/llvm-readobj.rst

 .. option:: --auxiliary-header
 
   Display XCOFF Auxiliary header.
 
 .. option:: --exception-section
 
   Display XCOFF exception section entries.
 
+.. option:: --loader-section-header
+
+  Display XCOFF loader section header.
+
 EXIT STATUS
 -----------
 
 :program:`llvm-readobj` returns 0 under normal operation. It returns a non-zero
 exit code if there were any errors.
 
 SEE ALSO
 --------
 
 :manpage:`llvm-nm(1)`, :manpage:`llvm-objdump(1)`, :manpage:`llvm-readelf(1)`

llvm/include/llvm/Object/XCOFFObjectFile.h

struct XCOFFSectionHeader64 : XCOFFSectionHeader<XCOFFSectionHeader64> {
   support::big64_t FileOffsetToRelocationInfo;
   support::big64_t FileOffsetToLineNumberInfo;
   support::ubig32_t NumberOfRelocations;
   support::ubig32_t NumberOfLineNumbers;
   support::big32_t Flags;
   char Padding[4];
 };
 
-struct LoaderSectionHeader32 {
+template <typename T> struct LoaderSectionHeader {
+  uint32_t getVersion() const { return static_cast<const T *>(this)->Version; }
+  uint32_t getNumOfSymTblEnt() const {
+    return static_cast<const T *>(this)->NumberOfSymTabEnt;
+  }
+  uint32_t getNumOfRelTbleEnt() const {
+    return static_cast<const T *>(this)->NumberOfRelTabEnt;
+  }
+  uint32_t getLengthOfImpidStrTbl() const {
+    return static_cast<const T *>(this)->LengthOfImpidStrTbl;
+  }
+  uint32_t getNumberOfImpIds() const {
+    return static_cast<const T *>(this)->NumberOfImpid;
+  }
+  uint64_t getOffsetToImpids() const {
+    return static_cast<const T *>(this)->OffsetToImpid;
+  }
+  uint32_t getLengthOfStrTbl() const {
+    return static_cast<const T *>(this)->LengthOfStrTbl;
+  }
+  uint64_t getOffsetToStrTbl() const {
+    return static_cast<const T *>(this)->OffsetToStrTbl;
+  }
+};
+
+struct LoaderSectionHeader32 : LoaderSectionHeader<LoaderSectionHeader32> {
   support::ubig32_t Version;
   support::ubig32_t NumberOfSymTabEnt;
   support::ubig32_t NumberOfRelTabEnt;
   support::ubig32_t LengthOfImpidStrTbl;
   support::ubig32_t NumberOfImpid;
   support::big32_t OffsetToImpid;
   support::ubig32_t LengthOfStrTbl;
   support::big32_t OffsetToStrTbl;
 };
 
-struct LoaderSectionHeader64 {
+struct LoaderSectionHeader64 : LoaderSectionHeader<LoaderSectionHeader64> {
   support::ubig32_t Version;
   support::ubig32_t NumberOfSymTabEnt;
   support::ubig32_t NumberOfRelTabEnt;
   support::ubig32_t LengthOfImpidStrTbl;
   support::ubig32_t NumberOfImpid;
   support::ubig32_t LengthOfStrTbl;
   support::big64_t OffsetToImpid;
   support::big64_t OffsetToStrTbl;
   support::big64_t OffsetToSymTbl;
-  char Padding[16];
-  support::big32_t OffsetToRelEnt;
+  support::big64_t OffsetToRelEnt;
+
+  uint64_t getOffsetToSymTbl() const { return OffsetToSymTbl; }
+  uint64_t getOffsetToRelEnt() const { return OffsetToRelEnt; }
 };
 
 template <typename AddressType> struct ExceptionSectionEntry {
   union {
     support::ubig32_t SymbolIdx;
     AddressType TrapInstAddr;
   };
   uint8_t LangId;
private:
 
   const XCOFFSectionHeader32 *toSection32(DataRefImpl Ref) const;
   const XCOFFSectionHeader64 *toSection64(DataRefImpl Ref) const;
   uintptr_t getSectionHeaderTableAddress() const;
   uintptr_t getEndOfSymbolTableAddress() const;
 
   DataRefImpl getSectionByType(XCOFF::SectionTypeFlags SectType) const;
   uint64_t getSectionFileOffsetToRawData(DataRefImpl Sec) const;
-  Expected<uintptr_t>
-  getSectionFileOffsetToRawData(XCOFF::SectionTypeFlags SectType) const;
 
   // This returns a pointer to the start of the storage for the name field of
   // the 32-bit or 64-bit SectionHeader struct. This string is *not* necessarily
   // null-terminated.
   const char *getSectionNameInternal(DataRefImpl Sec) const;
 
   static bool isReservedSectionNumber(int16_t SectionNumber);
 
public:
 
   // Section header table related interfaces.
   ArrayRef<XCOFFSectionHeader32> sections32() const;
   ArrayRef<XCOFFSectionHeader64> sections64() const;
 
   int32_t getSectionFlags(DataRefImpl Sec) const;
   Expected<DataRefImpl> getSectionByNum(int16_t Num) const;
 
+  Expected<uintptr_t>
+  getSectionFileOffsetToRawData(XCOFF::SectionTypeFlags SectType) const;
+
   void checkSymbolEntryPointer(uintptr_t SymbolEntPtr) const;
 
   // Relocation-related interfaces.
   template <typename T>
   Expected<uint32_t>
   getNumberOfRelocationEntries(const XCOFFSectionHeader<T> &Sec) const;
 
   template <typename Shdr, typename Reloc>

llvm/test/tools/llvm-readobj/XCOFF/loader-section-header.test

+## Test the --loader-section-header option.
+
+# RUN: yaml2obj --docnum=1 %s -o %t_xcoff32.o
+# RUN: yaml2obj --docnum=2  %s -o %t_xcoff64.o
+# RUN: llvm-readobj --loader-section-header %t_xcoff32.o |\
+# RUN:   FileCheck %s --check-prefixes=CHECK32
+# RUN: llvm-readobj --loader-section-header %t_xcoff64.o |\
+# RUN:   FileCheck %s --check-prefixes=CHECK64
+
+--- !XCOFF
+FileHeader:
+  MagicNumber:       0x1DF
+Sections:
+  - Name:            .loader
+    Flags:           [ STYP_LOADER ]
+    SectionData:     "0000000100000003000000050000016D00000001000000A40000001800000211"
+##                    ^-------                                                           -Version=1
+##                            ^-------                                                   -NumberOfSymbolEntries=3
+##                                    ^-------                                           -NumberOfRelocationEntries=5
+##                                            ^-------                                   -LengthOfImportFileIDStringTable=365
+##                                                    ^-------                           -NumberOfImportFileIDs=1
+##                                                            ^-------                   -OffsetToImportFileIDs=0xA4
+##                                                                    ^-------           -LengthOfStringTable=24
+##                                                                            ^-------   -OffsetToStringTable=0x211 
+
+
+--- !XCOFF
+FileHeader:
+  MagicNumber:       0x1F7
+Sections:
+  - Name:            .loader
+    Flags:           [ STYP_LOADER ]
+    SectionData:     "0000000200000003000000050000016D000000010000002300000000000000D0000000000000023D00000000000000380000000000000080"
+##                    ^-------                                                           -Version=2
+##                            ^-------                                                   -NumberOfSymbolEntries=3
+##                                    ^-------                                           -NumberOfRelocationEntries=5
+##                                            ^-------                                   -LengthOfImportFileIDStringTable=365
+##                                                    ^-------                           -NumberOfImportFileIDs=1
+##                                                            ^-------                   --LengthOfStringTable=0x23
+##                                                                    ^---------------   -OffsetToImportFileIDs=0xD0
+##                                                                                    ^---------------                                        -OffsetToStringTable=0x23D
+##                                                                                                    ^--------------                         -OffsetToSymbolTable=0x38
+##                                                                                                                    ^---------------        -OffsetToRelocationEntries=0x80
+
+# CHECK32:      Loader Section {
+# CHECK32-NEXT:     Loader Section Header {
+# CHECK32-NEXT:       Version: 1
+# CHECK32-NEXT:       NumberOfSymbolEntries: 3
+# CHECK32-NEXT:       NumberOfRelocationEntries: 5
+# CHECK32-NEXT:       LengthOfImportFileIDStringTable: 365
+# CHECK32-NEXT:       NumberOfImportFileIDs: 1
+# CHECK32-NEXT:       OffsetToImportFileIDs: 0xA4
+# CHECK32-NEXT:       LengthOfStringTable: 24
+# CHECK32-NEXT:       OffsetToStringTable: 0x211
+# CHECK32-NEXT:   }
+# CHECK32-NEXT: }
+
+# CHECK64:      Loader Section {
+# CHECK64-NEXT:     Loader Section Header {
+# CHECK64-NEXT:       Version: 2
+# CHECK64-NEXT:       NumberOfSymbolEntries: 3
+# CHECK64-NEXT:       NumberOfRelocationEntries: 5
+# CHECK64-NEXT:       LengthOfImportFileIDStringTable: 365
+# CHECK64-NEXT:       NumberOfImportFileIDs: 1
+# CHECK64-NEXT:       OffsetToImportFileIDs: 0xD0
+# CHECK64-NEXT:       LengthOfStringTable: 35
+# CHECK64-NEXT:       OffsetToStringTable: 0x23D
+# CHECK64-NEXT:       OffsetToSymbolTable: 0x38
+# CHECK64-NEXT:       OffsetToRelocationEntries: 0x80
+# CHECK64-NEXT:   }
+# CHECK64-NEXT: }

llvm/tools/llvm-readobj/ObjDumper.h

mergeCodeViewTypes(llvm::codeview::MergingTypeTableBuilder &CVIDs,
                      llvm::codeview::MergingTypeTableBuilder &CVTypes,
                      llvm::codeview::GlobalTypeTableBuilder &GlobalCVIDs,
                      llvm::codeview::GlobalTypeTableBuilder &GlobalCVTypes,
                      bool GHash) {}
 
   // Only implement for XCOFF
   virtual void printAuxiliaryHeader() {}
   virtual void printExceptionSection() {}
+  virtual void printLoaderSection() {}
+  virtual void setPrintLoaderSectionHeader() {}
 
   // Only implemented for MachO.
   virtual void printMachODataInCode() { }
   virtual void printMachOVersionMin() { }
   virtual void printMachODysymtab() { }
   virtual void printMachOSegment() { }
   virtual void printMachOIndirectSymbols() { }
   virtual void printMachOLinkerOptions() { }

llvm/tools/llvm-readobj/Opts.td

 def coff_load_config : FF<"coff-load-config", "Display load config">, Group<grp_coff>;
 def coff_resources : FF<"coff-resources", "Display .rsrc section">, Group<grp_coff>;
 def coff_tls_directory : FF<"coff-tls-directory", "Display TLS directory">, Group<grp_coff>;
 
 // XCOFF specific options.
 def grp_xcoff : OptionGroup<"kind">, HelpText<"OPTIONS (XCOFF specific)">;
 def auxiliary_header : FF<"auxiliary-header" , "Display the auxiliary header">, Group<grp_xcoff>;
 def exception_section : FF<"exception-section" , "Display the exception section entries">, Group<grp_xcoff>;
+def loader_section_header : FF<"loader-section-header" , "Display the loader section header">, Group<grp_xcoff>;
 
 def help : FF<"help", "Display this help">;
 def version : FF<"version", "Display the version">;
 
 // Ignored for GNU readelf compatibility.
 def wide : FF<"wide", "Ignored for GNU readelf compatibility">;
 def : F<"W", "Ignored for GNU readelf compatibility">, Alias<wide>;
 

llvm/tools/llvm-readobj/XCOFFDumper.cpp

public:
   void printRelocations() override;
   void printSymbols() override;
   void printDynamicSymbols() override;
   void printUnwindInfo() override;
   void printStackMap() const override;
   void printNeededLibraries() override;
   void printStringTable() override;
   void printExceptionSection() override;
+  void printLoaderSection() override;
+
+  void setPrintLoaderSectionHeader() override {
+    PrintLoaderSectionHeader = true;
+  }
 
   ScopedPrinter &getScopedPrinter() const { return W; }
 
 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;
   template <typename T>
private:
   void printBlockAuxEnt(const XCOFFBlockAuxEnt64 *AuxEntPtr);
   template <typename T> void printSectAuxEntForDWARF(const T *AuxEntPtr);
   void printSymbol(const SymbolRef &);
   template <typename RelTy> void printRelocation(RelTy Reloc);
   template <typename Shdr, typename RelTy>
   void printRelocations(ArrayRef<Shdr> Sections);
   void printAuxiliaryHeader(const XCOFFAuxiliaryHeader32 *AuxHeader);
   void printAuxiliaryHeader(const XCOFFAuxiliaryHeader64 *AuxHeader);
+  void printLoaderSectionHeader(uintptr_t LoaderSectAddr);
   const XCOFFObjectFile &Obj;
+  bool PrintLoaderSectionHeader = false;
 };
 } // anonymous namespace
 
 void XCOFFDumper::printFileHeaders() {
   DictScope DS(W, "FileHeader");
   W.printHex("Magic", Obj.getMagic());
   W.printNumber("NumberOfSections", Obj.getNumberOfSections());
 

 
 void XCOFFDumper::printSectionHeaders() {
   if (Obj.is64Bit())
     printSectionHeaders(Obj.sections64());
   else
     printSectionHeaders(Obj.sections32());
 }
 
+void XCOFFDumper::printLoaderSection() {
+  DictScope DS(W, "Loader Section");
+  Expected<uintptr_t> LoaderSectionAddrOrError =
+      Obj.getSectionFileOffsetToRawData(XCOFF::STYP_LOADER);
+  if (!LoaderSectionAddrOrError) {
+    reportUniqueWarning(LoaderSectionAddrOrError.takeError());
+    return;
+  }
+  uintptr_t LoaderSectionAddr = LoaderSectionAddrOrError.get();
+
+  W.indent();
+  if (PrintLoaderSectionHeader)
+    XCOFFDumper::printLoaderSectionHeader(LoaderSectionAddr);
+  // TODO: Need to print symbol table, relocation entry of loader section later.
+  // For example:
+  //           if (PrintLoaderSectionSymbolTable)
+  //                XCOFFDumper::printLoaderSectionSymbolTable();
+  //           if (PrintLoaderSectionRelocationEntry)
+  //               XCOFFDumper::printLoaderSectionRelocationEntry();
+  W.unindent();
+}
+
+void XCOFFDumper::printLoaderSectionHeader(uintptr_t LoaderSectionAddr) {
+
+  DictScope DS(W, "Loader Section Header");
+
+  auto printLoadSecHeaderCommon = [&](auto *LDHeader) {
+    W.printNumber("Version", LDHeader->getVersion());
+    W.printNumber("NumberOfSymbolEntries", LDHeader->getNumOfSymTblEnt());
+    W.printNumber("NumberOfRelocationEntries", LDHeader->getNumOfRelTbleEnt());
+    W.printNumber("LengthOfImportFileIDStringTable",
+                  LDHeader->getLengthOfImpidStrTbl());
+    W.printNumber("NumberOfImportFileIDs", LDHeader->getNumberOfImpIds());
+    W.printHex("OffsetToImportFileIDs", LDHeader->getOffsetToImpids());
+    W.printNumber("LengthOfStringTable", LDHeader->getLengthOfStrTbl());
+    W.printHex("OffsetToStringTable", LDHeader->getOffsetToStrTbl());
+  };
+
+  if (Obj.is64Bit()) {
+    const LoaderSectionHeader64 *LoaderSec64 =
+        reinterpret_cast<const LoaderSectionHeader64 *>(LoaderSectionAddr);
+    printLoadSecHeaderCommon(LoaderSec64);
+    W.printHex("OffsetToSymbolTable", LoaderSec64->getOffsetToSymTbl());
+    W.printHex("OffsetToRelocationEntries", LoaderSec64->getOffsetToRelEnt());
+  } else {
+    const LoaderSectionHeader32 *LoaderSec32 =
+        reinterpret_cast<const LoaderSectionHeader32 *>(LoaderSectionAddr);
+    printLoadSecHeaderCommon(LoaderSec32);
+  }
+}
+
 template <typename T>
 void XCOFFDumper::printExceptionSectionEntry(const T &ExceptionSectEnt) const {
   if (ExceptionSectEnt.getReason())
     W.printHex("Trap Instr Addr", ExceptionSectEnt.getTrapInstAddr());
   else {
     uint32_t SymIdx = ExceptionSectEnt.getSymbolIndex();
     Expected<StringRef> ErrOrSymbolName = Obj.getSymbolNameByIndex(SymIdx);
     if (Error E = ErrOrSymbolName.takeError()) {

llvm/tools/llvm-readobj/llvm-readobj.cpp

 static bool COFFExports;
 static bool COFFImports;
 static bool COFFLoadConfig;
 static bool COFFResources;
 static bool COFFTLSDirectory;
 
 // XCOFF specific options.
 static bool XCOFFAuxiliaryHeader;
+static bool XCOFFLoaderSectionHeader;
 static bool XCOFFExceptionSection;
 
 OutputStyleTy Output = OutputStyleTy::LLVM;
 static std::vector<std::string> InputFilenames;
 } // namespace opts
 
 static StringRef ToolName;
 
static void parseOptions(const opt::InputArgList &Args) {
   opts::COFFExports = Args.hasArg(OPT_coff_exports);
   opts::COFFImports = Args.hasArg(OPT_coff_imports);
   opts::COFFLoadConfig = Args.hasArg(OPT_coff_load_config);
   opts::COFFResources = Args.hasArg(OPT_coff_resources);
   opts::COFFTLSDirectory = Args.hasArg(OPT_coff_tls_directory);
 
   // XCOFF specific options.
   opts::XCOFFAuxiliaryHeader = Args.hasArg(OPT_auxiliary_header);
+  opts::XCOFFLoaderSectionHeader = Args.hasArg(OPT_loader_section_header);
   opts::XCOFFExceptionSection = Args.hasArg(OPT_exception_section);
 
   opts::InputFilenames = Args.getAllArgValues(OPT_INPUT);
 }
 
 namespace {
 struct ReadObjTypeTableBuilder {
   ReadObjTypeTableBuilder()
if (Obj.isMachO()) {
     if (opts::MachOVersionMin)
       Dumper->printMachOVersionMin();
     if (opts::MachODysymtab)
       Dumper->printMachODysymtab();
     if (opts::CGProfile)
       Dumper->printCGProfile();
   }
 
-  if (Obj.isXCOFF() && opts::XCOFFExceptionSection)
+  if (Obj.isXCOFF()) {
+    if (opts::XCOFFLoaderSectionHeader) {
+      Dumper->setPrintLoaderSectionHeader();
+      Dumper->printLoaderSection();
+    }
+    if (opts::XCOFFExceptionSection)
       Dumper->printExceptionSection();
+  }
 
   if (opts::PrintStackMap)
     Dumper->printStackMap();
   if (opts::PrintStackSizes)
     Dumper->printStackSizes();
 }
 
 /// Dumps each object file in \a Arc;