[XCOFF] llvm-readobj support display symbol table of loader section of xcoff object file.

[DiggerLin]

Summary

llvvm-readobj support display symbol table of loader section of xcoff object file.

https://www.ibm.com/docs/en/aix/7.2?topic=formats-xcoff-object-file-format#XCOFF__vra3i31ejbau

[Esme]

The symbols in the loader section should be the dynamic symbols in the general definition, so is it possible to use the original option --dyn-syms, and then implement the defined interface XCOFFDumper::printDynamicSymbols()?

[DiggerLin]

In D135887#3873329, @Esme wrote:

The symbols in the loader section should be the dynamic symbols in the general definition, so is it possible to use the original option --dyn-syms, and then implement the defined interface XCOFFDumper::printDynamicSymbols()?

according to https://llvm.org/docs/CommandGuide/llvm-readobj.html

--dyn-syms is "ELF SPECIFIC OPTIONS"

in "MACH-O SPECIFIC OPTIONS" there is --macho-dsymtab

We have XCOFF SPECIFIC OPTIONS options too. and the --dyn-syms looks do not express the xcoff loader section terminology.

[DiggerLin]

gentle ping @jhenderson and @Esme .

[jhenderson]

In D135887#3885526, @DiggerLin wrote:

gentle ping @jhenderson and @Esme .

I was waiting on @Esme to respond to your latest comment, as it's a bit outside where I feel comfortable to make an informed decision.

It does sound to me like dynamic symbols/loader section symbols are functionally the same thing (and also dynamic/loader section relocations). However, I also get the point that the terminology is different.

Re. the documentation: it's ELF-specific, because no other format supported the option yet. That's not a reason not to move the option out of the ELF-specific options section. I note that in the Options.td file, --dyn-syms is already not in the ELF-specific area, so perhaps somebody has implemented it for another file format but forgot to update the docs? To address the different terminology point, how about the code be moved into printDynamicSymbols and then make --loader-section-symbols an alias of --dyn-syms. A similar approach could be adopted for the --loader-section-relocations` option, which would be similar to priting dynamic relocations for ELF, I expect.

llvm/docs/CommandGuide/llvm-readobj.rst

341

Make this a plural name, as there's more than one symbol (typically). (The same will go for the relocation option in the next patch).

[DiggerLin]

the documentation: it's ELF-specific, because no other format supported the option yet. That's not a reason not to move the option out of the ELF-specific options section.

"MACH-O SPECIFIC OPTIONS"
there is --macho-dsymtab in MachO, if move out the ELF-specific options , do we want to delete MachO's "--macho-dsymtab" instead of using --dyn-syms

--dyn-syms is already not in the ELF-specific area, so perhaps somebody has implemented it for another file format but forgot to update the docs?

I search the function "printDynamicTable()" which only implemented on ELFDumper.cpp.

how about the code be moved into printDynamicSymbols and then make --loader-section-symbols an alias of --dyn-syms. A similar approach could be adopted for the --loader-section-relocations` option, which would be similar to printing dynamic relocations for ELF, I expect.

I can make --loader-section-symbols an alias of --dyn-syms . but I can not move the code into printDynamicSymbols

when user specific "--loader-section-symbols" , The output will look as

