[XCOFF] Decode the relocation entries of loader section of xcoff for llvm-readobj

[DiggerLin]

Summary

support decoding the relocation entries of loader section of xcoff for llvm-readobj

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

[jhenderson]

llvm/include/llvm/Object/XCOFFObjectFile.h

253

I was just looking at the XCOFF loader section header spec, and it refers to a l_rdoff field, i.e. the offset of the relocation entries, but this struct here doesn't seem to define an equivalent field. Is this not supposed to represent the actual loader header struct in the file? It seems to me like it is intended to, due to the way the symbol table offset is calculated. (Admittedly, the description for this field contradicts the point of having the field, so I'm not entirely sure what to make of the spec).

llvm/tools/llvm-readobj/ObjDumper.h

158–159

Just spotted errors in this comment. See the Mach-O example below.

163

This field should be PrintRelocations because there can be more than one relocation.

llvm/tools/llvm-readobj/XCOFFDumper.cpp

44

Same as above (PrintRelocations). Also throughout the changes in this file.

286

It might be worth noting that this is a direct quote from the specification. Perhaps adding something like "From the XCOFF specification: there are five ...".

I'd be concerned putting in a detailed quote like this without any form of attribution.

311

Nit

312

This lambda is only used once. What's the motivation for it being a lambda, rather than putting the code directly inline?

325

Again, this lambda is only used once. What's preventing the code being directly written inline?

328–330

Please make sure to reflow again after making the suggested edits.

350

Prefer static_cast not C-style casts.

352

Typo. This appears in the output. Did you just copy the output of the tool to write your test? Be careful...

355

It would be worth factoring this "3" into a named constant in the function. Something like FirstSymbolIndex.

362

Nit: Don't end blocks with a blank line.

369

I'm not sure I follow why this and the if(Obj.is64Bit()) cases need distinguishing?

370

Use static_cast.

372

[DiggerLin]

address James's comment. thanks @jhenderson

[DiggerLin]

llvm/include/llvm/Object/XCOFFObjectFile.h

253

there is document error on (Table 5. Loader Section Header Structure) https://www.ibm.com/docs/en/aix/7.2?topic=formats-xcoff-object-file-format#XCOFF__vra3i31ejbau . We have discuss internally. I implement based in the AIX OS /usr/include/loader.h (When in doubt, the header files should be believed.)

error as:

1. in Table 5. Loader Section Header Structure

the field of l_rldoff (Offset to start of relocation entries) for 32 bits ,is

( -Offset: 36,
 -Length: 2)

but in the loader.h, it looks do not have the field and I used the llvm-objdump --full-contents libtest.a
to decode a 32bit example object file which has loader section . it also do not has the field l_rldoff (for 32bit xcoff object, the loader section head field has 32bytes when dump the data.)

2. there is another error on offset of l_rldoff in 64bits

(-Offset: 64
-Length: 4).

the -Offset:64 should be -Offset: 48 , according to decode a loader section head of 64bits xcoff and loader.h

3. (Table 7. Loader Section Relocation Table Entry Structure.) . According to AIX OS loader.h.

There should be no field "l_value" (Address field) in "Loader Section Relocation Table Entry" both XCOFF32 and XCOFF64.

2. the Length of field "l_rtype" (Relocation type) should be 2 (not 4), and the Offset of "l_rtype" for 32bits should be "Offset:8".

the definiton for 32bit loader section header in the /usr/include/loader.h in AIX OS as

#ifdef __XCOFF32__

typedef struct ldhdr {
	_LONG32		l_version;	/* Loader section version number */
#define _CURRENT_LDR_VERSION	(1)
	_LONG32		l_nsyms;	/* Qty of loader Symbol table entries */
	_LONG32		l_nreloc;	/* Qty of loader relocation table
					   entries */
	_ULONG32	l_istlen;	/* Length of loader import file id
					   strings */
	_LONG32		l_nimpid;	/* Qty of loader import file ids. */
	_ULONG32	l_impoff;	/* Offset to start of loader import
					   file id strings */
	_ULONG32	l_stlen;	/* Length of loader string table */
	_ULONG32	l_stoff;	/* Offset to start of loader string
					   table */
} LDHDR;

#endif /* __XCOFF32__ */

#ifdef __XCOFF64__

typedef struct _S_(ldhdr) {
	_LONG32		l_version;	/* Loader section version number */

#ifdef __XCOFF32__
#define _CURRENT_LDR_VERSION_64	(2)
#else
#define _CURRENT_LDR_VERSION	(2)
#endif

	_LONG32		l_nsyms;	/* Qty of loader Symbol table entries */
	_LONG32		l_nreloc;	/* Qty of loader relocation table
					   entries */
	_ULONG32	l_istlen;	/* Length of loader import file id
					   strings */
	_LONG32		l_nimpid;	/* Qty of loader import file ids. */
	_ULONG32	l_stlen;	/* Length of loader string table */
	unsigned long long l_impoff;	/* Offset to start of loader import
					   file id strings */
	unsigned long long l_stoff;	/* Offset to start of loader string
					   table */
	unsigned long long l_symoff;	/* Offset to start of loader symbol
					   table */
	unsigned long long l_rldoff;	/* Offset to start of loader rlds */
} _S_(LDHDR);

