[XCOFF][AIX] Generate symbol table entries with llvm-readobj

[jasonliu]

Summary

This patch implements main entry and auxiliary entries of symbol table generation for llvm-readobj on AIX.
The source code of aix_xcoff_xlc_test8.o (compile with xlc) is:

-bash-4.2$ cat test8.c
extern int i;
extern int TestforXcoff;
extern int fun(int i);
static int static_i;
char* p="abcd";
int fun1(int j) {
  static_i++;
  j++;
  j=j+*p;
  return j;
}
int main() {
  i++;
  fun(i);
  return fun1(i);
}

Patch provided by DiggerLin. I'm posting this on his behalf as he is currently on vacation.

[sfertile]

llvm/include/llvm/Object/XCOFFObjectFile.h

129

minor nit: Was this supposed to be NamePad?

151

minor nit: IndexofNextEntry --> IndexOfNextEntry.

llvm/lib/Object/XCOFFObjectFile.cpp

467

I think this is the wrong interface for this function. Taking a pointer to an XCOFFSymbolEntry ends up making us cast a bunch of symbol table entries to a type they clearly are not to get their Symbol index. Instead we should take a unitptr_t.

621

minor nit: place the assert as the first statement in the function.

622

Use a reinterpret_cast instead of a c-style cast.

A though about the implementation of this function:
We are converting the address in the DataRefImpl to an XCOFFSymbolEntry and doing the pointer arithmetic on that type and it works because all symbol table entries have the same size as this structiure. But why convert in the first place? Instead we can calculate the address using getWithOffset. That code would be equally valid for 64-bit and 32-bit XCOFF objects.

assert(hasCSectAuxEnt());
uintptr_t AuxAddr = getWithOffset(SymEntDataRef.p, SYM_TAB_ENTRY_SIZE * getNumberOfAuxEntries());
return reiterpret_cast<const XCOFFCSectAuxEnt *>(AuxAddr);

655

If we fail to find a section, then should a StorageMappingClass of XMC_PR be enough to determine the symbol is a function?

llvm/tools/llvm-readobj/XCOFFDumper.cpp

124

When we fix the interface to getSymbolIndex we can get rid of this function.

131

This is the cast I find confusing. We have a pointer to a structure of type XCOFFFileAuxEnt and we have to cast it to something it is not to get the symbol table entries index.

[abrachet]

llvm/include/llvm/Object/XCOFFObjectFile.h

162–167

How do these and the other structs work? They have seemingly random padding that align these on non normal boundaries. Assuming this is the file format, why is there no need for #pragma pack or aligans? If we take just this type as an example 18 bytes worth of members, wont this be aligned by the compiler to 24 bytes?

[sfertile]

llvm/include/llvm/Object/XCOFFObjectFile.h

162–167

Assuming this is the file format, why is there no need for #pragma pack or aligans? If we take just this type as an example 18 bytes worth of members, wont this be aligned by the compiler to 24 bytes?

No: because none of the members used have an alignment greater then 1. support::[u]bigN_t types are 1 byte aligned, and the only other types used are char and uint8_t.

How do these and the other structs work? They have seemingly random padding that align these on non normal boundaries.

Most (maybe all) are described here: https://www.ibm.com/support/knowledgecenter/en/ssw_aix_72/filesreference/XCOFF.html#XCOFF__yaa3i18fjbau There is also a set of headers shipped as part of the OS that describes them but they are much harder to decipher. I'm not sure if the headers are available on the internet but hopefully @hubert.reinterpretcast or @cebowleratibm can point you to them if they are.

Each of them being 18 bytes in size is expected, once you know that and that there is no alignment restriction on the 2 and 4 byte types used the padding layout should no longer seem so random.

[jasonliu]

llvm/lib/Object/XCOFFObjectFile.cpp

655

In a single .o file, then maybe XMC_PR is enough to determine the symbol is a function.
But I'm not sure if that's the case for a executable/dynamic library where linker could regroup the functions in a different way.
I'm open to suggestions if there is a better way to do this.

[jasonliu]

Gentle ping.

[sfertile]

llvm/include/llvm/Object/XCOFFObjectFile.h

152

We should open a defect against the XCOFF object file docs, it list the pading as length 1 which is incorrect.

llvm/lib/Object/XCOFFObjectFile.cpp

125

We can remove the second argument to generateStringRef and use XCOFF::NameSize directly in the implementation, since all calls use the same value for the argument.

467

Looks good. One suggestion is to have some error checking similar to what we have in checkSectionAddress .

647

label define --> label definition.

655

Sorry, I don't have any helpful suggestions. I'm not familiar enough with XCOFF to know when/how it uses absolute symbols. I think this current implementation is OK for now. It might lead to missing information in llvm-readobj but we can refine it as our understanding grows.

llvm/test/tools/llvm-readobj/xcoff-symbols.test

2

Add the source used, compiler, and options used to genetrate the object file in a comment.

Also it seems that we have added several constructs that are not exercised in the test: Block Aux Entry, Dwarf Aux Entry, Function Aux Ent. If these aren't tested then remove them from this patch and we can add them in a subsequent patch.

llvm/tools/llvm-readobj/XCOFFDumper.cpp

257

We are adding a bunch of cases which aren't tested. Would it be better to add these cases with an assert and implement them in a future patch which also adds the missing test coverage?

[hubert.reinterpretcast]

llvm/include/llvm/BinaryFormat/XCOFF.h

23

Please commit the removal of SectionNameSize and SymbolNameSize separately from this patch. This conflicts with other Phabricator reviews in flight.

[jasonliu]

llvm/include/llvm/Object/XCOFFObjectFile.h

152

Will do.

[sfertile]

llvm/include/llvm/BinaryFormat/XCOFF.h

23

We should commit this as a NFC patch and then rebase this patch to reflect the change.

llvm/lib/Object/XCOFFObjectFile.cpp

466

Why a pointer to a unitptr_t, shouldn't the argument just be a unitptr_t?

473

Should also check that the address isn't larger then the end of the symbol table.

llvm/test/tools/llvm-readobj/xcoff-symbols.test

2

Sorry I wasn't explicit before: the Run steps should be at the top of the file. Ideally the source and compile command would be at the end of the file.

[jasonliu]

llvm/include/llvm/BinaryFormat/XCOFF.h

23