Loader Section {
     Loader Section Symbols {
       Symbol {
        ......
       }
     Symbol {
        ......
       }
  }

when user specific "--loader-section-relocation" , The output will look as 

  Loader Section {
   Loader Section Relocations {
      Relocation {
      ......
     }
      Relocation {
      ......
     }
  }

But If the code be moved into printDynamicSymbols" , it can not archive following

when user specific "--loader-section-symbols --loader-section-relocation --loader-section-header" , The output will look as 

  Loader Section {
     Header {
       .......
     }
   
   Loader Section Symbols {
       Symbol {
        ......
       }
     Symbol {
        ......
       }

   Loader Section Relocations {
      Relocation {
      ......
     }
      Relocation {
      ......
     }
  }

And I will add new option "--loader-section" later to print out all the content of loader section at one time. (equal to " loader-section-symbols + loader-section-relocation + loader-section-header + importLib"); which output all the loader section content into one Loader Section

Loader Section {
  Loader Section Header  
  Loader Section Symbols {
    Symbol {
    }
  }
  Loader Section Relocations { 
    relocation {
   }
  }
 Loader  section import libs { 
   lib {
   }
 }
 etc...
}

[Esme]

Sorry for the late reply, in fact I'm not quite sure about using the existing --dyn-syms option or adding an XCOFF specific one, so I wait to see what others think.
I noticed that the objdump from AIX system tool kits prints the loader section (together with its symbols and relocations) with the XCOFF specific option -P loader:

$ objdump base.xcoff -P loader

Loader header:
...
Dynamic symbols:
...
Dynamic relocs:
...
Import files:
...

While objdump --dynamic-syms doesn't work.
From that standpoint, I have no objection to what Digger is doing now.

[jhenderson]

Thanks for the explanation, I follow what you're saying. One follow-up question: what is the motivation for having the outer "Loader Section" grouping to wrap the header/relocations/symbols? I'm not aware of any prior art for this style, at least within the llvm-readobj tooling (for example, in ELF, dynamic symbols, the dynamic section tags, and the dynamic relocations are all separate and ungrouped).

(For clarity, I'm not opposed to a combined option that dumps them all, but am just wondering why the grouping is important).

[DiggerLin]

addressed James' comment.

[DiggerLin]

In D135887#3898552, @jhenderson wrote:

Thanks for the explanation, I follow what you're saying. One follow-up question: what is the motivation for having the outer "Loader Section" grouping to wrap the header/relocations/symbols? I'm not aware of any prior art for this style, at least within the llvm-readobj tooling (for example, in ELF, dynamic symbols, the dynamic section tags, and the dynamic relocations are all separate and ungrouped).

(For clarity, I'm not opposed to a combined option that dumps them all, but am just wondering why the grouping is important).

I think it is more clear that what data are belong to loader-section. it like all symbols are group into one symbols group(relocation too) . if you not agree to that group into a load section, I can change it.

[jhenderson]

Typo in the patch topic: [XOCFF] -> [XCOFF].

llvm/include/llvm/Object/XCOFFObjectFile.h

247

Here and throughout: I'd change LDHeader to LoaderHeader, as it avoids the need for metal gymnastics to underestand what "LD" means here.

llvm/lib/Object/XCOFFObjectFile.cpp

93

106–107

This is undefined behaviour. From cppreference.com:

It is undefined behavior to read from the member of the union that wasn't most recently written.

In other words, your design of the struct isn't guaranteed to work according to the C++ coding standard. You need to change it so that you can use a different mechanism to identify whether the name is in the string table or not.

llvm/test/tools/llvm-readobj/XCOFF/loader-section-symbol-invalid.test

38 ↗

(On Diff #472352)

Get rid of extra blank line.

39 ↗

(On Diff #472352)

llvm/tools/llvm-readobj/XCOFFDumper.cpp

161

216

As asked before, please take more care with your code before uploading for review. I have repeatedly pointed out that functions should not start with a blank line.

I'm sorry, but there may come a point where I simply won't be willing to review the patch until you've got rid of all the trivial errors like this, because it wastes my time reviewing it and having to comment on all these issues every time.

222–227

245

https://llvm.org/docs/CodingStandards.html#prefer-preincrement

248

As far as I can tell, the else block here is identical to the if part, except for different types. Put them into a helper template function to avoid code duplication.

255

https://llvm.org/docs/CodingStandards.html#prefer-preincrement

[DiggerLin]

address comment

[DiggerLin]

llvm/lib/Object/XCOFFObjectFile.cpp

106–107

thanks for point out.

llvm/tools/llvm-readobj/XCOFFDumper.cpp

216

sorry about that. Actually I always take a careful review when I uploaded the code. But sorry that there are still some trivial error. I will put more work on the review when uploaded.

248

thanks

[jhenderson]

llvm/include/llvm/Object/XCOFFObjectFile.h

229–232

Use C++ style struct naming. I'm not a big fan of the struct name either. We don't generally call any of our types "...Type", since that part of the name is typically redundant (it will be used as a type or not as a type, so the usage tells us it's a type). How about simply "SymbolNameOffset"? The usage will make it clear it's not a pure integer, I think. Other ideas are welcome too.

(If the XCOFF spec has a sepcific name for this struct, then it's fine to use that name, I guess).

llvm/lib/Object/XCOFFObjectFile.cpp

93

Marked as done, but this comment hasn't been addressed. Please don't mark comments as done if you haven't done them.

llvm/test/tools/llvm-readobj/XCOFF/loader-section-symbol-invalid.test

1 ↗

(On Diff #474305)

llvm/tools/llvm-readobj/XCOFFDumper.cpp

161

Updated comment still doesn't completely match my suggestion. Please fix.

217–221

Do these two calculations need checking to make sure they are within the file (in case of malformed input)?

[DiggerLin]

address James' comment

llvm/include/llvm/Object/XCOFFObjectFile.h

229–232

We already define "NameOffset" in the LoaderSectionSymbolEntry32, so we do not need the "Symbol" in SymbolNameOffset. I change to use the NameOffsetInStrTbl.

llvm/lib/Object/XCOFFObjectFile.cpp

93

I used the abbr Name in function name , otherwise the function name is too long. For example:
Sec for Section.
StrTbl for StringTable.
Load for Loader.

llvm/test/tools/llvm-readobj/XCOFF/loader-section-symbol-invalid.test

1 ↗

(On Diff #474305)

thanks

llvm/tools/llvm-readobj/XCOFFDumper.cpp

161

thanks

217–221

I added check code for it . thanks

[jhenderson]

Looks good, but probably worth @Esme taking a quick look to confirm that they're happy too.

llvm/lib/Object/XCOFFObjectFile.cpp

93

I'm okay with some abbreviations (Sec, Sym and StrTbl are all fine), but "Load" -> "Loader" is not an obvious one to me, hence my objection.

Regarding marking things as done - if you disagree with my comment, that's fine, but please say so and explain why so that we can have a discussion.

[DiggerLin]

llvm/lib/Object/XCOFFObjectFile.cpp

93

OK, thanks.

[vitalybuka]

there is a use of uninitialized value:
https://lab.llvm.org/buildbot/#/builders/5/builds/29299

[MaskRay]

(Note, a typo in the commit [XCOFF] llvvm-readobj ...)

[DiggerLin]

In D135887#3939235, @MaskRay wrote:

(Note, a typo in the commit [XCOFF] llvvm-readobj ...)

fixed. thanks

[DiggerLin]

In D135887#3939182, @vitalybuka wrote:

there is a use of uninitialized value:
https://lab.llvm.org/buildbot/#/builders/5/builds/29299

fixed , thanks

llvm/docs/CommandGuide/llvm-readobj.rst

 .. option:: --exception-section
 
   Display XCOFF exception section entries.
 
 .. option:: --loader-section-header
 
   Display XCOFF loader section header.
 
+.. option:: --loader-section-symbols
+
+  Display symbol table of loader section.
+
 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 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;
+
+  uint64_t getOffsetToSymTbl() const {
+    return NumberOfSymTabEnt == 0 ? 0 : sizeof(LoaderSectionHeader32);
+  }
 };
 
 struct 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;
   support::big64_t OffsetToRelEnt;
+
+  uint64_t getOffsetToSymTbl() const { return OffsetToSymTbl; }
+};
+
+struct LoaderSectionSymbolEntry32 {
+  struct NameOffsetInStrTbl {
+    support::big32_t IsNameInStrTbl; // Zero indicates name in string table.
+    support::ubig32_t Offset;
+  };
+
+  char SymbolName[XCOFF::NameSize];
+  support::ubig32_t Value; // The virtual address of the symbol.
+  support::big16_t SectionNumber;
+  uint8_t SymbolType;
+  XCOFF::StorageClass StorageClass;
+  support::ubig32_t ImportFileID;
+  support::ubig32_t ParameterTypeCheck;
+
+  Expected<StringRef>
+  getSymbolName(const LoaderSectionHeader32 *LoaderSecHeader) const;
+};
+
+struct LoaderSectionSymbolEntry64 {
+  support::ubig64_t Value; // The virtual address of the symbol.
+  support::ubig32_t Offset;
+  support::big16_t SectionNumber;
+  uint8_t SymbolType;
+  XCOFF::StorageClass StorageClass;
+  support::ubig32_t ImportFileID;
+  support::ubig32_t ParameterTypeCheck;
+
+  Expected<StringRef>
+  getSymbolName(const LoaderSectionHeader64 *LoaderSecHeader) const;
 };
 
 template <typename AddressType> struct ExceptionSectionEntry {
   union {
     support::ubig32_t SymbolIdx;
     AddressType TrapInstAddr;
   };
   uint8_t LangId;

llvm/lib/Object/XCOFFObjectFile.cpp

uint8_t XCOFFRelocation<AddressType>::getRelocatedLength() const {
   // The relocation encodes the bit length being relocated minus 1. Add back
   // the 1 to get the actual length being relocated.
   return (Info & XR_BIASED_LENGTH_MASK) + 1;
 }
 
 template struct ExceptionSectionEntry<support::ubig32_t>;
 template struct ExceptionSectionEntry<support::ubig64_t>;
 
+template <typename T>
+Expected<StringRef> getLoaderSecSymNameInStrTbl(const T *LoaderSecHeader,
+                                                uint64_t Offset) {
+  if (LoaderSecHeader->LengthOfStrTbl > Offset)
+    return (reinterpret_cast<const char *>(LoaderSecHeader) +
+            LoaderSecHeader->OffsetToStrTbl + Offset);
+
+  return createError("entry with offset 0x" + Twine::utohexstr(Offset) +
+                     " in the loader section's string table with size 0x" +
+                     Twine::utohexstr(LoaderSecHeader->LengthOfStrTbl) +
+                     " is invalid");
+}
+
+Expected<StringRef> LoaderSectionSymbolEntry32::getSymbolName(
+    const LoaderSectionHeader32 *LoaderSecHeader32) const {
+  const NameOffsetInStrTbl *NameInStrTbl =
+      reinterpret_cast<const NameOffsetInStrTbl *>(SymbolName);
+  if (NameInStrTbl->IsNameInStrTbl != XCOFFSymbolRef::NAME_IN_STR_TBL_MAGIC)
+    return generateXCOFFFixedNameStringRef(SymbolName);
+
+  return getLoaderSecSymNameInStrTbl(LoaderSecHeader32, NameInStrTbl->Offset);
+}
+
+Expected<StringRef> LoaderSectionSymbolEntry64::getSymbolName(
+    const LoaderSectionHeader64 *LoaderSecHeader64) const {
+  return getLoaderSecSymNameInStrTbl(LoaderSecHeader64, Offset);
+}
+
 uintptr_t
 XCOFFObjectFile::getAdvancedSymbolEntryAddress(uintptr_t CurrentAddress,
                                                uint32_t Distance) {
   return getWithOffset(CurrentAddress, Distance * XCOFF::SymbolTableEntrySize);
 }
 
 const XCOFF::SymbolAuxType *
 XCOFFObjectFile::getSymbolAuxType(uintptr_t AuxEntryAddress) const {

llvm/test/tools/llvm-readobj/XCOFF/loader-section-invalid-stringtable-offset.test

+## Test invalid offset to symbol string table of loader section for --loader-section-symbols option.
+
+# RUN: yaml2obj %s -o %t_xcoff.o
+# RUN: llvm-readobj --loader-section-symbols %t_xcoff.o 2>&1 | FileCheck   -DFILE=%t_xcoff.o %s
+
+--- !XCOFF
+FileHeader:
+  MagicNumber:       0x1DF
+Sections:
+  - Name:            .loader
+    Flags:           [ STYP_LOADER ]
+    SectionData:     "0000000100000002000000050000016D00000001000000A40000000c000000506d79696e747661722000028000021105000000000000000000000000000000A2200002840002110a0000000000000000000a66756e63305f5f467600"
+##                    ^-------                                                           -Version=1
+##                            ^-------                                                   -NumberOfSymbolEntries=2
+##                                    ^-------                                           -NumberOfRelocationEntries=5
+##                                            ^-------                                   -LengthOfImportFileIDStringTable=365
+##                                                    ^-------                           -NumberOfImportFileIDs=1
+##                                                            ^-------                   -OffsetToImportFileIDs=0xA4
+##                                                                    ^-------           -LengthOfStringTable=12
+##                                                                            ^-------   -OffsetToStringTable=0x050
+##                                                                                    ^---------------         SymbolName=myintvar
+##                                                                                                    ^------- Value=0x20000280
+##                                                                                                            ^---  sectionNumber = 2
+##                                                                                                                ^- SymbolType=0x11
+##                                                                                                                  ^- StorageClass=0x0a
+##                                                                                                                    ^-------   ImportFileID=0
+##                                                                                                                            ^-------ParameterCheckType=0
+##                                                                                                                                    ^-------SymbolZero=0
+##                                                                                                                                            ^-------OffsetToStringTbl=0xA2 (Invalid)
+##                                                                                                                                                    ^------- Value=20000284
+##                                                                                                                                                            ^---  sectionNumber = 2
+##                                                                                                                                                                ^- SymbolType=0x11
+##                                                                                                                                                                  ^- StorageClass=0x0a
+##                                                                                                                                                                    ^-------   ImportFileID=0
+##                                                                                                                                                                            ^-------ParameterCheckType=0
+##                                                                                                                                                                                    ^StringTable
+
+# CHECK: warning: '[[FILE]]': entry with offset 0xa2 in the loader section's string table with size 0xc is invalid

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

+## Test the --loader-section-symbols option.
+
+# RUN: yaml2obj --docnum=1 -DSYMNUM=2 %s -o %t_xcoff32.o
+# RUN: yaml2obj --docnum=1 -DSYMNUM=4 %s -o %t_xcoff32_invalid.o
+# RUN: yaml2obj --docnum=2 %s -o %t_xcoff64.o
+
+# RUN: llvm-readobj --loader-section-symbols %t_xcoff32.o |\
+# RUN:   FileCheck %s --check-prefixes=CHECK32
+# RUN: llvm-readobj --loader-section-symbols %t_xcoff32_invalid.o 2>&1 |\
+# RUN:   FileCheck -DFILE=%t_xcoff32_invalid.o %s --check-prefixes=CHECK32,WARN
+# RUN: llvm-readobj --loader-section-symbols %t_xcoff64.o |\
+# RUN:   FileCheck %s --check-prefixes=CHECK64
+
+--- !XCOFF
+FileHeader:
+  MagicNumber:       0x1DF
+Sections:
+  - Name:            .loader
+    Flags:           [ STYP_LOADER ]
+    SectionData:     "000000010000000[[SYMNUM]]000000050000016D00000001000000A40000000c000000506d79696e74766172200002800002110500000000000000000000000000000002200002840002110a0000000000000000000a66756e63305f5f467600"
+##                    ^-------                                                           -Version=1
+##                            ^----------------                                                   -NumberOfSymbolEntries=SYMNUM
+##                                             ^-------                                           -NumberOfRelocationEntries=5
+##                                                     ^-------                                   -LengthOfImportFileIDStringTable=365
+##                                                             ^-------                           -NumberOfImportFileIDs=1
+##                                                                     ^-------                   -OffsetToImportFileIDs=0xA4
+##                                                                             ^-------           -LengthOfStringTable=12
+##                                                                                     ^-------   -OffsetToStringTable=0x050
+##                                                                                             ^---------------         SymbolName=myintvar
+##                                                                                                             ^------- Value=0x20000280
+##                                                                                                                     ^---  sectionNumber = 2
+##                                                                                                                         ^- SymbolType=0x11
+##                                                                                                                           ^- StorageClass=0x05
+##                                                                                                                             ^-------   ImportFileID=0
+##                                                                                                                                     ^-------ParameterCheckType=0
+##                                                                                                                                             ^-------SymbolZero=0
+##                                                                                                                                                     ^-------OffsetToSymTbl=2
+##                                                                                                                                                             ^------- Value=20000284
+##                                                                                                                                                                     ^---  sectionNumber = 2
+##                                                                                                                                                                         ^- SymbolType=0x11
+##                                                                                                                                                                           ^- StorageClass=0x0a
+##                                                                                                                                                                              ^-------   ImportFileID=0
+##                                                                                                                                                                                      ^-------ParameterCheckType=0
+##                                                                                                                                                                                              ^StringTable
+
+--- !XCOFF
+FileHeader:
+  MagicNumber:       0x1F7
+Sections:
+  - Name:            .loader
+    Flags:           [ STYP_LOADER ]
+    SectionData:     "0000000200000002000000050000016D000000010000001200000000000000D000000000000000680000000000000038000000000000008000000001100003000000000200021105000000000000000000000001100003080000000d0002110a000000000000000000096d79696e7476617200000a5f5a3566756e6330760000"
+##                    ^-------                                                           -Version=2
+##                            ^-------                                                   -NumberOfSymbolEntries=2
+##                                    ^-------                                           -NumberOfRelocationEntries=5
+##                                            ^-------                                   -LengthOfImportFileIDStringTable=365
+##                                                    ^-------                           -NumberOfImportFileIDs=1
+##                                                            ^-------                   --LengthOfStringTable=0x12
+##                                                                    ^---------------   -OffsetToImportFileIDs=0xD0
+##                                                                                    ^---------------   -OffsetToStringTable=0x68
+##                                                                                                    ^---------------  -OffsetToSymbolTable=0x38
+##                                                                                                                    ^---------------   -OffsetToRelocationEntries=0x80
+##                                                                                                                                    ^---------------         Value=0x0000000110000300
+##                                                                                                                                                    ^------- OffsetToStringTbl=2
+##                                                                                                                                                            ^---  sectionNumber = 2
+##                                                                                                                                                                ^- SymbolType=0x11
+##                                                                                                                                                                  ^- StorageClass=0x05
+##                                                                                                                                                                    ^-------   ImportFileID=0
+##                                                                                                                                                                            ^-------ParameterCheckType=0
+##                                                                                                                                                                                    ^--------------- Value=0x0000000110000308
+##                                                                                                                                                                                                    ^------- OffsetToStringTbl= 0x0d
+##                                                                                                                                                                                                            ^---  sectionNumber = 2
+##                                                                                                                                                                                                                ^- SymbolType=0x11
+##                                                                                                                                                                                                                  ^- StorageClass=0x0a
+##                                                                                                                                                                                                                    ^-------   ImportFileID=0
+##                                                                                                                                                                                                                            ^-------ParameterCheckType=0
+##                                                                                                                                                                                                                                    ^StringTable
+
+# CHECK32:      Loader Section {
+# CHECK32-NEXT:     Loader Section Symbols {
+# CHECK32-NEXT:       Symbol {
+# CHECK32-NEXT:         Name: myintvar
+# CHECK32-NEXT:         Virtual Address: 0x20000280
+# CHECK32-NEXT:         SectionNum: 2
+# CHECK32-NEXT:         SymbolType: 0x11
+# CHECK32-NEXT:         StorageClass: C_EXTDEF (0x5)
+# CHECK32-NEXT:         ImportFileID: 0x0
+# CHECK32-NEXT:         ParameterTypeCheck: 0
+# CHECK32-NEXT:       }
+# CHECK32-NEXT:       Symbol {
+# CHECK32-NEXT:         Name: func0__Fv
+# CHECK32-NEXT:         Virtual Address: 0x20000284
+# CHECK32-NEXT:         SectionNum: 2
+# CHECK32-NEXT:         SymbolType: 0x11
+# CHECK32-NEXT:         StorageClass: C_STRTAG (0xA)
+# CHECK32-NEXT:         ImportFileID: 0x0
+# CHECK32-NEXT:         ParameterTypeCheck: 0
+# CHECK32-NEXT:       }
+# WARN:          warning: '[[FILE]]': The end of the file was unexpectedly encountered
+# CHECK32-NEXT:     }
+# CHECK32-NEXT: }
+
+# CHECK64:      Loader Section {
+# CHECK64-NEXT:     Loader Section Symbols {
+# CHECK64-NEXT:       Symbol {
+# CHECK64-NEXT:         Name: myintvar
+# CHECK64-NEXT:         Virtual Address: 0x110000300
+# CHECK64-NEXT:         SectionNum: 2
+# CHECK64-NEXT:         SymbolType: 0x11
+# CHECK64-NEXT:         StorageClass: C_EXTDEF (0x5)
+# CHECK64-NEXT:         ImportFileID: 0x0
+# CHECK64-NEXT:         ParameterTypeCheck: 0
+# CHECK64-NEXT:       }
+# CHECK64-NEXT:       Symbol {
+# CHECK64-NEXT:         Name: _Z5func0v
+# CHECK64-NEXT:         Virtual Address: 0x110000308
+# CHECK64-NEXT:         SectionNum: 2
+# CHECK64-NEXT:         SymbolType: 0x11
+# CHECK64-NEXT:         StorageClass: C_STRTAG (0xA)
+# CHECK64-NEXT:         ImportFileID: 0x0
+# CHECK64-NEXT:         ParameterTypeCheck: 0
+# CHECK64-NEXT:       }
+# 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(bool PrintHeader) {}
+  virtual void printLoaderSection(bool PrintHeader, bool PrintSymbolTable) {}
 
   // 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_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 loader_section_symbols : FF<"loader-section-symbols" , "Display the loader section symbol table">, 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(bool PrintHeader) override;
+  void printLoaderSection(bool PrintHeader, bool PrintSymbolTable) override;
 
   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:
   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);
+  void printLoaderSectionSymbols(uintptr_t LoaderSectAddr);
+  template <typename LoaderSectionSymbolEntry, typename LoaderSectionHeader>
+  void printLoaderSectionSymbolsHelper(uintptr_t LoaderSectAddr);
   const XCOFFObjectFile &Obj;
 };
 } // 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(bool PrintHeader) {
+void XCOFFDumper::printLoaderSection(bool PrintHeader, bool PrintSymbolTable) {
   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();
 
+  if (LoaderSectionAddr == 0)
+    return;
+
   W.indent();
   if (PrintHeader)
     printLoaderSectionHeader(LoaderSectionAddr);
-  // TODO: Need to print symbol table, relocation entry of loader section later.
+
+  if (PrintSymbolTable)
+    printLoaderSectionSymbols(LoaderSectionAddr);
+
+  // TODO: Need to add printing of relocation entry of loader section later.
   // For example:
-  //           if (PrintSymbolTable)
-  //             printLoaderSectionSymbolTable();
   //           if (PrintRelocation)
   //             printLoaderSectionRelocationEntry();
   W.unindent();
 }
 
 void XCOFFDumper::printLoaderSectionHeader(uintptr_t LoaderSectionAddr) {
   DictScope DS(W, "Loader Section Header");
 
if (Obj.is64Bit()) {
     W.printHex("OffsetToRelocationEntries", LoaderSec64->OffsetToRelEnt);
   } else {
     const LoaderSectionHeader32 *LoaderSec32 =
         reinterpret_cast<const LoaderSectionHeader32 *>(LoaderSectionAddr);
     PrintLoadSecHeaderCommon(LoaderSec32);
   }
 }
 
+const EnumEntry<XCOFF::StorageClass> SymStorageClass[] = {
+#define ECase(X)                                                               \
+  { #X, XCOFF::X }
+    ECase(C_NULL),  ECase(C_AUTO),    ECase(C_EXT),     ECase(C_STAT),
+    ECase(C_REG),   ECase(C_EXTDEF),  ECase(C_LABEL),   ECase(C_ULABEL),
+    ECase(C_MOS),   ECase(C_ARG),     ECase(C_STRTAG),  ECase(C_MOU),
+    ECase(C_UNTAG), ECase(C_TPDEF),   ECase(C_USTATIC), ECase(C_ENTAG),
+    ECase(C_MOE),   ECase(C_REGPARM), ECase(C_FIELD),   ECase(C_BLOCK),
+    ECase(C_FCN),   ECase(C_EOS),     ECase(C_FILE),    ECase(C_LINE),
+    ECase(C_ALIAS), ECase(C_HIDDEN),  ECase(C_HIDEXT),  ECase(C_BINCL),
+    ECase(C_EINCL), ECase(C_INFO),    ECase(C_WEAKEXT), ECase(C_DWARF),
+    ECase(C_GSYM),  ECase(C_LSYM),    ECase(C_PSYM),    ECase(C_RSYM),
+    ECase(C_RPSYM), ECase(C_STSYM),   ECase(C_TCSYM),   ECase(C_BCOMM),
+    ECase(C_ECOML), ECase(C_ECOMM),   ECase(C_DECL),    ECase(C_ENTRY),
+    ECase(C_FUN),   ECase(C_BSTAT),   ECase(C_ESTAT),   ECase(C_GTLS),
+    ECase(C_STTLS), ECase(C_EFCN)
+#undef ECase
+};
+
+template <typename LoaderSectionSymbolEntry, typename LoaderSectionHeader>
+void XCOFFDumper::printLoaderSectionSymbolsHelper(uintptr_t LoaderSectionAddr) {
+  const LoaderSectionHeader *LoadSecHeader =
+      reinterpret_cast<const LoaderSectionHeader *>(LoaderSectionAddr);
+  const LoaderSectionSymbolEntry *LoadSecSymEntPtr =
+      reinterpret_cast<LoaderSectionSymbolEntry *>(
+          LoaderSectionAddr + uintptr_t(LoadSecHeader->getOffsetToSymTbl()));
+
+  for (uint32_t i = 0; i < LoadSecHeader->NumberOfSymTabEnt;
+       ++i, ++LoadSecSymEntPtr) {
+    if (Error E = Binary::checkOffset(
+            Obj.getMemoryBufferRef(),
+            LoaderSectionAddr + uintptr_t(LoadSecHeader->getOffsetToSymTbl()) +
+                (i * sizeof(LoaderSectionSymbolEntry)),
+            sizeof(LoaderSectionSymbolEntry))) {
+      reportUniqueWarning(std::move(E));
+      return;
+    }
+
+    Expected<StringRef> SymbolNameOrErr =
+        LoadSecSymEntPtr->getSymbolName(LoadSecHeader);
+    if (!SymbolNameOrErr) {
+      reportUniqueWarning(SymbolNameOrErr.takeError());
+      return;
+    }
+
+    DictScope DS(W, "Symbol");
+    W.printString("Name", SymbolNameOrErr.get());
+    W.printHex("Virtual Address", LoadSecSymEntPtr->Value);
+    W.printNumber("SectionNum", LoadSecSymEntPtr->SectionNumber);
+    W.printHex("SymbolType", LoadSecSymEntPtr->SymbolType);
+    W.printEnum("StorageClass",
+                static_cast<uint8_t>(LoadSecSymEntPtr->StorageClass),
+                makeArrayRef(SymStorageClass));
+    W.printHex("ImportFileID", LoadSecSymEntPtr->ImportFileID);
+    W.printNumber("ParameterTypeCheck", LoadSecSymEntPtr->ParameterTypeCheck);
+  }
+}
+
+void XCOFFDumper::printLoaderSectionSymbols(uintptr_t LoaderSectionAddr) {
+  DictScope DS(W, "Loader Section Symbols");
+  if (Obj.is64Bit())
+    printLoaderSectionSymbolsHelper<LoaderSectionSymbolEntry64,
+                                    LoaderSectionHeader64>(LoaderSectionAddr);
+  else
+    printLoaderSectionSymbolsHelper<LoaderSectionSymbolEntry32,
+                                    LoaderSectionHeader32>(LoaderSectionAddr);
+}
+
 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()) {
W.printNumber("Index",
                 Obj.getSymbolIndex(reinterpret_cast<uintptr_t>(AuxEntPtr)));
   W.printHex("LengthOfSectionPortion", AuxEntPtr->LengthOfSectionPortion);
   W.printNumber("NumberOfRelocEntries", AuxEntPtr->NumberOfRelocEnt);
   if (Obj.is64Bit())
     W.printEnum("Auxiliary Type", static_cast<uint8_t>(XCOFF::AUX_SECT),
                 makeArrayRef(SymAuxType));
 }
 
-const EnumEntry<XCOFF::StorageClass> SymStorageClass[] = {
-#define ECase(X)                                                               \
-  { #X, XCOFF::X }
-    ECase(C_NULL),  ECase(C_AUTO),    ECase(C_EXT),     ECase(C_STAT),
-    ECase(C_REG),   ECase(C_EXTDEF),  ECase(C_LABEL),   ECase(C_ULABEL),
-    ECase(C_MOS),   ECase(C_ARG),     ECase(C_STRTAG),  ECase(C_MOU),
-    ECase(C_UNTAG), ECase(C_TPDEF),   ECase(C_USTATIC), ECase(C_ENTAG),
-    ECase(C_MOE),   ECase(C_REGPARM), ECase(C_FIELD),   ECase(C_BLOCK),
-    ECase(C_FCN),   ECase(C_EOS),     ECase(C_FILE),    ECase(C_LINE),
-    ECase(C_ALIAS), ECase(C_HIDDEN),  ECase(C_HIDEXT),  ECase(C_BINCL),
-    ECase(C_EINCL), ECase(C_INFO),    ECase(C_WEAKEXT), ECase(C_DWARF),
-    ECase(C_GSYM),  ECase(C_LSYM),    ECase(C_PSYM),    ECase(C_RSYM),
-    ECase(C_RPSYM), ECase(C_STSYM),   ECase(C_TCSYM),   ECase(C_BCOMM),
-    ECase(C_ECOML), ECase(C_ECOMM),   ECase(C_DECL),    ECase(C_ENTRY),
-    ECase(C_FUN),   ECase(C_BSTAT),   ECase(C_ESTAT),   ECase(C_GTLS),
-    ECase(C_STTLS), ECase(C_EFCN)
-#undef ECase
-};
-
 static StringRef GetSymbolValueName(XCOFF::StorageClass SC) {
   switch (SC) {
   case XCOFF::C_EXT:
   case XCOFF::C_WEAKEXT:
   case XCOFF::C_HIDEXT:
   case XCOFF::C_STAT:
   case XCOFF::C_FCN:
   case XCOFF::C_BLOCK:

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

 static bool COFFImports;
 static bool COFFLoadConfig;
 static bool COFFResources;
 static bool COFFTLSDirectory;
 
 // XCOFF specific options.
 static bool XCOFFAuxiliaryHeader;
 static bool XCOFFLoaderSectionHeader;
+static bool XCOFFLoaderSectionSymbol;
 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::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::XCOFFLoaderSectionSymbol = Args.hasArg(OPT_loader_section_symbols);
   opts::XCOFFExceptionSection = Args.hasArg(OPT_exception_section);
 
   opts::InputFilenames = Args.getAllArgValues(OPT_INPUT);
 }
 
 namespace {
 struct ReadObjTypeTableBuilder {
   ReadObjTypeTableBuilder()
if (opts::MachOVersionMin)
       Dumper->printMachOVersionMin();
     if (opts::MachODysymtab)
       Dumper->printMachODysymtab();
     if (opts::CGProfile)
       Dumper->printCGProfile();
   }
 
   if (Obj.isXCOFF()) {
-    if (opts::XCOFFLoaderSectionHeader)
-      Dumper->printLoaderSection(opts::XCOFFLoaderSectionHeader);
+    if (opts::XCOFFLoaderSectionHeader || opts::XCOFFLoaderSectionSymbol)
+      Dumper->printLoaderSection(opts::XCOFFLoaderSectionHeader,
+                                 opts::XCOFFLoaderSectionSymbol);
 
     if (opts::XCOFFExceptionSection)
       Dumper->printExceptionSection();
   }
 
   if (opts::PrintStackMap)
     Dumper->printStackMap();
   if (opts::PrintStackSizes)