#ifdef __XCOFF32__
#define	LDHDRSZ_64	sizeof(LDHDR_64)
#endif

llvm/tools/llvm-readobj/ObjDumper.h

163

I think whether to use "PrintSymbolTables" instead of "PrintSymbolTable" when I implement the decoding the symbol table of loader section. I think PrintSymbolTable can explain the we want to print symbol table out. (and we only one symbol table in the loader section, we have multi symbol table entries in the symbol table. ) the same reason for the PrintRelocation. if the parameter name is "PrintRelocationEntry", we should be change to "PrintRelocationEntries"

llvm/tools/llvm-readobj/XCOFFDumper.cpp

311

sorry about that

312

agree with you.

328–330

thanks

352

sorry, yes, But I used the patch to decode the relocations of the loader section of big lib which I copied from the /usr/lib and compare with the gnu objdump and compare the output , there has the same relocations result.

369

the fields order of relocation entry is different between 32bit and 64bit, I just keep the same order of the object file. not keeping the same order of the object file is OK for me. If you strong suggest me to not keep the order of object file. I can change it.

[jhenderson]

llvm/include/llvm/Object/XCOFFObjectFile.h

253

Thanks for the explanation, it makes sense. In the future though, I'd put such lengthy comments out-of-line, as they make it harder to follow the code!

llvm/tools/llvm-readobj/ObjDumper.h

163

Your analogy is flawed: "Relocation" and "SymbolTable" are not referring to the same kind of thing.

There is exactly one symbol table, hence why it is singular. The relocation entries consist of one or more relocations: "relocation entry" is just a verbose way of saying "relocation". The term for a group of relocations could be "relocation table" or "relocation section" (see ELF for good examples of this throughout). In other words, "relocation" is the same sort of thing as a "symbol". You could change the PrintSymbolTable parameter to PrintSymbols, but not to PrintSymbol for example.

llvm/tools/llvm-readobj/XCOFFDumper.cpp

334–336

As this expression is getting quite long, it might be worth splitting it into two or three local variables for ease of reading.

341

Test case for this warning?

369

FWIW, I don't think it's important to have the order match the data structure order, if there are reasons to do something else. In this case it will simplify code, and also people consuming this won't have to special case whatever scripts they write to handle the order being different.

[DiggerLin]

llvm/tools/llvm-readobj/ObjDumper.h

163

thanks

llvm/tools/llvm-readobj/XCOFFDumper.cpp

341

I am not sure whether we need to test Symbol Name error in all different patch, we have the same test for the code
in https://github.com/llvm/llvm-project/blob/main/llvm/tools/llvm-readobj/XCOFFDumper.cpp#L234

[jhenderson]

llvm/tools/llvm-readobj/XCOFFDumper.cpp

341

This isn't about testing the internal generation of the error, this is about testing that the library-generated error is properly handled in the tool code (i.e. it's reported to stderr, and not thrown away, for example).

[DiggerLin]

added a new test case to test invalid symbol name for relocation.

[jhenderson]

Essentially looks reasonable to me, although I haven't verified that all the call paths are properly covered by tests. @Esme or another XCOFF developer should take a look at this before landing it.

FYI, my last day working before Christmas is next Friday, and I may have limited reviewing time next week. I won't be back and able to review things further after that until late January.

[DiggerLin]

In D136787#3965951, @jhenderson wrote:

Essentially looks reasonable to me, although I haven't verified that all the call paths are properly covered by tests. @Esme or another XCOFF developer should take a look at this before landing it.

FYI, my last day working before Christmas is next Friday, and I may have limited reviewing time next week. I won't be back and able to review things further after that until late January.

Thanks, James, have a good vacation. @jhenderson

[Esme]

Feel sorry that i'm just getting started to review this patch.
I've applied the patch and test the functionality and it looks good overall. Thanks.
However, considering the printing format of relocations in llvm-readobj, when --expand-relocs is not specified, we usually print relocations in this format:

vaddr     section    type   symbol
20000294    2       POS   .data
2000029c    2       POS   0

Only when --expand-relocs is specified, we print relocations like the format in this patch.
The --dyn-relocations option also follows such rule.

@jhenderson What do you think?

llvm/include/llvm/Object/XCOFFObjectFile.h

243

I noticed an extra field of l_value for Loader Section Relocation Table Entry Structure specified by the doc, is it also a doc error?

[Esme]

Btw. Do you have any plans to implement an option like "--loader-section" to embrace all this loader section related information?

[DiggerLin]

In D136787#3977618, @Esme wrote:

Btw. Do you have any plans to implement an option like "--loader-section" to embrace all this loader section related information?

Yes, after I have a plan to implement the option "--loader-section" and I also have plan to reimplement of "[llvm-readobj][XCOFF] Add support for --needed-libs option." which will print the needed-libs in the "loader sections"