I was planning to land this first. Then when dust settles(https://reviews.llvm.org/D65159), have a NFC patch to remove those enums.
In this way, we could have less dependencies.
The more pedantic way is of course to land that NFC before this patch and D65159, then rebase these two patches.
Have a slightly preference on my original plan because of less action on both end.
But if you think it's better to land that NFC first, let me know and I could do that.

[sfertile]

llvm/include/llvm/BinaryFormat/XCOFF.h

23

I do think its worthwhile to land the enum name change first and rebase the patches. I understand it introduces a bit of extra work but I think its worth the small bit of time it takes.

[jasonliu]

llvm/include/llvm/BinaryFormat/XCOFF.h

23

Sure. When the NFC patch is available, I will rebase this patch to reflect that.

[sfertile]

llvm/include/llvm/BinaryFormat/XCOFF.h

23

Committed in https://reviews.llvm.org/rL368584

[jasonliu]

Rebased on latest trunk.

[jasonliu]

I believe I addressed the existing comments. Looking for more comments or approval. Thanks!

[hubert.reinterpretcast]

llvm/include/llvm/Object/XCOFFObjectFile.h

115

XCOFFCSectAuxEnt32.

117

This does not hold the hash value itself, so ParameterHashIndex.

121

StabInfoIndex, like ParameterHashIndex.

122

StabSecNum, like TypeChkSectNum.

[hubert.reinterpretcast]

llvm/include/llvm/Object/XCOFFObjectFile.h

136

ReservedZeroes?

137

Add at least a comment to indicate that this field is XCOFF64-specific.

291

Stray top-level const on a parameter declaration not attached to a function definition.

llvm/test/tools/llvm-readobj/xcoff-symbols.test

22

There is no such field defined for XCOFF32.

[hubert.reinterpretcast]

llvm/lib/Object/XCOFFObjectFile.cpp

466

Top-level const on parameter types are known to cause grief with certain build compilers.

467

Type error. The answer fits into 32-bits after being divided by 18, but not necessarily before that.

467

I suggest moving this to after the error checking.

477

>=. The calculation on the RHS points "one-past-the-end".

[hubert.reinterpretcast]

llvm/include/llvm/Object/XCOFFObjectFile.h

308

Make both fields const if we don't need to modify them.

312

Parameter variable name does not match the prevalent style.

317

There's no reason to add XCoff to the set of ways we capitalize XCOFF. We already use XCOFF even when we capitalize the next word in names.

320

Newline before this to split the derived-property functions from the field accessors.

[jhenderson]

llvm/test/tools/llvm-readobj/xcoff-symbols.test

2

A few test comments from me:

Add a brief comment to the top of the file explaining the purpose of the test.

You don't need to prepend the RUN: lines with a '#' character.

Add a single blank line between the end of the RUN: lines and the start of the CHECK patterns.

I take it yaml2obj doesn't have XCOFF support? Assuming that's the case, is it possible to use something like llvm-mc to build this at test time rather than use the pre-canned binary? In general we've been trying to avoid adding pre-canned binaries to the llvm-readobj tests, as they are opaque and hard to maintain.

[sfertile]

llvm/lib/Object/XCOFFObjectFile.cpp

478

getWithOffset?

llvm/test/tools/llvm-readobj/xcoff-symbols.test

2

I take it yaml2obj doesn't have XCOFF support? Assuming that's the case, is it possible to use something like llvm-mc to build this at test time rather than use the pre-canned binary? In general we've been trying to avoid adding pre-canned binaries to the llvm-readobj tests, as they are opaque and hard to maintain.

We are using the pre-canned binaries for testing since we need the tools support first, to be able to write lit tests as we add backend XCOFF functionality. Once we have enough functionality in the XCOFFObjectWriter we can remove the pre-canned binaries and generate them with llvm-mc as you suggest.

[jasonliu]

llvm/include/llvm/Object/XCOFFObjectFile.h

122

Changed it to StabSectNum.

llvm/test/tools/llvm-readobj/xcoff-symbols.test

2

Thanks for the comments. Addressed them in the new revision.

Yes, we haven't implement XCOFF support for yaml2obj yet. And llvm-mc do not yet have enough functionality to generate all the symbol entries kind for our testing, although we are working towards that goal. And we are actually going to use llvm-readobj to test the correctness of our llvm-mc obj gen.
So there is a chicken-and-egg problem here for us. And what we are choosing to do is to use a pre-canned binary that we know is correct (generated from xlc) to test the correctness of the tooling (llvm-readobj). Then later use this tooling to test the object file generated by llc/llvm-mc.

22

Removed this for printing XCOFF32.

[jasonliu]

I addressed all the comments I see.
Thanks for the reviewing.

[jhenderson]

llvm/test/tools/llvm-readobj/xcoff-symbols.test

2

Fair enough. Another way to resolve this, which was used for minidump support, was implement support in yaml2obj for XCOFF, and test using gtest unit-testing. yaml2obj can then be used to generate objects for llvm-readobj testing, which can in turn verify llvm-mc and other tools.

[hubert.reinterpretcast]

llvm/include/llvm/Object/XCOFFObjectFile.h

307

I meant this line (re: const) as well.

317

Might as well use Csect here while we are at this for this patch (see D65159).

llvm/lib/Object/XCOFFObjectFile.cpp

128

Please common up some of the code between this and getSymbolName. We might be able to go with one template function implementation for both of these interfaces to use.

467

getSymbolIndex is a strange place for the error checking to occur. We already got a SymbolEntPtr, and we might have used it already. We should move the error checking out to a separate function and call it where appropriate (perhaps at each place where we retrieve a handle to a symbol table entry, or perhaps only when jumping by an index).

670

Global replace CSect with Csect in code (note: not the same for English).

674

To explain the code, add a comment to indicate that the csect auxiliary entry is, for symbols that have them in XCOFF32, the last auxiliary entry.

676

Might make sense to call the error checking function here.

688

s/Sc/SC;

704

Newline before the comment. Clarify the comment as saying that we are expecting function definitions to be label definitions.

llvm/test/tools/llvm-readobj/xcoff-symbols.test

2

s/generate/display the/;
s/for/for a/;

17

TB_C = 0,
TB_CPLUSPLUS = 9,

18

TCPU_PPC64 = 2,
TCPU_COM = 3,
TCPU_970 = 19,

110

Global replace "CSect" with "CSECT" in English.

427

The filename is test8.c.

llvm/tools/llvm-readobj/XCOFFDumper.cpp

28

Given the way it is used, this should be something like SymbolAlignmentBitOffset.

253

Assert XCOFF32. This entry type does not exist for XCOFF64.

[hubert.reinterpretcast]

llvm/lib/Object/XCOFFObjectFile.cpp

22

This is unused, and this should be something like RELOC_LNNO_OVERFLOW if we were to have it in this patch.

llvm/tools/llvm-readobj/XCOFFDumper.cpp

134

Use static_cast.

243

If the previous line did not need the cast to do the bitwise-and, then neither does this one. Also, remove the redundant parentheses.

245

Use static_cast.

257

Overflow handling is not here, and there is no TODO.

303

Add a period to the end of the sentence.
Replace llvm_unreachable(x) with assert(false && x) here. I guess the assert makes sense to have (in place of just a TODO), so that developers can clue in when they are running this utility on an object with the unimplemented kinds.

[hubert.reinterpretcast]

llvm/tools/llvm-readobj/XCOFFDumper.cpp

311

s/unimplmented/unimplemented/;

341

Use static_cast.

350

s/entires/entries/;
Replace the period with an ellipsis. What is here is not a sentence.

351

Yes, the name should be ".file", but I don't think there is sufficient rationale to skip processing the auxiliary entries if the name isn't.

361

s/is Function/is for a function/;

365

Can we have some rationale here for not printing the first auxiliary entry if it is not also the last?
Also, please fix the spacing, capitalization, etc.

368

Remove the " are print out" part. It is clear that it is being printed out.

370

SYM_TAB_ENTRY_SIZE might make more sense (since we are not really talking about an XCOFFSymbolEntry object).

370

Use reinterpret_cast.

381

This is unsafe. There is no statement I could find indicating that such an auxiliary entry is required, and xlc will generate such symbol table entries with no auxiliary entry.

[16]    m   0x00000094     .data     1  unamex                    _$STATIC
[17]    a4  0x00000004       0    0     SD       RW    0    0
[18]    m   0x00000094     .data     0  static                    x

392

See comments above.

394

See comments above.

398

Add a newline between the functions.

[hubert.reinterpretcast]

llvm/tools/llvm-readobj/XCOFFDumper.cpp

376

printCsectAuxEnt32(XCOFFSymRef.getXCOFFCsectAuxEnt32()).

[jasonliu]

llvm/lib/Object/XCOFFObjectFile.cpp

22

Yes, removed it from the patch.

@DiggerLin
Please note this change might be needed for the upcoming relocation patch.

467

Hopefully, I covered all the cases that we needed to call the checker function.

llvm/tools/llvm-readobj/XCOFFDumper.cpp

381

We have

if (NumberOfAuxEntries == 0)
    return;

before this switch statement. If there is no aux entry, we would exit already before getting here.

[jasonliu]

llvm/tools/llvm-readobj/XCOFFDumper.cpp

117

Will add a new line before this function.

[jasonliu]

llvm/tools/llvm-readobj/XCOFFDumper.cpp

257

Discussed offline, the overflow handling is for section auxiliary header, not for symbol auxiliary entry.

[hubert.reinterpretcast]

Looking through this latest version still (this is a largish patch).

llvm/tools/llvm-readobj/XCOFFDumper.cpp

381

Ah, yes. As a further consideration, I think we should do something about having more than one auxiliary entry here.

[hubert.reinterpretcast]

Looks like the patch is getting close.

llvm/include/llvm/BinaryFormat/XCOFF.h

167

Use "64-bit".

llvm/include/llvm/Object/XCOFFObjectFile.h

195

This function is sufficiently generic that we can just say that it returns string table entries (and name it appropriately).

llvm/lib/Object/XCOFFObjectFile.cpp

90

Ref.p is a uintptr_t, so this can be moved to before the viewAs.

119

Use "end-of-symbol-table".

151

Remove "or .debug section" as this function does not cover this case (at least not yet).

161

This is more generically "Bad offset for string table entry".

182

generateStringRef got modified in an NFC patch I believe. The uses in this patch make it more obvious that the one-argument version of that function should not be named so generically. Perhaps generateXCOFFFixedNameStringRef?

llvm/tools/llvm-readobj/XCOFFDumper.cpp

166

I think we should treat this as code.

257

I've experimented with XLC, and confirmed that it does not do the overflow handling for these fields. It will populate these with the low bits of the logical value.

[hubert.reinterpretcast]

llvm/tools/llvm-readobj/XCOFFDumper.cpp

257

I think we can have a comment here that, unlike the corresponding fields in the section header, these fields do not handle values greater than 65535.

[jasonliu]

Addressed all the new comments.

llvm/lib/Object/XCOFFObjectFile.cpp

182

Agree. The name should give more information on what it is trying to do.

llvm/tools/llvm-readobj/XCOFFDumper.cpp

381

Could C_STAT symbol have more than 1 aux entry? I added an assertion for that.

[hubert.reinterpretcast]

llvm/tools/llvm-readobj/XCOFFDumper.cpp

381

Can we make that a report_fatal_error? It is an error in the user-provided input, so we should report the error.

[jasonliu]

llvm/tools/llvm-readobj/XCOFFDumper.cpp

381

Right. I will make it a report_fatal_error in the commit or next revision.

[hubert.reinterpretcast]

LGTM with minor comments.

llvm/tools/llvm-readobj/XCOFFDumper.cpp

294

Newline before the comment.

440

s/could/should/;

llvm/include/llvm/BinaryFormat/XCOFF.h

 #define LLVM_BINARYFORMAT_XCOFF_H
 
 #include <cstdint>
 
 namespace llvm {
 namespace XCOFF {
 
 // Constants used in the XCOFF definition.
-enum { SectionNameSize = 8, SymbolNameSize = 8 };
+enum {
+  NameSize = 8,
+  FileNamePadSize = 6
+};
+
 enum ReservedSectionNum { N_DEBUG = -2, N_ABS = -1, N_UNDEF = 0 };
 
 // x_smclas field of x_csect from system header: /usr/include/syms.h
 /// Storage Mapping Class definitions.
-enum StorageMappingClass {
+enum StorageMappingClass : uint8_t {
   //     READ ONLY CLASSES
   XMC_PR = 0,      ///< Program Code
   XMC_RO = 1,      ///< Read Only Constant
   XMC_DB = 2,      ///< Debug Dictionary Table
   XMC_GL = 6,      ///< Global Linkage (Interfile Interface Code)
   XMC_XO = 7,      ///< Extended Operation (Pseudo Machine Instruction)
   XMC_SV = 8,      ///< Supervisor Call (32-bit process only)
   XMC_SV64 = 17,   ///< Supervisor Call for 64-bit process

 enum SymbolType {
   XTY_ER = 0, ///< External reference.
   XTY_SD = 1, ///< Csect definition for initialized storage.
   XTY_LD = 2, ///< Label definition.
               ///< Defines an entry point to an initialized csect.
   XTY_CM = 3  ///< Common csect definition. For uninitialized storage.
 };
 
+enum CFileStringType : uint8_t {
+  XFT_FN = 0,  ///< Specifies the source-file name.
+  XFT_CT = 1,  ///< Specifies the compiler time stamp.
+  XFT_CV = 2,  ///< Specifies the compiler version number.
+  XFT_CD = 128 ///< Specifies compiler-defined information.
+};
+
 } // end namespace XCOFF
 } // end namespace llvm
 
 #endif

llvm/include/llvm/Object/XCOFFObjectFile.h

struct XCOFFFileHeader64 {
 
   support::ubig64_t SymbolTableOffset; // File offset to symbol table.
   support::ubig16_t AuxHeaderSize;
   support::ubig16_t Flags;
   support::ubig32_t NumberOfSymTableEntries;
 };
 
 struct XCOFFSectionHeader32 {
-  char Name[XCOFF::SectionNameSize];
+  char Name[XCOFF::NameSize];
   support::ubig32_t PhysicalAddress;
   support::ubig32_t VirtualAddress;
   support::ubig32_t SectionSize;
   support::ubig32_t FileOffsetToRawData;
   support::ubig32_t FileOffsetToRelocationInfo;
   support::ubig32_t FileOffsetToLineNumberInfo;
   support::ubig16_t NumberOfRelocations;
   support::ubig16_t NumberOfLineNumbers;
   support::big32_t Flags;
 
   StringRef getName() const;
 };
 
 struct XCOFFSectionHeader64 {
-  char Name[XCOFF::SectionNameSize];
+  char Name[XCOFF::NameSize];
   support::ubig64_t PhysicalAddress;
   support::ubig64_t VirtualAddress;
   support::ubig64_t SectionSize;
   support::big64_t FileOffsetToRawData;
   support::big64_t FileOffsetToRelocationInfo;
   support::big64_t FileOffsetToLineNumberInfo;
   support::ubig32_t NumberOfRelocations;
   support::ubig32_t NumberOfLineNumbers;
struct XCOFFSymbolEntry {
   } NameInStrTblType;
 
   typedef struct {
     uint8_t LanguageId;
     uint8_t CpuTypeId;
   } CFileLanguageIdAndTypeIdType;
 
   union {
-    char SymbolName[XCOFF::SymbolNameSize];
+    char SymbolName[XCOFF::NameSize];
     NameInStrTblType NameInStrTbl;
   };
 
   support::ubig32_t Value; // Symbol value; storage class-dependent.
   support::big16_t SectionNumber;
 
   union {
     support::ubig16_t SymbolType;
     CFileLanguageIdAndTypeIdType CFileLanguageIdAndTypeId;
   };
 
   XCOFF::StorageClass StorageClass;
   uint8_t NumberOfAuxEntries;
 };
 
 struct XCOFFStringTable {
   uint32_t Size;
   const char *Data;
 };
 
+struct XCOFFCSectAuxEnt {
+  support::ubig32_t SectionLen;
+  support::ubig32_t ParameterHash;
+  support::ubig16_t TypeChkSectNum;
+  uint8_t SymbolAlignmentAndType;
+  XCOFF::StorageMappingClass StorageMappingClass;
+  support::ubig32_t Stab;
+  support::ubig16_t Snstab;
+};
+
+struct XCOFFFileAuxEnt {
+  typedef struct {
+    support::big32_t Magic; // Zero indicates name in string table.
+    support::ubig32_t Offset;
+    char NamePad[XCOFF::FileNamePadSize];
+  } NameInStrTblType;
+  union {
+    char Name[XCOFF::NameSize + XCOFF::FileNamePadSize];
+    NameInStrTblType NameInStrTbl;
+  };
+  XCOFF::CFileStringType Type;
+  uint8_t ReservedZero[2];
+  uint8_t AuxType;
+};
+
+struct XCOFFBlockAuxEnt {
+  char Reserved[2];
+  support::ubig16_t SourceLineNumHi;
+  support::ubig16_t SourceLineNumLo;
+  char Pad[12];
+};
+
+struct XCOFFFunctionAuxEnt {
+  support::ubig32_t OffsetToExceptionTable;
+  support::ubig32_t FunctionSize;
+  support::ubig32_t FilePointerToLineNum;
+  support::ubig32_t IndexOfNextEntry;
+  char Pad[2];
+};
+
+struct XCOFFSectAuxEntForStat {
+  support::ubig32_t SectionLength;
+  support::ubig16_t NumberOfRelocEnt;
+  support::ubig16_t NumberOfLineNum;
+  uint8_t Pad[10];
+};
+
+struct XCOFFSectAuxEntForDwarf {
+  support::ubig32_t SectionLength;
+  uint8_t Pad1[4];
+  support::ubig32_t NumberOfRelocEnt;
+  uint8_t Pad2[6];
+};
+
 class XCOFFObjectFile : public ObjectFile {
 private:
   const void *FileHeader = nullptr;
   const void *SectionHeaderTable = nullptr;
 
   const XCOFFSymbolEntry *SymbolTblPtr = nullptr;
   XCOFFStringTable StringTable = {0, nullptr};
 
private:
   const XCOFFSectionHeader64 *toSection64(DataRefImpl Ref) const;
   void checkSectionAddress(uintptr_t Addr, uintptr_t TableAddr) const;
   uintptr_t getSectionHeaderTableAddress() const;
 
   // This returns a pointer to the start of the storage for the name field of
   // the 32-bit or 64-bit SectionHeader struct. This string is *not* necessarily
   // null-terminated.
   const char *getSectionNameInternal(DataRefImpl Sec) const;
-
-  int32_t getSectionFlags(DataRefImpl Sec) const;
-
   static bool isReservedSectionNumber(int16_t SectionNumber);
-  Expected<DataRefImpl> getSectionByNum(int16_t Num) const;
 
   // Constructor and "create" factory function. The constructor is only a thin
   // wrapper around the base constructor. The "create" function fills out the
   // XCOFF-specific information and performs the error checking along the way.
   XCOFFObjectFile(unsigned Type, MemoryBufferRef Object);
   static Expected<std::unique_ptr<XCOFFObjectFile>> create(unsigned Type,
                                                            MemoryBufferRef MBR);
 
public:
   // Note that this value is signed and might return a negative value. Negative
   // values are reserved for future use.
   int32_t getRawNumberOfSymbolTableEntries32() const;
 
   // The sanitized value appropriate to use as an index into the symbol table.
   uint32_t getLogicalNumberOfSymbolTableEntries32() const;
 
   uint32_t getNumberOfSymbolTableEntries64() const;
+  uint32_t getSymbolIndex(const XCOFFSymbolEntry *SymEntPtr) const;
+  uint32_t getSymbolIndex(const uintptr_t *SymEntPtr) const;
 
+  Expected<StringRef> getCFileName(const XCOFFFileAuxEnt *CFileEntPtr) const;
   uint16_t getOptionalHeaderSize() const;
   uint16_t getFlags() const;
 
   // Section header table related interfaces.
   ArrayRef<XCOFFSectionHeader32> sections32() const;
   ArrayRef<XCOFFSectionHeader64> sections64() const;
+
+  int32_t getSectionFlags(DataRefImpl Sec) const;
+  Expected<DataRefImpl> getSectionByNum(int16_t Num) const;
 }; // XCOFFObjectFile
 
+class XCOFFSymbolRef {
+  DataRefImpl SymEntDataRef;
+  const XCOFFObjectFile *OwningObjectPtr;
+
+public:
+  XCOFFSymbolRef(DataRefImpl SymEntDataRef,
+                 const XCOFFObjectFile *owningObjectPtr)
+      : SymEntDataRef(SymEntDataRef), OwningObjectPtr(owningObjectPtr){};
+
+  XCOFF::StorageClass getStorageClass() const;
+  uint8_t getNumberOfAuxEntries() const;
+  const XCOFFCSectAuxEnt *getXCoffCSectAuxEnt() const;
+  uint16_t getType() const;
+  int16_t getSectionNumber() const;
+  bool hasCSectAuxEnt() const;
+  bool isFunction() const;
+};
+
 } // namespace object
 } // namespace llvm
 
 #endif // LLVM_OBJECT_XCOFFOBJECTFILE_H

llvm/lib/Object/XCOFFObjectFile.cpp

 
 #include "llvm/Object/XCOFFObjectFile.h"
 #include <cstddef>
 #include <cstring>
 
 namespace llvm {
 namespace object {
 
+enum {
+  FUNCTION_SYM = 0x20,
+  RELOC_OVERFLOW = 65535,
+  SYM_TAB_ENTRY_SIZE = 18,
+  SYM_TYPE_MASK = 0x07
+};
+
 // Checks that [Ptr, Ptr + Size) bytes fall inside the memory buffer
 // 'M'. Returns a pointer to the underlying object on success.
 template <typename T>
 static Expected<const T *> getObject(MemoryBufferRef M, const void *Ptr,
                                      const uint64_t Size = sizeof(T)) {
   uintptr_t Addr = uintptr_t(Ptr);
   if (std::error_code EC = Binary::checkOffset(M, Addr, Size))
     return errorCodeToError(EC);
#endif
   return viewAs<XCOFFSectionHeader64>(Ref.p);
 }
 
 const XCOFFSymbolEntry *XCOFFObjectFile::toSymbolEntry(DataRefImpl Ref) const {
   assert(!is64Bit() && "Symbol table support not implemented for 64-bit.");
   assert(Ref.p != 0 && "Symbol table pointer can not be nullptr!");
   auto SymEntPtr = viewAs<XCOFFSymbolEntry>(Ref.p);
   return SymEntPtr;
 }
 
 const XCOFFFileHeader32 *XCOFFObjectFile::fileHeader32() const {
   assert(!is64Bit() && "32-bit interface called on 64-bit object file.");
   return static_cast<const XCOFFFileHeader32 *>(FileHeader);
 }
 
 const XCOFFFileHeader64 *XCOFFObjectFile::fileHeader64() const {
   assert(is64Bit() && "64-bit interface called on a 32-bit object file.");
XCOFFObjectFile::sectionHeaderTable64() const {
   return static_cast<const XCOFFSectionHeader64 *>(SectionHeaderTable);
 }
 
 void XCOFFObjectFile::moveSymbolNext(DataRefImpl &Symb) const {
   const XCOFFSymbolEntry *SymEntPtr = toSymbolEntry(Symb);
   SymEntPtr += SymEntPtr->NumberOfAuxEntries + 1;
   Symb.p = reinterpret_cast<uintptr_t>(SymEntPtr);
 }
 
+Expected<StringRef>
+XCOFFObjectFile::getCFileName(const XCOFFFileAuxEnt *CFileEntPtr) const {
+
+  if (CFileEntPtr->NameInStrTbl.Magic !=
+      XCOFFSymbolEntry::NAME_IN_STR_TBL_MAGIC)
+    return generateStringRef(CFileEntPtr->Name, XCOFF::NameSize);
+
+  uint32_t Offset = CFileEntPtr->NameInStrTbl.Offset;
+  if (Offset < 4)
+    return StringRef(nullptr, 0);
+
+  if (StringTable.Data != nullptr && StringTable.Size > Offset)
+    return (StringTable.Data + Offset);
+
+  return make_error<GenericBinaryError>("CFile Name parse failed.",
+                                        object_error::parse_failed);
+}
+
 Expected<StringRef> XCOFFObjectFile::getSymbolName(DataRefImpl Symb) const {
   const XCOFFSymbolEntry *SymEntPtr = toSymbolEntry(Symb);
 
   if (SymEntPtr->NameInStrTbl.Magic != XCOFFSymbolEntry::NAME_IN_STR_TBL_MAGIC)
-    return generateStringRef(SymEntPtr->SymbolName, XCOFF::SymbolNameSize);
+    return generateStringRef(SymEntPtr->SymbolName, XCOFF::NameSize);
 
   // A storage class value with the high-order bit on indicates that the name is
   // a symbolic debugger stabstring.
   if (SymEntPtr->StorageClass & 0x80)
     return StringRef("Unimplemented Debug Name");
 
   uint32_t Offset = SymEntPtr->NameInStrTbl.Offset;
   // The byte offset is relative to the start of the string table
   // or .debug section. A byte offset value of 0 is a null or zero-length symbol
   // name. A byte offset in the range 1 to 3 (inclusive) points into the length
   // field; as a soft-error recovery mechanism, we treat such cases as having an
   // offset of 0.
   if (Offset < 4)
     return StringRef(nullptr, 0);
 
   if (StringTable.Data != nullptr && StringTable.Size > Offset)
     return (StringTable.Data + Offset);
 
   return make_error<GenericBinaryError>("Symbol Name parse failed",
                                         object_error::parse_failed);
 }
 
 Expected<uint64_t> XCOFFObjectFile::getSymbolAddress(DataRefImpl Symb) const {
   uint64_t Result = 0;
   llvm_unreachable("Not yet implemented!");
   return Result;
 }
 
 uint64_t XCOFFObjectFile::getSymbolValueImpl(DataRefImpl Symb) const {
+  assert(!is64Bit() && "Symbol table support not implemented for 64-bit.");
   return toSymbolEntry(Symb)->Value;
 }
 
 uint64_t XCOFFObjectFile::getCommonSymbolSizeImpl(DataRefImpl Symb) const {
   uint64_t Result = 0;
   llvm_unreachable("Not yet implemented!");
   return Result;
 }
 
 Expected<SymbolRef::Type>
 XCOFFObjectFile::getSymbolType(DataRefImpl Symb) const {
   llvm_unreachable("Not yet implemented!");
   return SymbolRef::ST_Other;
 }
 
 Expected<section_iterator>
 XCOFFObjectFile::getSymbolSection(DataRefImpl Symb) const {
   const XCOFFSymbolEntry *SymEntPtr = toSymbolEntry(Symb);

 }
 
 void XCOFFObjectFile::moveSectionNext(DataRefImpl &Sec) const {
   const char *Ptr = reinterpret_cast<const char *>(Sec.p);
   Sec.p = reinterpret_cast<uintptr_t>(Ptr + getSectionHeaderSize());
 }
 
 Expected<StringRef> XCOFFObjectFile::getSectionName(DataRefImpl Sec) const {
-  return generateStringRef(getSectionNameInternal(Sec), XCOFF::SectionNameSize);
+  return generateStringRef(getSectionNameInternal(Sec), XCOFF::NameSize);
 }
 
 uint64_t XCOFFObjectFile::getSectionAddress(DataRefImpl Sec) const {
   // Avoid ternary due to failure to convert the ubig32_t value to a unit64_t
   // with MSVC.
   if (is64Bit())
     return toSection64(Sec)->VirtualAddress;
 
XCOFFObjectFile::getSymbolSectionName(const XCOFFSymbolEntry *SymEntPtr) const {
   case XCOFF::N_ABS:
     return "N_ABS";
   case XCOFF::N_UNDEF:
     return "N_UNDEF";
   default:
     Expected<DataRefImpl> SecRef = getSectionByNum(SectionNum);
     if (SecRef)
       return generateStringRef(getSectionNameInternal(SecRef.get()),
-                               XCOFF::SectionNameSize);
+                               XCOFF::NameSize);
     return SecRef.takeError();
   }
 }
 
 bool XCOFFObjectFile::isReservedSectionNumber(int16_t SectionNumber) {
   return (SectionNumber <= 0 && SectionNumber >= -2);
 }
 

 uint64_t XCOFFObjectFile::getSymbolTableOffset64() const {
   return fileHeader64()->SymbolTableOffset;
 }
 
 uint32_t XCOFFObjectFile::getNumberOfSymbolTableEntries64() const {
   return fileHeader64()->NumberOfSymTableEntries;
 }
 
+uint32_t XCOFFObjectFile::getSymbolIndex(const uintptr_t *SymbolEntPtr) const {
+  return (reinterpret_cast<const char *>(SymbolEntPtr) -
+          reinterpret_cast<const char *>(SymbolTblPtr)) /
+         SYM_TAB_ENTRY_SIZE;
+}
+
 uint16_t XCOFFObjectFile::getFlags() const {
   return is64Bit() ? fileHeader64()->Flags : fileHeader32()->Flags;
 }
 
 const char *XCOFFObjectFile::getSectionNameInternal(DataRefImpl Sec) const {
   return is64Bit() ? toSection64(Sec)->Name : toSection32(Sec)->Name;
 }
 
 uintptr_t XCOFFObjectFile::getSectionHeaderTableAddress() const {
   return reinterpret_cast<uintptr_t>(SectionHeaderTable);
 }
 
 int32_t XCOFFObjectFile::getSectionFlags(DataRefImpl Sec) const {
   return is64Bit() ? toSection64(Sec)->Flags : toSection32(Sec)->Flags;
 }

 
 Expected<std::unique_ptr<ObjectFile>>
 ObjectFile::createXCOFFObjectFile(MemoryBufferRef MemBufRef,
                                   unsigned FileType) {
   return XCOFFObjectFile::create(FileType, MemBufRef);
 }
 
 StringRef XCOFFSectionHeader32::getName() const {
-  return generateStringRef(Name, XCOFF::SectionNameSize);
+  return generateStringRef(Name, XCOFF::NameSize);
 }
 
 StringRef XCOFFSectionHeader64::getName() const {
-  return generateStringRef(Name, XCOFF::SectionNameSize);
+  return generateStringRef(Name, XCOFF::NameSize);
+}
+
+XCOFF::StorageClass XCOFFSymbolRef::getStorageClass() const {
+  return OwningObjectPtr->toSymbolEntry(SymEntDataRef)->StorageClass;
+}
+
+uint8_t XCOFFSymbolRef::getNumberOfAuxEntries() const {
+  return OwningObjectPtr->toSymbolEntry(SymEntDataRef)->NumberOfAuxEntries;
+}
+
+const XCOFFCSectAuxEnt *XCOFFSymbolRef::getXCoffCSectAuxEnt() const {
+  assert(hasCSectAuxEnt());
+  uintptr_t AuxAddr = getWithOffset(
+      SymEntDataRef.p, SYM_TAB_ENTRY_SIZE * getNumberOfAuxEntries());
+  return reinterpret_cast<const XCOFFCSectAuxEnt *>(AuxAddr);
+}
+
+uint16_t XCOFFSymbolRef::getType() const {
+  return OwningObjectPtr->toSymbolEntry(SymEntDataRef)->SymbolType;
+}
+
+int16_t XCOFFSymbolRef::getSectionNumber() const {
+  return OwningObjectPtr->toSymbolEntry(SymEntDataRef)->SectionNumber;
+}
+
+bool XCOFFSymbolRef::hasCSectAuxEnt() const {
+  XCOFF::StorageClass Sc = getStorageClass();
+  return (Sc == XCOFF::C_EXT || Sc == XCOFF::C_WEAKEXT ||
+          Sc == XCOFF::C_HIDEXT);
+}
+
+bool XCOFFSymbolRef::isFunction() const {
+  if (getType() & FUNCTION_SYM)
+    return true;
+
+  if (!hasCSectAuxEnt())
+    return false;
+
+  const XCOFFCSectAuxEnt *CSectAuxEnt = getXCoffCSectAuxEnt();
+  // The symbol is label define.
+  if ((CSectAuxEnt->SymbolAlignmentAndType & SYM_TYPE_MASK) != XCOFF::XTY_LD)
+    return false;
+
+  if (CSectAuxEnt->StorageMappingClass != XCOFF::XMC_PR)
+    return false;
+
+  int16_t SectNum = getSectionNumber();
+  Expected<DataRefImpl> SI = OwningObjectPtr->getSectionByNum(SectNum);
+  if (!SI)
+    return false;
+
+  return (OwningObjectPtr->getSectionFlags(SI.get()) & XCOFF::STYP_TEXT);
 }
 
 } // namespace object
 } // namespace llvm

llvm/test/tools/llvm-readobj/xcoff-symbols.test

+# RUN: llvm-readobj --symbols %p/Inputs/aix_xcoff_xlc_test8.o | \
+# RUN: FileCheck --check-prefix=SYMBOL32 %s
+SYMBOL32: File: {{.*}}aix_xcoff_xlc_test8.o
+SYMBOL32-NEXT: Format: aixcoff-rs6000
+SYMBOL32-NEXT: Arch: powerpc
+SYMBOL32-NEXT: AddressSize: 32bit
+SYMBOL32-NEXT: Symbols [
+SYMBOL32-NEXT:   Symbol {
+SYMBOL32-NEXT:     Index: 0
+SYMBOL32-NEXT:     Name: .file
+SYMBOL32-NEXT:     Value (SymbolTableIndex): 0x0
+SYMBOL32-NEXT:     Section: N_DEBUG
+SYMBOL32-NEXT:     Source Language ID: 0
+SYMBOL32-NEXT:     CPU Version ID: 3
+SYMBOL32-NEXT:     StorageClass: C_FILE (0x67)
+SYMBOL32-NEXT:     NumberOfAuxEntries: 3
+SYMBOL32-NEXT:     File Auxiliary Entry {
+SYMBOL32-NEXT:       Index: 1
+SYMBOL32-NEXT:       Name: test8.c
+SYMBOL32-NEXT:       Type: XFT_FN (0x0)
+SYMBOL32-NEXT:       AuxType: 0x0
+SYMBOL32-NEXT:     }
+SYMBOL32-NEXT:     File Auxiliary Entry {
+SYMBOL32-NEXT:       Index: 2
+SYMBOL32-NEXT:       Name: Sun Apr 28 15:56:49 2019 
+SYMBOL32-NEXT:       Type: XFT_CT (0x1)
+SYMBOL32-NEXT:       AuxType: 0x0
+SYMBOL32-NEXT:     }
+SYMBOL32-NEXT:     File Auxiliary Entry {
+SYMBOL32-NEXT:       Index: 3
+SYMBOL32-NEXT:       Name: IBM XL C for AIX, Version 16.1.0.2
+SYMBOL32-NEXT:       Type: XFT_CV (0x2)
+SYMBOL32-NEXT:       AuxType: 0x0
+SYMBOL32-NEXT:     }
+SYMBOL32-NEXT:   }
+SYMBOL32-NEXT:   Symbol {
+SYMBOL32-NEXT:     Index: 4
+SYMBOL32-NEXT:     Name: .text
+SYMBOL32-NEXT:     Value (RelocatableAddress): 0x0
+SYMBOL32-NEXT:     Section: .text
+SYMBOL32-NEXT:     Type: 0x0
+SYMBOL32-NEXT:     StorageClass: C_STAT (0x3)
+SYMBOL32-NEXT:     NumberOfAuxEntries: 1
+SYMBOL32-NEXT:     Sect Auxiliary Entry For Stat {
+SYMBOL32-NEXT:       Index: 5
+SYMBOL32-NEXT:       SectionLength: 256
+SYMBOL32-NEXT:       NumberOfRelocEnt: 4
+SYMBOL32-NEXT:       NumberOfLineNum: 0
+SYMBOL32-NEXT:     }
+SYMBOL32-NEXT:   }
+SYMBOL32-NEXT:   Symbol {
+SYMBOL32-NEXT:     Index: 6
+SYMBOL32-NEXT:     Name: .data
+SYMBOL32-NEXT:     Value (RelocatableAddress): 0x100
+SYMBOL32-NEXT:     Section: .data
+SYMBOL32-NEXT:     Type: 0x0
+SYMBOL32-NEXT:     StorageClass: C_STAT (0x3)
+SYMBOL32-NEXT:     NumberOfAuxEntries: 1
+SYMBOL32-NEXT:     Sect Auxiliary Entry For Stat {
+SYMBOL32-NEXT:       Index: 7
+SYMBOL32-NEXT:       SectionLength: 60
+SYMBOL32-NEXT:       NumberOfRelocEnt: 11
+SYMBOL32-NEXT:       NumberOfLineNum: 0
+SYMBOL32-NEXT:     }
+SYMBOL32-NEXT:   }
+SYMBOL32-NEXT:   Symbol {
+SYMBOL32-NEXT:     Index: 8
+SYMBOL32-NEXT:     Name: .bss
+SYMBOL32-NEXT:     Value (RelocatableAddress): 0x13C
+SYMBOL32-NEXT:     Section: .bss
+SYMBOL32-NEXT:     Type: 0x0
+SYMBOL32-NEXT:     StorageClass: C_STAT (0x3)
+SYMBOL32-NEXT:     NumberOfAuxEntries: 1
+SYMBOL32-NEXT:     Sect Auxiliary Entry For Stat {
+SYMBOL32-NEXT:       Index: 9
+SYMBOL32-NEXT:       SectionLength: 4
+SYMBOL32-NEXT:       NumberOfRelocEnt: 0
+SYMBOL32-NEXT:       NumberOfLineNum: 0
+SYMBOL32-NEXT:     }
+SYMBOL32-NEXT:   }
+SYMBOL32-NEXT:   Symbol {
+SYMBOL32-NEXT:     Index: 10
+SYMBOL32-NEXT:     Name: 
+SYMBOL32-NEXT:     Value (RelocatableAddress): 0x0
+SYMBOL32-NEXT:     Section: .text
+SYMBOL32-NEXT:     Type: 0x0
+SYMBOL32-NEXT:     StorageClass: C_HIDEXT (0x6B)
+SYMBOL32-NEXT:     NumberOfAuxEntries: 1
+SYMBOL32-NEXT:     CSect Auxiliary Entry {
+SYMBOL32-NEXT:       Index: 11
+SYMBOL32-NEXT:       SectionLen: 256
+SYMBOL32-NEXT:       ParameterHash: 0x0
+SYMBOL32-NEXT:       TypeChkSectNum: 0x0
+SYMBOL32-NEXT:       SymbolAlignmentLog2: 7
+SYMBOL32-NEXT:       SymbolType: XTY_SD (0x1)
+SYMBOL32-NEXT:       StorageMappingClass: XMC_PR (0x0)
+SYMBOL32-NEXT:       Stab: 0x0
+SYMBOL32-NEXT:       Snstab: 0x0
+SYMBOL32-NEXT:     }
+SYMBOL32-NEXT:   }
+SYMBOL32-NEXT:   Symbol {
+SYMBOL32-NEXT:     Index: 12
+SYMBOL32-NEXT:     Name: .fun1
+SYMBOL32-NEXT:     Value (RelocatableAddress): 0x0
+SYMBOL32-NEXT:     Section: .text
+SYMBOL32-NEXT:     Type: 0x20
+SYMBOL32-NEXT:     StorageClass: C_EXT (0x2)
+SYMBOL32-NEXT:     NumberOfAuxEntries: 1
+SYMBOL32-NEXT:     CSect Auxiliary Entry {
+SYMBOL32-NEXT:       Index: 13
+SYMBOL32-NEXT:       ContainingCSectSymbolIndex: 10
+SYMBOL32-NEXT:       ParameterHash: 0x0
+SYMBOL32-NEXT:       TypeChkSectNum: 0x0
+SYMBOL32-NEXT:       SymbolAlignmentLog2: 0
+SYMBOL32-NEXT:       SymbolType: XTY_LD (0x2)
+SYMBOL32-NEXT:       StorageMappingClass: XMC_PR (0x0)
+SYMBOL32-NEXT:       Stab: 0x0
+SYMBOL32-NEXT:       Snstab: 0x0
+SYMBOL32-NEXT:     }
+SYMBOL32-NEXT:   }
+SYMBOL32-NEXT:   Symbol {
+SYMBOL32-NEXT:     Index: 14
+SYMBOL32-NEXT:     Name: .main
+SYMBOL32-NEXT:     Value (RelocatableAddress): 0x60
+SYMBOL32-NEXT:     Section: .text
+SYMBOL32-NEXT:     Type: 0x20
+SYMBOL32-NEXT:     StorageClass: C_EXT (0x2)
+SYMBOL32-NEXT:     NumberOfAuxEntries: 1
+SYMBOL32-NEXT:     CSect Auxiliary Entry {
+SYMBOL32-NEXT:       Index: 15
+SYMBOL32-NEXT:       ContainingCSectSymbolIndex: 10
+SYMBOL32-NEXT:       ParameterHash: 0x0
+SYMBOL32-NEXT:       TypeChkSectNum: 0x0
+SYMBOL32-NEXT:       SymbolAlignmentLog2: 0
+SYMBOL32-NEXT:       SymbolType: XTY_LD (0x2)
+SYMBOL32-NEXT:       StorageMappingClass: XMC_PR (0x0)
+SYMBOL32-NEXT:       Stab: 0x0
+SYMBOL32-NEXT:       Snstab: 0x0
+SYMBOL32-NEXT:     }
+SYMBOL32-NEXT:   }
+SYMBOL32-NEXT:   Symbol {
+SYMBOL32-NEXT:     Index: 16
+SYMBOL32-NEXT:     Name: TOC
+SYMBOL32-NEXT:     Value (RelocatableAddress): 0x100
+SYMBOL32-NEXT:     Section: .data
+SYMBOL32-NEXT:     Type: 0x0
+SYMBOL32-NEXT:     StorageClass: C_HIDEXT (0x6B)
+SYMBOL32-NEXT:     NumberOfAuxEntries: 1
+SYMBOL32-NEXT:     CSect Auxiliary Entry {
+SYMBOL32-NEXT:       Index: 17
+SYMBOL32-NEXT:       SectionLen: 0
+SYMBOL32-NEXT:       ParameterHash: 0x0
+SYMBOL32-NEXT:       TypeChkSectNum: 0x0
+SYMBOL32-NEXT:       SymbolAlignmentLog2: 2
+SYMBOL32-NEXT:       SymbolType: XTY_SD (0x1)
+SYMBOL32-NEXT:       StorageMappingClass: XMC_TC0 (0xF)
+SYMBOL32-NEXT:       Stab: 0x0
+SYMBOL32-NEXT:       Snstab: 0x0
+SYMBOL32-NEXT:     }
+SYMBOL32-NEXT:   }
+SYMBOL32-NEXT:   Symbol {
+SYMBOL32-NEXT:     Index: 18
+SYMBOL32-NEXT:     Name: 
+SYMBOL32-NEXT:     Value (RelocatableAddress): 0x114
+SYMBOL32-NEXT:     Section: .data
+SYMBOL32-NEXT:     Type: 0x0
+SYMBOL32-NEXT:     StorageClass: C_HIDEXT (0x6B)
+SYMBOL32-NEXT:     NumberOfAuxEntries: 1
+SYMBOL32-NEXT:     CSect Auxiliary Entry {
+SYMBOL32-NEXT:       Index: 19
+SYMBOL32-NEXT:       SectionLen: 4
+SYMBOL32-NEXT:       ParameterHash: 0x0
+SYMBOL32-NEXT:       TypeChkSectNum: 0x0
+SYMBOL32-NEXT:       SymbolAlignmentLog2: 2
+SYMBOL32-NEXT:       SymbolType: XTY_SD (0x1)
+SYMBOL32-NEXT:       StorageMappingClass: XMC_TC (0x3)
+SYMBOL32-NEXT:       Stab: 0x0
+SYMBOL32-NEXT:       Snstab: 0x0
+SYMBOL32-NEXT:     }
+SYMBOL32-NEXT:   }
+SYMBOL32-NEXT:   Symbol {
+SYMBOL32-NEXT:     Index: 20
+SYMBOL32-NEXT:     Name: 
+SYMBOL32-NEXT:     Value (RelocatableAddress): 0x134
+SYMBOL32-NEXT:     Section: .data
+SYMBOL32-NEXT:     Type: 0x0
+SYMBOL32-NEXT:     StorageClass: C_HIDEXT (0x6B)
+SYMBOL32-NEXT:     NumberOfAuxEntries: 1
+SYMBOL32-NEXT:     CSect Auxiliary Entry {
+SYMBOL32-NEXT:       Index: 21
+SYMBOL32-NEXT:       SectionLen: 5
+SYMBOL32-NEXT:       ParameterHash: 0x0
+SYMBOL32-NEXT:       TypeChkSectNum: 0x0
+SYMBOL32-NEXT:       SymbolAlignmentLog2: 3
+SYMBOL32-NEXT:       SymbolType: XTY_SD (0x1)
+SYMBOL32-NEXT:       StorageMappingClass: XMC_RO (0x1)
+SYMBOL32-NEXT:       Stab: 0x0
+SYMBOL32-NEXT:       Snstab: 0x0
+SYMBOL32-NEXT:     }
+SYMBOL32-NEXT:   }
+SYMBOL32-NEXT:   Symbol {
+SYMBOL32-NEXT:     Index: 22
+SYMBOL32-NEXT:     Name: _$STATIC_BSS
+SYMBOL32-NEXT:     Value (RelocatableAddress): 0x13C
+SYMBOL32-NEXT:     Section: .bss
+SYMBOL32-NEXT:     Type: 0x0
+SYMBOL32-NEXT:     StorageClass: C_HIDEXT (0x6B)
+SYMBOL32-NEXT:     NumberOfAuxEntries: 1
+SYMBOL32-NEXT:     CSect Auxiliary Entry {
+SYMBOL32-NEXT:       Index: 23
+SYMBOL32-NEXT:       SectionLen: 4
+SYMBOL32-NEXT:       ParameterHash: 0x0
+SYMBOL32-NEXT:       TypeChkSectNum: 0x0
+SYMBOL32-NEXT:       SymbolAlignmentLog2: 2
+SYMBOL32-NEXT:       SymbolType: XTY_CM (0x3)
+SYMBOL32-NEXT:       StorageMappingClass: XMC_RW (0x5)
+SYMBOL32-NEXT:       Stab: 0x0
+SYMBOL32-NEXT:       Snstab: 0x0
+SYMBOL32-NEXT:     }
+SYMBOL32-NEXT:   }
+SYMBOL32-NEXT:   Symbol {
+SYMBOL32-NEXT:     Index: 24
+SYMBOL32-NEXT:     Name: _$STATIC_BSS
+SYMBOL32-NEXT:     Value (RelocatableAddress): 0x104
+SYMBOL32-NEXT:     Section: .data
+SYMBOL32-NEXT:     Type: 0x0
+SYMBOL32-NEXT:     StorageClass: C_HIDEXT (0x6B)
+SYMBOL32-NEXT:     NumberOfAuxEntries: 1
+SYMBOL32-NEXT:     CSect Auxiliary Entry {
+SYMBOL32-NEXT:       Index: 25
+SYMBOL32-NEXT:       SectionLen: 4
+SYMBOL32-NEXT:       ParameterHash: 0x0
+SYMBOL32-NEXT:       TypeChkSectNum: 0x0
+SYMBOL32-NEXT:       SymbolAlignmentLog2: 2
+SYMBOL32-NEXT:       SymbolType: XTY_SD (0x1)
+SYMBOL32-NEXT:       StorageMappingClass: XMC_TC (0x3)
+SYMBOL32-NEXT:       Stab: 0x0
+SYMBOL32-NEXT:       Snstab: 0x0
+SYMBOL32-NEXT:     }
+SYMBOL32-NEXT:   }
+SYMBOL32-NEXT:   Symbol {
+SYMBOL32-NEXT:     Index: 26
+SYMBOL32-NEXT:     Name: fun1
+SYMBOL32-NEXT:     Value (RelocatableAddress): 0x118
+SYMBOL32-NEXT:     Section: .data
+SYMBOL32-NEXT:     Type: 0x0
+SYMBOL32-NEXT:     StorageClass: C_EXT (0x2)
+SYMBOL32-NEXT:     NumberOfAuxEntries: 1
+SYMBOL32-NEXT:     CSect Auxiliary Entry {
+SYMBOL32-NEXT:       Index: 27
+SYMBOL32-NEXT:       SectionLen: 12
+SYMBOL32-NEXT:       ParameterHash: 0x0
+SYMBOL32-NEXT:       TypeChkSectNum: 0x0
+SYMBOL32-NEXT:       SymbolAlignmentLog2: 2
+SYMBOL32-NEXT:       SymbolType: XTY_SD (0x1)
+SYMBOL32-NEXT:       StorageMappingClass: XMC_DS (0xA)
+SYMBOL32-NEXT:       Stab: 0x0
+SYMBOL32-NEXT:       Snstab: 0x0
+SYMBOL32-NEXT:     }
+SYMBOL32-NEXT:   }
+SYMBOL32-NEXT:   Symbol {
+SYMBOL32-NEXT:     Index: 28
+SYMBOL32-NEXT:     Name: fun1
+SYMBOL32-NEXT:     Value (RelocatableAddress): 0x100
+SYMBOL32-NEXT:     Section: .data
+SYMBOL32-NEXT:     Type: 0x0
+SYMBOL32-NEXT:     StorageClass: C_HIDEXT (0x6B)
+SYMBOL32-NEXT:     NumberOfAuxEntries: 1
+SYMBOL32-NEXT:     CSect Auxiliary Entry {
+SYMBOL32-NEXT:       Index: 29
+SYMBOL32-NEXT:       SectionLen: 4
+SYMBOL32-NEXT:       ParameterHash: 0x0
+SYMBOL32-NEXT:       TypeChkSectNum: 0x0
+SYMBOL32-NEXT:       SymbolAlignmentLog2: 2
+SYMBOL32-NEXT:       SymbolType: XTY_SD (0x1)
+SYMBOL32-NEXT:       StorageMappingClass: XMC_TC (0x3)
+SYMBOL32-NEXT:       Stab: 0x0
+SYMBOL32-NEXT:       Snstab: 0x0
+SYMBOL32-NEXT:     }
+SYMBOL32-NEXT:   }
+SYMBOL32-NEXT:   Symbol {
+SYMBOL32-NEXT:     Index: 30
+SYMBOL32-NEXT:     Name: p
+SYMBOL32-NEXT:     Value (RelocatableAddress): 0x130
+SYMBOL32-NEXT:     Section: .data
+SYMBOL32-NEXT:     Type: 0x0
+SYMBOL32-NEXT:     StorageClass: C_EXT (0x2)
+SYMBOL32-NEXT:     NumberOfAuxEntries: 1
+SYMBOL32-NEXT:     CSect Auxiliary Entry {
+SYMBOL32-NEXT:       Index: 31
+SYMBOL32-NEXT:       SectionLen: 4
+SYMBOL32-NEXT:       ParameterHash: 0x0
+SYMBOL32-NEXT:       TypeChkSectNum: 0x0
+SYMBOL32-NEXT:       SymbolAlignmentLog2: 2
+SYMBOL32-NEXT:       SymbolType: XTY_SD (0x1)
+SYMBOL32-NEXT:       StorageMappingClass: XMC_RW (0x5)
+SYMBOL32-NEXT:       Stab: 0x0
+SYMBOL32-NEXT:       Snstab: 0x0
+SYMBOL32-NEXT:     }
+SYMBOL32-NEXT:   }
+SYMBOL32-NEXT:   Symbol {
+SYMBOL32-NEXT:     Index: 32
+SYMBOL32-NEXT:     Name: p
+SYMBOL32-NEXT:     Value (RelocatableAddress): 0x108
+SYMBOL32-NEXT:     Section: .data
+SYMBOL32-NEXT:     Type: 0x0
+SYMBOL32-NEXT:     StorageClass: C_HIDEXT (0x6B)
+SYMBOL32-NEXT:     NumberOfAuxEntries: 1
+SYMBOL32-NEXT:     CSect Auxiliary Entry {
+SYMBOL32-NEXT:       Index: 33
+SYMBOL32-NEXT:       SectionLen: 4
+SYMBOL32-NEXT:       ParameterHash: 0x0
+SYMBOL32-NEXT:       TypeChkSectNum: 0x0
+SYMBOL32-NEXT:       SymbolAlignmentLog2: 2
+SYMBOL32-NEXT:       SymbolType: XTY_SD (0x1)
+SYMBOL32-NEXT:       StorageMappingClass: XMC_TC (0x3)
+SYMBOL32-NEXT:       Stab: 0x0
+SYMBOL32-NEXT:       Snstab: 0x0
+SYMBOL32-NEXT:     }
+SYMBOL32-NEXT:   }
+SYMBOL32-NEXT:   Symbol {
+SYMBOL32-NEXT:     Index: 34
+SYMBOL32-NEXT:     Name: main
+SYMBOL32-NEXT:     Value (RelocatableAddress): 0x124
+SYMBOL32-NEXT:     Section: .data
+SYMBOL32-NEXT:     Type: 0x0
+SYMBOL32-NEXT:     StorageClass: C_EXT (0x2)
+SYMBOL32-NEXT:     NumberOfAuxEntries: 1
+SYMBOL32-NEXT:     CSect Auxiliary Entry {
+SYMBOL32-NEXT:       Index: 35
+SYMBOL32-NEXT:       SectionLen: 12
+SYMBOL32-NEXT:       ParameterHash: 0x0
+SYMBOL32-NEXT:       TypeChkSectNum: 0x0
+SYMBOL32-NEXT:       SymbolAlignmentLog2: 2
+SYMBOL32-NEXT:       SymbolType: XTY_SD (0x1)
+SYMBOL32-NEXT:       StorageMappingClass: XMC_DS (0xA)
+SYMBOL32-NEXT:       Stab: 0x0
+SYMBOL32-NEXT:       Snstab: 0x0
+SYMBOL32-NEXT:     }
+SYMBOL32-NEXT:   }
+SYMBOL32-NEXT:   Symbol {
+SYMBOL32-NEXT:     Index: 36
+SYMBOL32-NEXT:     Name: main
+SYMBOL32-NEXT:     Value (RelocatableAddress): 0x10C
+SYMBOL32-NEXT:     Section: .data
+SYMBOL32-NEXT:     Type: 0x0
+SYMBOL32-NEXT:     StorageClass: C_HIDEXT (0x6B)
+SYMBOL32-NEXT:     NumberOfAuxEntries: 1
+SYMBOL32-NEXT:     CSect Auxiliary Entry {
+SYMBOL32-NEXT:       Index: 37
+SYMBOL32-NEXT:       SectionLen: 4
+SYMBOL32-NEXT:       ParameterHash: 0x0
+SYMBOL32-NEXT:       TypeChkSectNum: 0x0
+SYMBOL32-NEXT:       SymbolAlignmentLog2: 2
+SYMBOL32-NEXT:       SymbolType: XTY_SD (0x1)
+SYMBOL32-NEXT:       StorageMappingClass: XMC_TC (0x3)
+SYMBOL32-NEXT:       Stab: 0x0
+SYMBOL32-NEXT:       Snstab: 0x0
+SYMBOL32-NEXT:     }
+SYMBOL32-NEXT:   }
+SYMBOL32-NEXT:   Symbol {
+SYMBOL32-NEXT:     Index: 38
+SYMBOL32-NEXT:     Name: i
+SYMBOL32-NEXT:     Value (RelocatableAddress): 0x0
+SYMBOL32-NEXT:     Section: N_UNDEF
+SYMBOL32-NEXT:     Type: 0x0
+SYMBOL32-NEXT:     StorageClass: C_EXT (0x2)
+SYMBOL32-NEXT:     NumberOfAuxEntries: 1
+SYMBOL32-NEXT:     CSect Auxiliary Entry {
+SYMBOL32-NEXT:       Index: 39
+SYMBOL32-NEXT:       SectionLen: 0
+SYMBOL32-NEXT:       ParameterHash: 0x0
+SYMBOL32-NEXT:       TypeChkSectNum: 0x0
+SYMBOL32-NEXT:       SymbolAlignmentLog2: 0
+SYMBOL32-NEXT:       SymbolType: XTY_ER (0x0)
+SYMBOL32-NEXT:       StorageMappingClass: XMC_UA (0x4)
+SYMBOL32-NEXT:       Stab: 0x0
+SYMBOL32-NEXT:       Snstab: 0x0
+SYMBOL32-NEXT:     }
+SYMBOL32-NEXT:   }
+SYMBOL32-NEXT:   Symbol {
+SYMBOL32-NEXT:     Index: 40
+SYMBOL32-NEXT:     Name: i
+SYMBOL32-NEXT:     Value (RelocatableAddress): 0x110
+SYMBOL32-NEXT:     Section: .data
+SYMBOL32-NEXT:     Type: 0x0
+SYMBOL32-NEXT:     StorageClass: C_HIDEXT (0x6B)
+SYMBOL32-NEXT:     NumberOfAuxEntries: 1
+SYMBOL32-NEXT:     CSect Auxiliary Entry {
+SYMBOL32-NEXT:       Index: 41
+SYMBOL32-NEXT:       SectionLen: 4
+SYMBOL32-NEXT:       ParameterHash: 0x0
+SYMBOL32-NEXT:       TypeChkSectNum: 0x0
+SYMBOL32-NEXT:       SymbolAlignmentLog2: 2
+SYMBOL32-NEXT:       SymbolType: XTY_SD (0x1)
+SYMBOL32-NEXT:       StorageMappingClass: XMC_TC (0x3)
+SYMBOL32-NEXT:       Stab: 0x0
+SYMBOL32-NEXT:       Snstab: 0x0
+SYMBOL32-NEXT:     }
+SYMBOL32-NEXT:   }
+SYMBOL32-NEXT:   Symbol {
+SYMBOL32-NEXT:     Index: 42
+SYMBOL32-NEXT:     Name: .fun
+SYMBOL32-NEXT:     Value (RelocatableAddress): 0x0
+SYMBOL32-NEXT:     Section: N_UNDEF
+SYMBOL32-NEXT:     Type: 0x0
+SYMBOL32-NEXT:     StorageClass: C_EXT (0x2)
+SYMBOL32-NEXT:     NumberOfAuxEntries: 1
+SYMBOL32-NEXT:     CSect Auxiliary Entry {
+SYMBOL32-NEXT:       Index: 43
+SYMBOL32-NEXT:       SectionLen: 0
+SYMBOL32-NEXT:       ParameterHash: 0x0
+SYMBOL32-NEXT:       TypeChkSectNum: 0x0
+SYMBOL32-NEXT:       SymbolAlignmentLog2: 0
+SYMBOL32-NEXT:       SymbolType: XTY_ER (0x0)
+SYMBOL32-NEXT:       StorageMappingClass: XMC_PR (0x0)
+SYMBOL32-NEXT:       Stab: 0x0
+SYMBOL32-NEXT:       Snstab: 0x0
+SYMBOL32-NEXT:     }
+SYMBOL32-NEXT:   }
+SYMBOL32-NEXT: ]

llvm/tools/llvm-readobj/XCOFFDumper.cpp

 #include "llvm/Support/ScopedPrinter.h"
 
 using namespace llvm;
 using namespace object;
 
 namespace {
 
 class XCOFFDumper : public ObjDumper {
+  enum {
+    SymbolTypeMask = 0x07,
+    SymbolAlignmentMask = 0xF8,
+    SymbolTypeBits = 3
+  };
+
 public:
   XCOFFDumper(const XCOFFObjectFile &Obj, ScopedPrinter &Writer)
       : ObjDumper(Writer), Obj(Obj) {}
 
   void printFileHeaders() override;
   void printSectionHeaders() override;
   void printRelocations() override;
   void printSymbols() override;
   void printDynamicSymbols() override;
   void printUnwindInfo() override;
   void printStackMap() const override;
   void printNeededLibraries() override;
 
 private:
   template <typename T> void printSectionHeaders(ArrayRef<T> Sections);
-
-  const XCOFFObjectFile &Obj;
+  void printFileAuxEnt(const XCOFFFileAuxEnt *AuxEntPtr);
+  void printFunctionAuxEnt(const XCOFFFunctionAuxEnt *AuxEntPtr);
+  void printCSectAuxEnt(const XCOFFCSectAuxEnt *AuxEntPtr);
+  void printSectAuxEntForStat(const XCOFFSectAuxEntForStat *AuxEntPtr);
+  void printSectAuxEntForDwarf(const XCOFFSectAuxEntForDwarf *AuxEntPtr);
+  void printBlockAuxEnt(const XCOFFBlockAuxEnt *AuxEntPtr);
+  void printSymbol(const SymbolRef &);
 
   // Least significant 3 bits are reserved.
   static constexpr unsigned SectionFlagsReservedMask = 0x7;
+  const XCOFFObjectFile &Obj;
 };
 } // anonymous namespace
 
 void XCOFFDumper::printFileHeaders() {
   DictScope DS(W, "FileHeader");
   W.printHex("Magic", Obj.getMagic());
   W.printNumber("NumberOfSections", Obj.getNumberOfSections());
 
if (Obj.is64Bit())
     printSectionHeaders(Obj.sections64());
   else
     printSectionHeaders(Obj.sections32());
 }
 
 void XCOFFDumper::printRelocations() {
   llvm_unreachable("Unimplemented functionality for XCOFFDumper");
 }
+static const EnumEntry<XCOFF::CFileStringType> FileStringType[] = {
+#define ECase(X)                                                               \
+  { #X, XCOFF::X }
+    ECase(XFT_FN), ECase(XFT_CT), ECase(XFT_CV), ECase(XFT_CD)
+#undef ECase
+};
+
+template <typename T> const XCOFFSymbolEntry *ViewAsSymEnt(const T *t) {
+  return reinterpret_cast<const XCOFFSymbolEntry *>(t);
+}
+
+void XCOFFDumper::printFileAuxEnt(const XCOFFFileAuxEnt *AuxEntPtr) {
+  StringRef FileName = unwrapOrError(Obj.getCFileName(AuxEntPtr));
+  DictScope SymDs(W, "File Auxiliary Entry");
+  W.printNumber("Index", Obj.getSymbolIndex(
+                             reinterpret_cast<const uintptr_t *>(AuxEntPtr)));
+  W.printString("Name", FileName);
+  W.printEnum("Type", (uint8_t)AuxEntPtr->Type, makeArrayRef(FileStringType));
+  W.printHex("AuxType", AuxEntPtr->AuxType);
+}
+
+void XCOFFDumper::printFunctionAuxEnt(const XCOFFFunctionAuxEnt *AuxEntPtr) {
+  DictScope SymDs(W, "Function Auxiliary Entry");
+  W.printNumber("Index", Obj.getSymbolIndex(
+                             reinterpret_cast<const uintptr_t *>(AuxEntPtr)));
+  W.printHex("OffsetToExceptionTable", AuxEntPtr->OffsetToExceptionTable);
+  W.printNumber("FunctionSize", AuxEntPtr->FunctionSize);
+  W.printHex("FilePointerToLineNum", AuxEntPtr->FilePointerToLineNum);
+  W.printNumber("IndexofNextEntry", AuxEntPtr->IndexOfNextEntry);
+}
+
+static const EnumEntry<XCOFF::StorageMappingClass> CSectStorageMappingClass[] =
+    {
+#define ECase(X)                                                               \
+  { #X, XCOFF::X }
+        ECase(XMC_PR),   ECase(XMC_RO),     ECase(XMC_DB),
+        ECase(XMC_GL),   ECase(XMC_XO),     ECase(XMC_SV),
+        ECase(XMC_SV64), ECase(XMC_SV3264), ECase(XMC_TI),
+        ECase(XMC_TB),   ECase(XMC_RW),     ECase(XMC_TC0),
+        ECase(XMC_TC),   ECase(XMC_TD),     ECase(XMC_DS),
+        ECase(XMC_UA),   ECase(XMC_BS),     ECase(XMC_UC),
+        ECase(XMC_TL),   ECase(XMC_TE)
+#undef ECase
+};
 
+static const EnumEntry<XCOFF::SymbolType> CSectSymbolTypeClass[] = {
+#define ECase(X)                                                               \
+  { #X, XCOFF::X }
+    ECase(XTY_ER), ECase(XTY_SD), ECase(XTY_LD), ECase(XTY_CM)
+#undef ECase
+};
+
+void XCOFFDumper::printCSectAuxEnt(const XCOFFCSectAuxEnt *AuxEntPtr) {
+  DictScope SymDs(W, "CSect Auxiliary Entry");
+  W.printNumber("Index", Obj.getSymbolIndex(
+                             reinterpret_cast<const uintptr_t *>(AuxEntPtr)));
+  if ((AuxEntPtr->SymbolAlignmentAndType & SymbolTypeMask) == XCOFF::XTY_LD)
+    W.printNumber("ContainingCSectSymbolIndex", AuxEntPtr->SectionLen);
+  else
+    W.printNumber("SectionLen", AuxEntPtr->SectionLen);
+  W.printHex("ParameterHash", AuxEntPtr->ParameterHash);
+  W.printHex("TypeChkSectNum", AuxEntPtr->TypeChkSectNum);
+  // Print out symbol alignment and type.
+  W.printNumber("SymbolAlignmentLog2",
+                (AuxEntPtr->SymbolAlignmentAndType & SymbolAlignmentMask) >>
+                    SymbolTypeBits);
+  W.printEnum("SymbolType",
+              ((uint8_t)AuxEntPtr->SymbolAlignmentAndType & SymbolTypeMask),
+              makeArrayRef(CSectSymbolTypeClass));
+  W.printEnum("StorageMappingClass", (uint8_t)AuxEntPtr->StorageMappingClass,
+              makeArrayRef(CSectStorageMappingClass));
+  W.printHex("Stab", AuxEntPtr->Stab);
+  W.printHex("Snstab", AuxEntPtr->Snstab);
+}
+
+void XCOFFDumper::printSectAuxEntForStat(
+    const XCOFFSectAuxEntForStat *AuxEntPtr) {
+  DictScope SymDs(W, "Sect Auxiliary Entry For Stat");
+  W.printNumber("Index", Obj.getSymbolIndex(
+                             reinterpret_cast<const uintptr_t *>(AuxEntPtr)));
+  W.printNumber("SectionLength", AuxEntPtr->SectionLength);
+  W.printNumber("NumberOfRelocEnt", AuxEntPtr->NumberOfRelocEnt);
+  W.printNumber("NumberOfLineNum", AuxEntPtr->NumberOfLineNum);
+}
+
+void XCOFFDumper::printSectAuxEntForDwarf(
+    const XCOFFSectAuxEntForDwarf *AuxEntPtr) {
+  DictScope SymDs(W, "Sect Auxiliary Entry For Dwarf");
+  W.printNumber("Index", Obj.getSymbolIndex(
+                             reinterpret_cast<const uintptr_t *>(AuxEntPtr)));
+  W.printNumber("SectionLength", AuxEntPtr->SectionLength);
+  W.printNumber("NumberOfRelocEnt", AuxEntPtr->NumberOfRelocEnt);
+}
+
+void XCOFFDumper::printBlockAuxEnt(const XCOFFBlockAuxEnt *AuxEntPtr) {
+  DictScope SymDs(W, "Block Auxiliary Entry");
+  W.printNumber("Index", Obj.getSymbolIndex(
+                             reinterpret_cast<const uintptr_t *>(AuxEntPtr)));
+  W.printNumber("SourceLineNumHi", AuxEntPtr->SourceLineNumHi);
+  W.printNumber("SourceLineNumLo", AuxEntPtr->SourceLineNumLo);
+}
+
+static 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_FCN:
+  case XCOFF::C_BLOCK:
+  case XCOFF::C_STAT:
+    return "Value (RelocatableAddress)";
+  case XCOFF::C_FUN:
+  case XCOFF::C_STSYM:
+    return "Value (OffsetInCsect)";
+  case XCOFF::C_BINCL:
+  case XCOFF::C_EINCL:
+    return "Value (OffsetInFile)";
+  case XCOFF::C_INFO:
+    return "Value (OffsetInCommentSection)";
+  case XCOFF::C_FILE:
+  case XCOFF::C_BSTAT:
+    return "Value (SymbolTableIndex)";
+  case XCOFF::C_LSYM:
+  case XCOFF::C_PSYM:
+    return "Value (OffsetRelativeTostackFrame)";
+  case XCOFF::C_RPSYM:
+  case XCOFF::C_RSYM:
+    return "Value (RegisterNumber)";
+  case XCOFF::C_ECOML:
+    return "Value (OffsetWithinCommonBlock)";
+  case XCOFF::C_DWARF:
+    return "Value (OffsetWithinCorrespondingDWARFSection)";
+  default:
+    return "Value";
+  }
+}
+
+void XCOFFDumper::printSymbol(const SymbolRef &S) {
+  DataRefImpl SymbolDRI = S.getRawDataRefImpl();
+  const XCOFFSymbolEntry *SymbolEntPtr = Obj.toSymbolEntry(SymbolDRI);
+  XCOFFSymbolRef XCoffSymRef(SymbolDRI, &Obj);
+  uint8_t NumberOfAuxEntries = XCoffSymRef.getNumberOfAuxEntries();
+
+  DictScope SymDs(W, "Symbol");
+
+  StringRef SymbolName = unwrapOrError(Obj.getSymbolName(SymbolDRI));
+
+  W.printNumber("Index", Obj.getSymbolIndex(reinterpret_cast<const uintptr_t *>(
+                             SymbolEntPtr)));
+  W.printString("Name", SymbolName);
+  W.printHex(GetSymbolValueName(SymbolEntPtr->StorageClass),
+             SymbolEntPtr->Value);
+
+  StringRef SectionName = unwrapOrError(Obj.getSymbolSectionName(SymbolEntPtr));
+
+  W.printString("Section", SectionName);
+  if (XCoffSymRef.getStorageClass() == XCOFF::C_FILE) {
+    W.printNumber("Source Language ID",
+                  SymbolEntPtr->CFileLanguageIdAndTypeId.LanguageId);
+    W.printNumber("CPU Version ID",
+                  SymbolEntPtr->CFileLanguageIdAndTypeId.CpuTypeId);
+  } else
+    W.printHex("Type", SymbolEntPtr->SymbolType);
+
+  W.printEnum("StorageClass", (uint8_t)SymbolEntPtr->StorageClass,
+              makeArrayRef(SymStorageClass));
+  W.printNumber("NumberOfAuxEntries", SymbolEntPtr->NumberOfAuxEntries);
+
+  if (NumberOfAuxEntries == 0)
+    return;
+
+  switch (XCoffSymRef.getStorageClass()) {
+  case XCOFF::C_FILE:
+    // If the symbol is C_FILE and has auxiliary entires.
+    if (SymbolName.equals(".file"))
+      for (int i = 1; i <= NumberOfAuxEntries; i++) {
+        const XCOFFFileAuxEnt *FileAuxEntPtr =
+            reinterpret_cast<const XCOFFFileAuxEnt *>(SymbolEntPtr + i);
+        printFileAuxEnt(FileAuxEntPtr);
+      }
+    break;
+  case XCOFF::C_EXT:
+  case XCOFF::C_WEAKEXT:
+  case XCOFF::C_HIDEXT:
+    // If the symbol is Function.
+    if (XCoffSymRef.isFunction() && NumberOfAuxEntries >= 2) {
+      const XCOFFFunctionAuxEnt *CFnctPtr;
+      CFnctPtr =
+          reinterpret_cast<const XCOFFFunctionAuxEnt *>(SymbolEntPtr + 1);
+      printFunctionAuxEnt(CFnctPtr);
+    }
+    // If more than 2,Instead of printing out error information,
+    // Print out the raw Auxiliary entry between 2 and NumberOfAuxEntries-1
+    for (int i = 2; i < NumberOfAuxEntries; i++) {
+      W.startLine() << "!Unexpected raw auxiliary entry data are print out:\n";
+      W.startLine() << format_bytes(ArrayRef<uint8_t>(
+          (const uint8_t *)(SymbolEntPtr + i), sizeof(XCOFFSymbolEntry)));
+    }
+    // The symbol has a CSect Auxiliary Entry.
+    const XCOFFCSectAuxEnt *CSectAuxEntPtr;
+    CSectAuxEntPtr = reinterpret_cast<const XCOFFCSectAuxEnt *>(
+        SymbolEntPtr + NumberOfAuxEntries);
+    printCSectAuxEnt(CSectAuxEntPtr);
+    break;
+  case XCOFF::C_STAT:
+    const XCOFFSectAuxEntForStat *StatAuxEntPtr;
+    StatAuxEntPtr =
+        reinterpret_cast<const XCOFFSectAuxEntForStat *>(SymbolEntPtr + 1);
+    printSectAuxEntForStat(StatAuxEntPtr);
+    break;
+  case XCOFF::C_DWARF:
+    const XCOFFSectAuxEntForDwarf *DwarfAuxEntPtr;
+    DwarfAuxEntPtr =
+        reinterpret_cast<const XCOFFSectAuxEntForDwarf *>(SymbolEntPtr + 1);
+    printSectAuxEntForDwarf(DwarfAuxEntPtr);
+    break;
+  case XCOFF::C_BLOCK:
+  case XCOFF::C_FCN:
+    const XCOFFBlockAuxEnt *BlockAuxEntPtr;
+    BlockAuxEntPtr =
+        reinterpret_cast<const XCOFFBlockAuxEnt *>(SymbolEntPtr + 1);
+    printBlockAuxEnt(BlockAuxEntPtr);
+    break;
+  default:
+    for (int i = 1; i <= NumberOfAuxEntries; i++) {
+      W.startLine() << "!Unexpected raw auxiliary entry data are print out:\n";
+      W.startLine() << format_bytes(ArrayRef<uint8_t>(
+          (const uint8_t *)(SymbolEntPtr + i), sizeof(XCOFFSymbolEntry)));
+    }
+    break;
+  }
+}
 void XCOFFDumper::printSymbols() {
-  llvm_unreachable("Unimplemented functionality for XCOFFDumper");
+  ListScope Group(W, "Symbols");
+  for (const SymbolRef &S : Obj.symbols())
+    printSymbol(S);
 }
 
 void XCOFFDumper::printDynamicSymbols() {
   llvm_unreachable("Unimplemented functionality for XCOFFDumper");
 }
 
 void XCOFFDumper::printUnwindInfo() {
   llvm_unreachable("Unimplemented functionality for XCOFFDumper");
 }
 
 void XCOFFDumper::printStackMap() const {
   llvm_unreachable("Unimplemented functionality for XCOFFDumper");
 }
 
 void XCOFFDumper::printNeededLibraries() {
   llvm_unreachable("Unimplemented functionality for XCOFFDumper");
 }
 
 static const EnumEntry<XCOFF::SectionTypeFlags> SectionTypeFlagsNames[] = {
 #define ECase(X)                                                               \
   { #X, XCOFF::X }
     ECase(STYP_PAD),    ECase(STYP_DWARF), ECase(STYP_TEXT),
     ECase(STYP_DATA),   ECase(STYP_BSS),   ECase(STYP_EXCEPT),
     ECase(STYP_INFO),   ECase(STYP_TDATA), ECase(STYP_TBSS),
     ECase(STYP_LOADER), ECase(STYP_DEBUG), ECase(STYP_TYPCHK),
     ECase(STYP_OVRFLO)
 #undef ECase
 };
 
 template <typename T>
 void XCOFFDumper::printSectionHeaders(ArrayRef<T> Sections) {
   ListScope Group(W, "Sections");
 
   uint16_t Index = 1;
   for (const T &Sec : Sections) {
void XCOFFDumper::printSectionHeaders(ArrayRef<T> Sections) {
 
   if (opts::SectionRelocations)
     report_fatal_error("Dumping section relocations is unimplemented");
 
   if (opts::SectionSymbols)
     report_fatal_error("Dumping symbols is unimplemented");
 
   if (opts::SectionData)
     report_fatal_error("Dumping section data is unimplemented");
 }
 
 namespace llvm {
 std::error_code createXCOFFDumper(const object::ObjectFile *Obj,
                                   ScopedPrinter &Writer,
                                   std::unique_ptr<ObjDumper> &Result) {
   const XCOFFObjectFile *XObj = dyn_cast<XCOFFObjectFile>(Obj);
   if (!XObj)
     return readobj_error::unsupported_obj_file_format;
 
   Result.reset(new XCOFFDumper(*XObj, Writer));
   return readobj_error::success;
 }
 } // namespace llvm