[DiggerLin]

added a new no expand relocation format.

[Esme]

llvm/tools/llvm-readobj/XCOFFDumper.cpp

318–320

Prefer to move the code (lines 315~317) into the else code block below (line 353).

319

We seem to be more accustomed to abbreviating Section as Sec, is it more meaningful to change RelSect to SecNum?

365–366

[DiggerLin]

added decode size of relocation type in --expand-relocs

[jhenderson]

Some nits, but the idea of implementing expand relocs behaviour here seems reasonable to me. This will likely be my last post on this review until I'm back at the end of January. Feel free to not wait any further on me.

llvm/tools/llvm-readobj/XCOFFDumper.cpp

319

I would actually here print "Section" or "SectionIndex". Ultimately though, do the same as we do for ELF, I recommend.

320

Text intended to be read by humans should have spaces between words...

350

Perhaps worth putting the ExpandRelocs behaviour into a small helper function (not a lambda), just to avoid making this function too long.

359–361

Word wrapping has gone weird here.

[DiggerLin]

In D136787#3977618, @Esme wrote:

Btw. Do you have any plans to implement an option like "--loader-section" to embrace all this loader section related information?

llvm/include/llvm/Object/XCOFFObjectFile.h

243

yes, this is doc error. I have mention it in comment which I response to James.

llvm/tools/llvm-readobj/XCOFFDumper.cpp

318–320

if move the lines into "else code block below (line 353)." , it is in the loop , it will cause the "Vaddr Type SecNum SymbolName(Index)" be printed multi time. (this is only head line.)

319

thanks

319

in AIX doc , it always use SectionNumber, and all implement of llvm tools, it always use SectionNumber. not Section Index.

[Esme]

This comment was removed by Esme.

[Esme]

LGTM. Thanks!

[jhenderson]

llvm/tools/llvm-readobj/XCOFFDumper.cpp

321–322

Nit: this word wrapping wasn't fixed when the code was moved. Please make an NFC commit (no review needed) to fix it.

llvm/docs/CommandGuide/llvm-readobj.rst

 .. option:: --loader-section-header
 
   Display XCOFF loader section header.
 
 .. option:: --loader-section-symbols
 
   Display symbol table of loader section.
 
+.. option:: --loader-section-relocations
+
+  Display relocation entries 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/BinaryFormat/XCOFF.h

 constexpr size_t ExceptionSectionEntrySize64 = 10;
 constexpr uint16_t RelocOverflow = 65535;
 constexpr uint8_t AllocRegNo = 31;
 
 enum ReservedSectionNum : int16_t { N_DEBUG = -2, N_ABS = -1, N_UNDEF = 0 };
 
 enum MagicNumber : uint16_t { XCOFF32 = 0x01DF, XCOFF64 = 0x01F7 };
 
+// Masks for packing/unpacking the r_rsize field of relocations.
+
+// The msb is used to indicate if the bits being relocated are signed or
+// unsigned.
+static constexpr uint8_t XR_SIGN_INDICATOR_MASK = 0x80;
+// The 2nd msb is used to indicate that the binder has replaced/modified the
+// original instruction.
+static constexpr uint8_t XR_FIXUP_INDICATOR_MASK = 0x40;
+// The remaining bits specify the bit length of the relocatable reference
+// minus one.
+static constexpr uint8_t XR_BIASED_LENGTH_MASK = 0x3f;
+
 // This field only exists in the XCOFF64 definition.
 enum AuxHeaderFlags64 : uint16_t {
   SHR_SYMTAB = 0x8000,  ///< At exec time, create shared symbol table for program
                         ///< (main program only).
   FORK_POLICY = 0x4000, ///< Forktree policy specified (main program only).
   FORK_COR = 0x2000     ///< If _AOUT_FORK_POLICY is set, specify copy-on-reference
                         ///< if this bit is set. Specify copy-on- write otherwise.
                         ///< If _AOUT_FORK_POLICY is 0, this bit is reserved for

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 {
-  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 LoaderSectionHeader32;
+struct LoaderSectionHeader64;
 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.
struct LoaderSectionSymbolEntry64 {
   XCOFF::StorageClass StorageClass;
   support::ubig32_t ImportFileID;
   support::ubig32_t ParameterTypeCheck;
 
   Expected<StringRef>
   getSymbolName(const LoaderSectionHeader64 *LoaderSecHeader) const;
 };
 
+struct LoaderSectionRelocationEntry32 {
+  support::ubig32_t VirtualAddr;
+  support::big32_t SymbolIndex;
+  support::ubig16_t Type;
+  support::big16_t SectionNum;
+};
+
+struct LoaderSectionRelocationEntry64 {
+  support::ubig64_t VirtualAddr;
+  support::ubig16_t Type;
+  support::big16_t SectionNum;
+  support::big32_t SymbolIndex;
+};
+
+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);
+  }
+
+  uint64_t getOffsetToRelEnt() const {
+    // Relocation table is after Symbol table.
+    return NumberOfRelTabEnt == 0
+               ? 0
+               : sizeof(LoaderSectionHeader32) +
+                     sizeof(LoaderSectionSymbolEntry32) * NumberOfSymTabEnt;
+  }
+};
+
+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; }
+  uint64_t getOffsetToRelEnt() const { return OffsetToRelEnt; }
+};
+
 template <typename AddressType> struct ExceptionSectionEntry {
   union {
     support::ubig32_t SymbolIdx;
     AddressType TrapInstAddr;
   };
   uint8_t LangId;
   uint8_t Reason;
 

 struct XCOFFSectAuxEntForDWARF64 {
   support::ubig64_t LengthOfSectionPortion;
   support::ubig64_t NumberOfRelocEnt;
   uint8_t Pad;
   XCOFF::SymbolAuxType AuxType; // Contains _AUX_SECT; Type of Auxillary entry
 };
 
 template <typename AddressType> struct XCOFFRelocation {
-  // Masks for packing/unpacking the r_rsize field of relocations.
-
-  // The msb is used to indicate if the bits being relocated are signed or
-  // unsigned.
-  static constexpr uint8_t XR_SIGN_INDICATOR_MASK = 0x80;
-
-  // The 2nd msb is used to indicate that the binder has replaced/modified the
-  // original instruction.
-  static constexpr uint8_t XR_FIXUP_INDICATOR_MASK = 0x40;
-
-  // The remaining bits specify the bit length of the relocatable reference
-  // minus one.
-  static constexpr uint8_t XR_BIASED_LENGTH_MASK = 0x3f;
-
 public:
   AddressType VirtualAddress;
   support::ubig32_t SymbolIndex;
 
   // Packed field, see XR_* masks for details of packing.
   uint8_t Info;
 
   XCOFF::RelocationType Type;

llvm/test/tools/llvm-readobj/XCOFF/loader-section-relocation-invalid-sym-name.test

+## Test invalid offset to symbol string table of loader section for --loader-section-relocations option.
+
+# RUN: yaml2obj %s -o %t_xcoff.o
+# RUN: llvm-readobj --loader-section-relocations %t_xcoff.o 2>&1 | FileCheck -DFILE=%t_xcoff.o %s
+
+--- !XCOFF
+FileHeader:
+  MagicNumber:       0x1DF
+Sections:
+  - Name:            .loader
+    Flags:           [ STYP_LOADER ]
+    SectionData:     "0000000100000001000000020000016D00000001000000A40000000c0000005000000000000000A22000028000021105000000000000000020000294000000011f0000022000029c000000031f000002000a66756e63305f5f467600"
+##                    ^-------                                                           -Version=1
+##                            ^-------                                                   -NumberOfSymbolEntries=1
+##                                    ^-------                                           -NumberOfRelocationEntries=2
+##                                            ^-------                                   -LengthOfImportFileIDStringTable=365
+##                                                    ^-------                           -NumberOfImportFileIDs=1
+##                                                            ^-------                   -OffsetToImportFileIDs=0xA4
+##                                                                    ^-------           -LengthOfStringTable=12
+##                                                                            ^-------   -OffsetToStringTable=0x050
+##                                                                                    ^-------SymbolZero=0
+##                                                                                            ^-------OffsetToStringTbl=0xA2 (Invalid)
+##                                                                                                    ^------- Value=0x20000280
+##                                                                                                            ^---  sectionNumber = 2
+##                                                                                                                ^- SymbolType=0x11
+##                                                                                                                  ^- StorageClass=0x05
+##                                                                                                                    ^-------   ImportFileID=0
+##                                                                                                                            ^-------ParameterCheckType=0
+##                                                                                                                                    ^-------    Virtual Address = 0x20000294
+##                                                                                                                                            ^------- SymbolIndex = 1
+##                                                                                                                                                    ^--- Type =0x1f
+##                                                                                                                                                        ^--- Section Num =2
+##                                                                                                                                                            ^-------    Virtual Address = 0x20000294
+##                                                                                                                                                                    ^------- SymbolIndex = 3
+##                                                                                                                                                                            ^--- Type =0x1f
+##                                                                                                                                                                                ^--- Section Num =2
+##                                                                                                                                                                                    ^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-relocation.test

+## Test the --loader-section-relocations option.
+
+# RUN: yaml2obj --docnum=1 %s -o %t_xcoff32.o
+# RUN: yaml2obj --docnum=2  %s -o %t_xcoff64.o
+# RUN: llvm-readobj --loader-section-relocations --expand-relocs %t_xcoff32.o | FileCheck --check-prefixes=COMMON,EXPAND %s
+# RUN: llvm-readobj --loader-section-relocations --expand-relocs %t_xcoff64.o | FileCheck --check-prefixes=COMMON,EXPAND %s
+# RUN: llvm-readobj --loader-section-relocations %t_xcoff32.o | FileCheck --check-prefixes=COMMON,NOEXPAND32 %s
+# RUN: llvm-readobj --loader-section-relocations %t_xcoff64.o | FileCheck --check-prefixes=COMMON,NOEXPAND64 %s
+
+--- !XCOFF
+FileHeader:
+  MagicNumber:       0x1DF
+Sections:
+  - Name:            .loader
+    Flags:           [ STYP_LOADER ]
+    SectionData:     "0000000100000001000000020000016D00000001000000A400000000000000506d79696e747661722000028000021105000000000000000020000294000000011f0000022000029c000000031f000002"
+##                    ^-------                                                           -Version=1
+##                            ^-------                                                   -NumberOfSymbolEntries=1
+##                                    ^-------                                           -NumberOfRelocationEntries=2
+##                                            ^-------                                   -LengthOfImportFileIDStringTable=365
+##                                                    ^-------                           -NumberOfImportFileIDs=1
+##                                                            ^-------                   -OffsetToImportFileIDs=0xA4
+##                                                                    ^-------           -LengthOfStringTable=0
+##                                                                            ^-------   -OffsetToStringTable=0
+##                                                                                    ^---------------         SymbolName=myintvar
+##                                                                                                    ^------- Value=0x20000280
+##                                                                                                            ^---  sectionNumber = 2
+##                                                                                                                ^- SymbolType=0x11
+##                                                                                                                  ^- StorageClass=0x05
+##                                                                                                                    ^-------   ImportFileID=0
+##                                                                                                                            ^-------ParameterCheckType=0
+##                                                                                                                                    ^-------    Virtual Address = 0x20000294
+##                                                                                                                                            ^------- SymbolIndex = 1
+##                                                                                                                                                    ^--- Type =0x1f00
+##                                                                                                                                                        ^--- Section Num =2
+##                                                                                                                                                            ^-------    Virtual Address = 0x20000294
+##                                                                                                                                                                    ^------- SymbolIndex = 3
+##                                                                                                                                                                            ^--- Type =0x1f00
+##                                                                                                                                                                                ^--- Section Num =2
+
+--- !XCOFF
+FileHeader:
+  MagicNumber:       0x1F7
+Sections:
+  - Name:            .loader
+    Flags:           [ STYP_LOADER ]
+    SectionData:     "0000000200000001000000020000016D000000010000001200000000000000D000000000000000700000000000000038000000000000005000000001100003000000000200021105000000000000000000000000200002941f00000200000001000000002000029C1f0000020000000300096d79696e747661720000"
+##                    ^-------                                                           -Version=2
+##                            ^-------                                                   -NumberOfSymbolEntries=1
+##                                    ^-------                                           -NumberOfRelocationEntries=2
+##                                            ^-------                                   -LengthOfImportFileIDStringTable=365
+##                                                    ^-------                           -NumberOfImportFileIDs=1
+##                                                            ^-------                   --LengthOfStringTable=0x12
+##                                                                    ^---------------   -OffsetToImportFileIDs=0xD0
+##                                                                                    ^---------------   -OffsetToStringTable=0x70
+##                                                                                                    ^---------------  -OffsetToSymbolTable=0x38
+##                                                                                                                    ^---------------   -OffsetToRelocationEntries=0x50
+##                                                                                                                                    ^---------------         Value=0x0000000110000300
+##                                                                                                                                                    ^------- OffsetToStringTbl=2
+##                                                                                                                                                            ^---  sectionNumber = 2
+##                                                                                                                                                                ^- SymbolType=0x11
+##                                                                                                                                                                  ^- StorageClass=0x05
+##                                                                                                                                                                    ^-------   ImportFileID=0
+##                                                                                                                                                                            ^-------ParameterCheckType=0
+##                                                                                                                                                                                    ^--------------- VirtualAddress= 0x20000294
+##                                                                                                                                                                                                    ^--- Type= 1f00
+##                                                                                                                                                                                                        ^---SectionNumber = 2
+##                                                                                                                                                                                                            ^------- SymbolIndex =1
+##                                                                                                                                                                                                                    ^--------------- VirtualAddress= 0x2000029C
+##                                                                                                                                                                                                                                    ^--- Type= 1f00
+##                                                                                                                                                                                                                                        ^---SectionNumber = 2
+##                                                                                                                                                                                                                                            ^------- SymbolIndex =3
+##                                                                                                                                                                                                                                                    ^-------------------StringTable 
+  
+# COMMON:      Loader Section {
+# COMMON-NEXT:     Loader Section Relocations {
+# NOEXPAND64-NEXT:           Vaddr            Type        SecNum  SymbolName (Index)
+# NOEXPAND64-NEXT:     0x0000000020000294 0x1f00 (R_POS)       2    .data (1)
+# NOEXPAND64-NEXT:     0x000000002000029c 0x1f00 (R_POS)       2    myintvar (3)
+# NOEXPAND32-NEXT:        Vaddr        Type        SecNum  SymbolName (Index)
+# NOEXPAND32-NEXT:      0x20000294 0x1f00 (R_POS)       2    .data (1)
+# NOEXPAND32-NEXT:      0x2000029c 0x1f00 (R_POS)       2    myintvar (3)
+# EXPAND-NEXT:       Relocation {
+# EXPAND-NEXT:         Virtual Address: 0x20000294
+# EXPAND-NEXT:         Symbol: .data (1)
+# EXPAND-NEXT:         IsSigned: No
+# EXPAND-NEXT:         FixupBitValue: 0
+# EXPAND-NEXT:         Length: 32
+# EXPAND-NEXT:         Type: R_POS (0x0)
+# EXPAND-NEXT:         SectionNumber: 2
+# EXPAND-NEXT:       }
+# EXPAND-NEXT:       Relocation {
+# EXPAND-NEXT:         Virtual Address: 0x2000029C
+# EXPAND-NEXT:         Symbol: myintvar (3)
+# EXPAND-NEXT:         IsSigned: No
+# EXPAND-NEXT:         FixupBitValue: 0
+# EXPAND-NEXT:         Length: 32
+# EXPAND-NEXT:         Type: R_POS (0x0)
+# EXPAND-NEXT:         SectionNumber: 2
+# EXPAND-NEXT:       }
+# EXPAND-NEXT:     }
+# EXPAND-NEXT: }

llvm/tools/llvm-readobj/ObjDumper.h

public:
   virtual void printCodeViewDebugInfo() { }
   virtual void
   mergeCodeViewTypes(llvm::codeview::MergingTypeTableBuilder &CVIDs,
                      llvm::codeview::MergingTypeTableBuilder &CVTypes,
                      llvm::codeview::GlobalTypeTableBuilder &GlobalCVIDs,
                      llvm::codeview::GlobalTypeTableBuilder &GlobalCVTypes,
                      bool GHash) {}
 
-  // Only implement for XCOFF
+  // Only implemented for XCOFF.
+  virtual void printStringTable() {}
   virtual void printAuxiliaryHeader() {}
   virtual void printExceptionSection() {}
-  virtual void printLoaderSection(bool PrintHeader, bool PrintSymbolTable) {}
+  virtual void printLoaderSection(bool PrintHeader, bool PrintSymbols,
+                                  bool PrintRelocations) {}
 
   // Only implemented for MachO.
   virtual void printMachODataInCode() { }
   virtual void printMachOVersionMin() { }
   virtual void printMachODysymtab() { }
   virtual void printMachOSegment() { }
   virtual void printMachOIndirectSymbols() { }
   virtual void printMachOLinkerOptions() { }
 
-  // Currently only implemented for XCOFF.
-  virtual void printStringTable() { }
-
   virtual void printStackMap() const = 0;
 
   void printAsStringList(StringRef StringContent, size_t StringDataOffset = 0);
 
   void printSectionsAsString(const object::ObjectFile &Obj,
                              ArrayRef<std::string> Sections);
   void printSectionsAsHex(const object::ObjectFile &Obj,
                           ArrayRef<std::string> Sections);

llvm/tools/llvm-readobj/Opts.td

 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 loader_section_relocations : FF<"loader-section-relocations" , "Display the loader section relocation entries">, 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, bool PrintSymbolTable) override;
+  void printLoaderSection(bool PrintHeader, bool PrintSymbols,
+                          bool PrintRelocations) 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 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);
+  template <typename LoadSectionRelocTy>
+  void printLoaderSectionRelocationEntry(LoadSectionRelocTy *LoaderSecRelEntPtr,
+                                         StringRef SymbolName);
+  void printLoaderSectionRelocationEntries(uintptr_t LoaderSectAddr);
+  template <typename LoaderSectionHeader, typename LoaderSectionSymbolEntry,
+            typename LoaderSectionRelocationEntry>
+  void printLoaderSectionRelocationEntriesHelper(uintptr_t LoaderSectAddr);
+
   const XCOFFObjectFile &Obj;
+  const static int32_t FirstSymIdxOfLoaderSec = 3;
 };
 } // 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, bool PrintSymbolTable) {
+void XCOFFDumper::printLoaderSection(bool PrintHeader, bool PrintSymbols,
+                                     bool PrintRelocations) {
   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);
 
-  if (PrintSymbolTable)
+  if (PrintSymbols)
     printLoaderSectionSymbols(LoaderSectionAddr);
 
-  // TODO: Need to add printing of relocation entry of loader section later.
-  // For example:
-  //           if (PrintRelocation)
-  //             printLoaderSectionRelocationEntry();
+  if (PrintRelocations)
+    printLoaderSectionRelocationEntries(LoaderSectionAddr);
+
   W.unindent();
 }
 
 void XCOFFDumper::printLoaderSectionHeader(uintptr_t LoaderSectionAddr) {
   DictScope DS(W, "Loader Section Header");
 
   auto PrintLoadSecHeaderCommon = [&](const auto *LDHeader) {
     W.printNumber("Version", LDHeader->Version);
void XCOFFDumper::printLoaderSectionSymbols(uintptr_t LoaderSectionAddr) {
   if (Obj.is64Bit())
     printLoaderSectionSymbolsHelper<LoaderSectionSymbolEntry64,
                                     LoaderSectionHeader64>(LoaderSectionAddr);
   else
     printLoaderSectionSymbolsHelper<LoaderSectionSymbolEntry32,
                                     LoaderSectionHeader32>(LoaderSectionAddr);
 }
 
+const EnumEntry<XCOFF::RelocationType> RelocationTypeNameclass[] = {
+#define ECase(X)                                                               \
+  { #X, XCOFF::X }
+    ECase(R_POS),    ECase(R_RL),     ECase(R_RLA),    ECase(R_NEG),
+    ECase(R_REL),    ECase(R_TOC),    ECase(R_TRL),    ECase(R_TRLA),
+    ECase(R_GL),     ECase(R_TCL),    ECase(R_REF),    ECase(R_BA),
+    ECase(R_BR),     ECase(R_RBA),    ECase(R_RBR),    ECase(R_TLS),
+    ECase(R_TLS_IE), ECase(R_TLS_LD), ECase(R_TLS_LE), ECase(R_TLSM),
+    ECase(R_TLSML),  ECase(R_TOCU),   ECase(R_TOCL)
+#undef ECase
+};
+
+// From the XCOFF specification: there are five implicit external symbols, one
+// each for the .text, .data, .bss, .tdata, and .tbss sections. These symbols
+// are referenced from the relocation table entries using symbol table index
+// values 0, 1, 2, -1, and -2, respectively.
+static const char *getImplicitLoaderSectionSymName(int SymIndx) {
+  switch (SymIndx) {
+  default:
+    return "Unkown Symbol Name";
+  case -2:
+    return ".tbss";
+  case -1:
+    return ".tdata";
+  case 0:
+    return ".text";
+  case 1:
+    return ".data";
+  case 2:
+    return ".bss";
+  }
+}
+
+template <typename LoadSectionRelocTy>
+void XCOFFDumper::printLoaderSectionRelocationEntry(
+    LoadSectionRelocTy *LoaderSecRelEntPtr, StringRef SymbolName) {
+  uint16_t Type = LoaderSecRelEntPtr->Type;
+  if (opts::ExpandRelocs) {
+    DictScope DS(W, "Relocation");
+    auto IsRelocationSigned = [](uint8_t Info) {
+      return Info & XCOFF::XR_SIGN_INDICATOR_MASK;
+    };
+    auto IsFixupIndicated = [](uint8_t Info) {
+      return Info & XCOFF::XR_FIXUP_INDICATOR_MASK;
+    };
+    auto GetRelocatedLength = [](uint8_t Info) {
+      // The relocation encodes the bit length being relocated minus 1. Add
+      // back
+      //   the 1 to get the actual length being relocated.
+      return (Info & XCOFF::XR_BIASED_LENGTH_MASK) + 1;
+    };
+
+    uint8_t Info = Type >> 8;
+    W.printHex("Virtual Address", LoaderSecRelEntPtr->VirtualAddr);
+    W.printNumber("Symbol", SymbolName, LoaderSecRelEntPtr->SymbolIndex);
+    W.printString("IsSigned", IsRelocationSigned(Info) ? "Yes" : "No");
+    W.printNumber("FixupBitValue", IsFixupIndicated(Info) ? 1 : 0);
+    W.printNumber("Length", GetRelocatedLength(Info));
+    W.printEnum("Type", static_cast<uint8_t>(Type),
+                makeArrayRef(RelocationTypeNameclass));
+    W.printNumber("SectionNumber", LoaderSecRelEntPtr->SectionNum);
+  } else {
+    W.startLine() << format_hex(LoaderSecRelEntPtr->VirtualAddr,
+                                Obj.is64Bit() ? 18 : 10)
+                  << " " << format_hex(Type, 6) << " ("
+                  << XCOFF::getRelocationTypeString(
+                         static_cast<XCOFF::RelocationType>(Type))
+                  << ")" << format_decimal(LoaderSecRelEntPtr->SectionNum, 8)
+                  << "    " << SymbolName << " ("
+                  << LoaderSecRelEntPtr->SymbolIndex << ")\n";
+  }
+}
+
+template <typename LoaderSectionHeader, typename LoaderSectionSymbolEntry,
+          typename LoaderSectionRelocationEntry>
+void XCOFFDumper::printLoaderSectionRelocationEntriesHelper(
+    uintptr_t LoaderSectionAddr) {
+  const LoaderSectionHeader *LoaderSec =
+      reinterpret_cast<const LoaderSectionHeader *>(LoaderSectionAddr);
+  const LoaderSectionRelocationEntry *LoaderSecRelEntPtr =
+      reinterpret_cast<const LoaderSectionRelocationEntry *>(
+          LoaderSectionAddr + uintptr_t(LoaderSec->getOffsetToRelEnt()));
+
+  if (!opts::ExpandRelocs)
+    W.startLine() << center_justify("Vaddr", Obj.is64Bit() ? 18 : 10)
+                  << center_justify("Type", 15) << right_justify("SecNum", 8)
+                  << center_justify("SymbolName (Index) ", 24) << "\n";
+
+  for (uint32_t i = 0; i < LoaderSec->NumberOfRelTabEnt;
+       ++i, ++LoaderSecRelEntPtr) {
+    StringRef SymbolName;
+    if (LoaderSecRelEntPtr->SymbolIndex >= FirstSymIdxOfLoaderSec) {
+      // Because there are implicit symbol index values (-2, -1, 0, 1, 2),
+      // LoaderSecRelEnt.SymbolIndex - FirstSymIdxOfLoaderSec will get the
+      // real symbol from the symbol table.
+      const uint64_t SymOffset =
+          (LoaderSecRelEntPtr->SymbolIndex - FirstSymIdxOfLoaderSec) *
+          sizeof(LoaderSectionSymbolEntry);
+      const LoaderSectionSymbolEntry *LoaderSecRelSymEntPtr =
+          reinterpret_cast<LoaderSectionSymbolEntry *>(
+              LoaderSectionAddr + uintptr_t(LoaderSec->getOffsetToSymTbl()) +
+              SymOffset);
+
+      Expected<StringRef> SymbolNameOrErr =
+          LoaderSecRelSymEntPtr->getSymbolName(LoaderSec);
+      if (!SymbolNameOrErr) {
+        reportUniqueWarning(SymbolNameOrErr.takeError());
+        return;
+      }
+      SymbolName = SymbolNameOrErr.get();
+    } else
+      SymbolName =
+          getImplicitLoaderSectionSymName(LoaderSecRelEntPtr->SymbolIndex);
+
+    printLoaderSectionRelocationEntry(LoaderSecRelEntPtr, SymbolName);
+  }
+}
+
+void XCOFFDumper::printLoaderSectionRelocationEntries(
+    uintptr_t LoaderSectionAddr) {
+  DictScope DS(W, "Loader Section Relocations");
+
+  if (Obj.is64Bit())
+    printLoaderSectionRelocationEntriesHelper<LoaderSectionHeader64,
+                                              LoaderSectionSymbolEntry64,
+                                              LoaderSectionRelocationEntry64>(
+        LoaderSectionAddr);
+  else
+    printLoaderSectionRelocationEntriesHelper<LoaderSectionHeader32,
+                                              LoaderSectionSymbolEntry32,
+                                              LoaderSectionRelocationEntry32>(
+        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()) {

 
 void XCOFFDumper::printRelocations() {
   if (Obj.is64Bit())
     printRelocations<XCOFFSectionHeader64, XCOFFRelocation64>(Obj.sections64());
   else
     printRelocations<XCOFFSectionHeader32, XCOFFRelocation32>(Obj.sections32());
 }
 
-const EnumEntry<XCOFF::RelocationType> RelocationTypeNameclass[] = {
-#define ECase(X)                                                               \
-  { #X, XCOFF::X }
-    ECase(R_POS),    ECase(R_RL),     ECase(R_RLA),    ECase(R_NEG),
-    ECase(R_REL),    ECase(R_TOC),    ECase(R_TRL),    ECase(R_TRLA),
-    ECase(R_GL),     ECase(R_TCL),    ECase(R_REF),    ECase(R_BA),
-    ECase(R_BR),     ECase(R_RBA),    ECase(R_RBR),    ECase(R_TLS),
-    ECase(R_TLS_IE), ECase(R_TLS_LD), ECase(R_TLS_LE), ECase(R_TLSM),
-    ECase(R_TLSML),  ECase(R_TOCU),   ECase(R_TOCL)
-#undef ECase
-};
-
 template <typename RelTy> void XCOFFDumper::printRelocation(RelTy Reloc) {
   Expected<StringRef> ErrOrSymbolName =
       Obj.getSymbolNameByIndex(Reloc.SymbolIndex);
   if (Error E = ErrOrSymbolName.takeError()) {
     reportUniqueWarning(std::move(E));
     return;
   }
   StringRef SymbolName = *ErrOrSymbolName;

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

 static bool COFFLoadConfig;
 static bool COFFResources;
 static bool COFFTLSDirectory;
 
 // XCOFF specific options.
 static bool XCOFFAuxiliaryHeader;
 static bool XCOFFLoaderSectionHeader;
 static bool XCOFFLoaderSectionSymbol;
+static bool XCOFFLoaderSectionRelocation;
 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::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::XCOFFLoaderSectionRelocation =
+      Args.hasArg(OPT_loader_section_relocations);
   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 || opts::XCOFFLoaderSectionSymbol)
+    if (opts::XCOFFLoaderSectionHeader || opts::XCOFFLoaderSectionSymbol ||
+        opts::XCOFFLoaderSectionRelocation)
       Dumper->printLoaderSection(opts::XCOFFLoaderSectionHeader,
-                                 opts::XCOFFLoaderSectionSymbol);
+                                 opts::XCOFFLoaderSectionSymbol,
+                                 opts::XCOFFLoaderSectionRelocation);
 
     if (opts::XCOFFExceptionSection)
       Dumper->printExceptionSection();
   }
 
   if (opts::PrintStackMap)
     Dumper->printStackMap();
   if (opts::PrintStackSizes)