[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.

640

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

641

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);

674

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

121

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

128

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

674

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

126

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 .

666

label define --> label definition.

674

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

186

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.

269

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

285

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

289

Parameter variable name does not match the prevalent style.

294

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.

297

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

284

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

294

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

llvm/lib/Object/XCOFFObjectFile.cpp

129

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).

637

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

641

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.

643

Might make sense to call the error checking function here.

655

s/Sc/SC;

671

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

1

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

16

TB_C = 0,
TB_CPLUSPLUS = 9,

17

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

109

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

426

The filename is test8.c.

llvm/tools/llvm-readobj/XCOFFDumper.cpp

28

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

182

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

131

Use static_cast.

172

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

174

Use static_cast.

186

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

232

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

240

s/unimplmented/unimplemented/;

270

Use static_cast.

279

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

280

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.

290

s/is Function/is for a function/;

294

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.

297

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

299

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

299

Use reinterpret_cast.

310

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

321

See comments above.

323

See comments above.

327

Add a newline between the functions.

[hubert.reinterpretcast]

llvm/tools/llvm-readobj/XCOFFDumper.cpp

305

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

310

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

114

Will add a new line before this function.

[jasonliu]

llvm/tools/llvm-readobj/XCOFFDumper.cpp

186

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

310

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

164

Use "64-bit".

llvm/include/llvm/Object/XCOFFObjectFile.h

173

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

91

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

120

Use "end-of-symbol-table".

152

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

162

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

183

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

163

I think we should treat this as code.

186

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

186

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

183

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

llvm/tools/llvm-readobj/XCOFFDumper.cpp

310

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

[hubert.reinterpretcast]

llvm/tools/llvm-readobj/XCOFFDumper.cpp

310

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

310

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

223

Newline before the comment.

369

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 { NameSize = 8 };
+enum { FileNamePadSize = 6, NameSize = 8 };
+
 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 XCOFFSymbolEntry {
   uint8_t NumberOfAuxEntries;
 };
 
 struct XCOFFStringTable {
   uint32_t Size;
   const char *Data;
 };
 
+struct XCOFFCSectAuxEnt32 {
+  support::ubig32_t SectionLen;
+  support::ubig32_t ParameterHashIndex;
+  support::ubig16_t TypeChkSectNum;
+  uint8_t SymbolAlignmentAndType;
+  XCOFF::StorageMappingClass StorageMappingClass;
+  support::ubig32_t StabInfoIndex;
+  support::ubig16_t StabSectNum;
+};
+
+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 ReservedZeros[2];
+  uint8_t AuxType; // 64-bit XCOFF file only.
+};
+
+struct XCOFFSectAuxEntForStat {
+  support::ubig32_t SectionLength;
+  support::ubig16_t NumberOfRelocEnt;
+  support::ubig16_t NumberOfLineNum;
+  uint8_t Pad[10];
+};
+
 class XCOFFObjectFile : public ObjectFile {
 private:
   const void *FileHeader = nullptr;
   const void *SectionHeaderTable = nullptr;
 
   const XCOFFSymbolEntry *SymbolTblPtr = nullptr;
   XCOFFStringTable StringTable = {0, nullptr};
 
   const XCOFFFileHeader32 *fileHeader32() const;
   const XCOFFFileHeader64 *fileHeader64() const;
 
   const XCOFFSectionHeader32 *sectionHeaderTable32() const;
   const XCOFFSectionHeader64 *sectionHeaderTable64() const;
 
   size_t getFileHeaderSize() const;
   size_t getSectionHeaderSize() const;
 
   const XCOFFSectionHeader32 *toSection32(DataRefImpl Ref) const;
   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(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 *const OwningObjectPtr;
+
+public:
+  XCOFFSymbolRef(DataRefImpl SymEntDataRef,
+                 const XCOFFObjectFile *OwningObjectPtr)
+      : SymEntDataRef(SymEntDataRef), OwningObjectPtr(OwningObjectPtr){};
+
+  XCOFF::StorageClass getStorageClass() const;
+  uint8_t getNumberOfAuxEntries() const;
+  const XCOFFCSectAuxEnt32 *getXCOFFCSectAuxEnt32() 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);
+
+  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);
 
   // 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);

 uint64_t XCOFFObjectFile::getSymbolTableOffset64() const {
   return fileHeader64()->SymbolTableOffset;
 }
 
 uint32_t XCOFFObjectFile::getNumberOfSymbolTableEntries64() const {
   return fileHeader64()->NumberOfSymTableEntries;
 }
 
+uint32_t XCOFFObjectFile::getSymbolIndex(uintptr_t SymbolEntPtr) const {
+#ifndef NDEBUG
+  if (SymbolEntPtr < reinterpret_cast<uintptr_t>(SymbolTblPtr))
+    report_fatal_error("Symbol table entry is outside of symbol table.");
+
+  uint32_t NumberOfSymTableEntries =
+      is64Bit() ? getNumberOfSymbolTableEntries64()
+                : getLogicalNumberOfSymbolTableEntries32();
+  if (SymbolEntPtr >=
+      getWithOffset(SymbolTblPtr, SYM_TAB_ENTRY_SIZE * NumberOfSymTableEntries))
+    report_fatal_error("Symbol table entry is outside of symbol table.");
+#endif
+
+  ptrdiff_t Offset = reinterpret_cast<const char *>(SymbolEntPtr) -
+                     reinterpret_cast<const char *>(SymbolTblPtr);
+
+#ifndef NDEBUG
+  if (Offset % SYM_TAB_ENTRY_SIZE != 0)
+    report_fatal_error(
+        "Symbol table entry position is not valid inside of symbol table.");
+#endif
+
+  return Offset / 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;
 }
 

 StringRef XCOFFSectionHeader32::getName() const {
   return generateStringRef(Name);
 }
 
 StringRef XCOFFSectionHeader64::getName() const {
   return generateStringRef(Name);
 }
 
+XCOFF::StorageClass XCOFFSymbolRef::getStorageClass() const {
+  return OwningObjectPtr->toSymbolEntry(SymEntDataRef)->StorageClass;
+}
+
+uint8_t XCOFFSymbolRef::getNumberOfAuxEntries() const {
+  return OwningObjectPtr->toSymbolEntry(SymEntDataRef)->NumberOfAuxEntries;
+}
+
+const XCOFFCSectAuxEnt32 *XCOFFSymbolRef::getXCOFFCSectAuxEnt32() const {
+  assert(!OwningObjectPtr->is64Bit() &&
+         "32-bit interface called on 64-bit object file.");
+  assert(hasCSectAuxEnt() && "No CSect Auxiliary Entry is found.");
+  uintptr_t AuxAddr = getWithOffset(
+      SymEntDataRef.p, SYM_TAB_ENTRY_SIZE * getNumberOfAuxEntries());
+  return reinterpret_cast<const XCOFFCSectAuxEnt32 *>(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 (OwningObjectPtr->is64Bit())
+    report_fatal_error("64-bit support is unimplemented yet.");
+
+  if (getType() & FUNCTION_SYM)
+    return true;
+
+  if (!hasCSectAuxEnt())
+    return false;
+
+  const XCOFFCSectAuxEnt32 *CSectAuxEnt = getXCOFFCSectAuxEnt32();
+  // The symbol is label definition.
+  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

+# This file tests the ability of llvm-readobj to generate symbol table for 
+# 32-bit XCOFF object file.
+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:     }
+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:     }
+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:     }
+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:       ParameterHashIndex: 0x0
+SYMBOL32-NEXT:       TypeChkSectNum: 0x0
+SYMBOL32-NEXT:       SymbolAlignmentLog2: 7
+SYMBOL32-NEXT:       SymbolType: XTY_SD (0x1)
+SYMBOL32-NEXT:       StorageMappingClass: XMC_PR (0x0)
+SYMBOL32-NEXT:       StabInfoIndex: 0x0
+SYMBOL32-NEXT:       StabSectNum: 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:       ParameterHashIndex: 0x0
+SYMBOL32-NEXT:       TypeChkSectNum: 0x0
+SYMBOL32-NEXT:       SymbolAlignmentLog2: 0
+SYMBOL32-NEXT:       SymbolType: XTY_LD (0x2)
+SYMBOL32-NEXT:       StorageMappingClass: XMC_PR (0x0)
+SYMBOL32-NEXT:       StabInfoIndex: 0x0
+SYMBOL32-NEXT:       StabSectNum: 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:       ParameterHashIndex: 0x0
+SYMBOL32-NEXT:       TypeChkSectNum: 0x0
+SYMBOL32-NEXT:       SymbolAlignmentLog2: 0
+SYMBOL32-NEXT:       SymbolType: XTY_LD (0x2)
+SYMBOL32-NEXT:       StorageMappingClass: XMC_PR (0x0)
+SYMBOL32-NEXT:       StabInfoIndex: 0x0
+SYMBOL32-NEXT:       StabSectNum: 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:       ParameterHashIndex: 0x0
+SYMBOL32-NEXT:       TypeChkSectNum: 0x0
+SYMBOL32-NEXT:       SymbolAlignmentLog2: 2
+SYMBOL32-NEXT:       SymbolType: XTY_SD (0x1)
+SYMBOL32-NEXT:       StorageMappingClass: XMC_TC0 (0xF)
+SYMBOL32-NEXT:       StabInfoIndex: 0x0
+SYMBOL32-NEXT:       StabSectNum: 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:       ParameterHashIndex: 0x0
+SYMBOL32-NEXT:       TypeChkSectNum: 0x0
+SYMBOL32-NEXT:       SymbolAlignmentLog2: 2
+SYMBOL32-NEXT:       SymbolType: XTY_SD (0x1)
+SYMBOL32-NEXT:       StorageMappingClass: XMC_TC (0x3)
+SYMBOL32-NEXT:       StabInfoIndex: 0x0
+SYMBOL32-NEXT:       StabSectNum: 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:       ParameterHashIndex: 0x0
+SYMBOL32-NEXT:       TypeChkSectNum: 0x0
+SYMBOL32-NEXT:       SymbolAlignmentLog2: 3
+SYMBOL32-NEXT:       SymbolType: XTY_SD (0x1)
+SYMBOL32-NEXT:       StorageMappingClass: XMC_RO (0x1)
+SYMBOL32-NEXT:       StabInfoIndex: 0x0
+SYMBOL32-NEXT:       StabSectNum: 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:       ParameterHashIndex: 0x0
+SYMBOL32-NEXT:       TypeChkSectNum: 0x0
+SYMBOL32-NEXT:       SymbolAlignmentLog2: 2
+SYMBOL32-NEXT:       SymbolType: XTY_CM (0x3)
+SYMBOL32-NEXT:       StorageMappingClass: XMC_RW (0x5)
+SYMBOL32-NEXT:       StabInfoIndex: 0x0
+SYMBOL32-NEXT:       StabSectNum: 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:       ParameterHashIndex: 0x0
+SYMBOL32-NEXT:       TypeChkSectNum: 0x0
+SYMBOL32-NEXT:       SymbolAlignmentLog2: 2
+SYMBOL32-NEXT:       SymbolType: XTY_SD (0x1)
+SYMBOL32-NEXT:       StorageMappingClass: XMC_TC (0x3)
+SYMBOL32-NEXT:       StabInfoIndex: 0x0
+SYMBOL32-NEXT:       StabSectNum: 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:       ParameterHashIndex: 0x0
+SYMBOL32-NEXT:       TypeChkSectNum: 0x0
+SYMBOL32-NEXT:       SymbolAlignmentLog2: 2
+SYMBOL32-NEXT:       SymbolType: XTY_SD (0x1)
+SYMBOL32-NEXT:       StorageMappingClass: XMC_DS (0xA)
+SYMBOL32-NEXT:       StabInfoIndex: 0x0
+SYMBOL32-NEXT:       StabSectNum: 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:       ParameterHashIndex: 0x0
+SYMBOL32-NEXT:       TypeChkSectNum: 0x0
+SYMBOL32-NEXT:       SymbolAlignmentLog2: 2
+SYMBOL32-NEXT:       SymbolType: XTY_SD (0x1)
+SYMBOL32-NEXT:       StorageMappingClass: XMC_TC (0x3)
+SYMBOL32-NEXT:       StabInfoIndex: 0x0
+SYMBOL32-NEXT:       StabSectNum: 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:       ParameterHashIndex: 0x0
+SYMBOL32-NEXT:       TypeChkSectNum: 0x0
+SYMBOL32-NEXT:       SymbolAlignmentLog2: 2
+SYMBOL32-NEXT:       SymbolType: XTY_SD (0x1)
+SYMBOL32-NEXT:       StorageMappingClass: XMC_RW (0x5)
+SYMBOL32-NEXT:       StabInfoIndex: 0x0
+SYMBOL32-NEXT:       StabSectNum: 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:       ParameterHashIndex: 0x0
+SYMBOL32-NEXT:       TypeChkSectNum: 0x0
+SYMBOL32-NEXT:       SymbolAlignmentLog2: 2
+SYMBOL32-NEXT:       SymbolType: XTY_SD (0x1)
+SYMBOL32-NEXT:       StorageMappingClass: XMC_TC (0x3)
+SYMBOL32-NEXT:       StabInfoIndex: 0x0
+SYMBOL32-NEXT:       StabSectNum: 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:       ParameterHashIndex: 0x0
+SYMBOL32-NEXT:       TypeChkSectNum: 0x0
+SYMBOL32-NEXT:       SymbolAlignmentLog2: 2
+SYMBOL32-NEXT:       SymbolType: XTY_SD (0x1)
+SYMBOL32-NEXT:       StorageMappingClass: XMC_DS (0xA)
+SYMBOL32-NEXT:       StabInfoIndex: 0x0
+SYMBOL32-NEXT:       StabSectNum: 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:       ParameterHashIndex: 0x0
+SYMBOL32-NEXT:       TypeChkSectNum: 0x0
+SYMBOL32-NEXT:       SymbolAlignmentLog2: 2
+SYMBOL32-NEXT:       SymbolType: XTY_SD (0x1)
+SYMBOL32-NEXT:       StorageMappingClass: XMC_TC (0x3)
+SYMBOL32-NEXT:       StabInfoIndex: 0x0
+SYMBOL32-NEXT:       StabSectNum: 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:       ParameterHashIndex: 0x0
+SYMBOL32-NEXT:       TypeChkSectNum: 0x0
+SYMBOL32-NEXT:       SymbolAlignmentLog2: 0
+SYMBOL32-NEXT:       SymbolType: XTY_ER (0x0)
+SYMBOL32-NEXT:       StorageMappingClass: XMC_UA (0x4)
+SYMBOL32-NEXT:       StabInfoIndex: 0x0
+SYMBOL32-NEXT:       StabSectNum: 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:       ParameterHashIndex: 0x0
+SYMBOL32-NEXT:       TypeChkSectNum: 0x0
+SYMBOL32-NEXT:       SymbolAlignmentLog2: 2
+SYMBOL32-NEXT:       SymbolType: XTY_SD (0x1)
+SYMBOL32-NEXT:       StorageMappingClass: XMC_TC (0x3)
+SYMBOL32-NEXT:       StabInfoIndex: 0x0
+SYMBOL32-NEXT:       StabSectNum: 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:       ParameterHashIndex: 0x0
+SYMBOL32-NEXT:       TypeChkSectNum: 0x0
+SYMBOL32-NEXT:       SymbolAlignmentLog2: 0
+SYMBOL32-NEXT:       SymbolType: XTY_ER (0x0)
+SYMBOL32-NEXT:       StorageMappingClass: XMC_PR (0x0)
+SYMBOL32-NEXT:       StabInfoIndex: 0x0
+SYMBOL32-NEXT:       StabSectNum: 0x0
+SYMBOL32-NEXT:     }
+SYMBOL32-NEXT:   }
+SYMBOL32-NEXT: ]
+
+# The object file used is generated by the following source file 
+# and command on AIX:
+#
+# > cat aix_xcoff_xlc_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);
+# }
+# 
+# > xlc -c aix_xcoff_xlc_test8.c
+

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 printCSectAuxEnt32(const XCOFFCSectAuxEnt32 *AuxEntPtr);
+  void printSectAuxEntForStat(const XCOFFSectAuxEntForStat *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
+};
+
+void XCOFFDumper::printFileAuxEnt(const XCOFFFileAuxEnt *AuxEntPtr) {
+  if (Obj.is64Bit())
+    report_fatal_error(
+        "Printing for File Auxiliary Entry in 64-bit is unimplemented.");
+  StringRef FileName =
+      unwrapOrError(Obj.getFileName(), Obj.getCFileName(AuxEntPtr));
+  DictScope SymDs(W, "File Auxiliary Entry");
+  W.printNumber("Index",
+                Obj.getSymbolIndex(reinterpret_cast<uintptr_t>(AuxEntPtr)));
+  W.printString("Name", FileName);
+  W.printEnum("Type", (uint8_t)AuxEntPtr->Type, makeArrayRef(FileStringType));
+}
+
+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::printCSectAuxEnt32(const XCOFFCSectAuxEnt32 *AuxEntPtr) {
+  assert(!Obj.is64Bit() && "32-bit interface called on 64-bit object file.");
+
+  DictScope SymDs(W, "CSect Auxiliary Entry");
+  W.printNumber("Index",
+                Obj.getSymbolIndex(reinterpret_cast<uintptr_t>(AuxEntPtr)));
+  if ((AuxEntPtr->SymbolAlignmentAndType & SymbolTypeMask) == XCOFF::XTY_LD)
+    W.printNumber("ContainingCSectSymbolIndex", AuxEntPtr->SectionLen);
+  else
+    W.printNumber("SectionLen", AuxEntPtr->SectionLen);
+  W.printHex("ParameterHashIndex", AuxEntPtr->ParameterHashIndex);
+  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("StabInfoIndex", AuxEntPtr->StabInfoIndex);
+  W.printHex("StabSectNum", AuxEntPtr->StabSectNum);
+}
+
+void XCOFFDumper::printSectAuxEntForStat(
+    const XCOFFSectAuxEntForStat *AuxEntPtr) {
+  DictScope SymDs(W, "Sect Auxiliary Entry For Stat");
+  W.printNumber("Index",
+                Obj.getSymbolIndex(reinterpret_cast<uintptr_t>(AuxEntPtr)));
+  W.printNumber("SectionLength", AuxEntPtr->SectionLength);
+  W.printNumber("NumberOfRelocEnt", AuxEntPtr->NumberOfRelocEnt);
+  W.printNumber("NumberOfLineNum", AuxEntPtr->NumberOfLineNum);
+}
+
+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_STAT:
+    return "Value (RelocatableAddress)";
+  case XCOFF::C_FILE:
+    return "Value (SymbolTableIndex)";
+  case XCOFF::C_FCN:
+  case XCOFF::C_BLOCK:
+  case XCOFF::C_FUN:
+  case XCOFF::C_STSYM:
+  case XCOFF::C_BINCL:
+  case XCOFF::C_EINCL:
+  case XCOFF::C_INFO:
+  case XCOFF::C_BSTAT:
+  case XCOFF::C_LSYM:
+  case XCOFF::C_PSYM:
+  case XCOFF::C_RPSYM:
+  case XCOFF::C_RSYM:
+  case XCOFF::C_ECOML:
+  case XCOFF::C_DWARF:
+    llvm_unreachable("This StorageClass for the symbol is not yet implemented");
+  default:
+    return "Value";
+  }
+}
+
+void XCOFFDumper::printSymbol(const SymbolRef &S) {
+  if (Obj.is64Bit())
+    report_fatal_error("64-bit support is unimplmented.");
 
+  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.getFileName(), Obj.getSymbolName(SymbolDRI));
+
+  W.printNumber("Index",
+                Obj.getSymbolIndex(reinterpret_cast<uintptr_t>(SymbolEntPtr)));
+  W.printString("Name", SymbolName);
+  W.printHex(GetSymbolValueName(SymbolEntPtr->StorageClass),
+             SymbolEntPtr->Value);
+
+  StringRef SectionName =
+      unwrapOrError(Obj.getFileName(), 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)
+      report_fatal_error("Function auxiliary entry printing is unimplemented.");
+
+    // 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 XCOFFCSectAuxEnt32 *CSectAuxEntPtr;
+    CSectAuxEntPtr = reinterpret_cast<const XCOFFCSectAuxEnt32 *>(
+        SymbolEntPtr + NumberOfAuxEntries);
+    printCSectAuxEnt32(CSectAuxEntPtr);
+    break;
+  case XCOFF::C_STAT:
+    const XCOFFSectAuxEntForStat *StatAuxEntPtr;
+    StatAuxEntPtr =
+        reinterpret_cast<const XCOFFSectAuxEntForStat *>(SymbolEntPtr + 1);
+    printSectAuxEntForStat(StatAuxEntPtr);
+    break;
+  case XCOFF::C_DWARF:
+  case XCOFF::C_BLOCK:
+  case XCOFF::C_FCN:
+    report_fatal_error("Symbol table entry printing for this storage class "
+                       "type is unimplemented.");
+    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");

 template <typename T>
 void XCOFFDumper::printSectionHeaders(ArrayRef<T> Sections) {
   ListScope Group(W, "Sections");
 
   uint16_t Index = 1;
   for (const T &Sec : Sections) {
     DictScope SecDS(W, "Section");
 
     W.printNumber("Index", Index++);
     W.printString("Name", Sec.getName());
 
     W.printHex("PhysicalAddress", Sec.PhysicalAddress);
     W.printHex("VirtualAddress", Sec.VirtualAddress);
     W.printHex("Size", Sec.SectionSize);
     W.printHex("RawDataOffset", Sec.FileOffsetToRawData);
     W.printHex("RelocationPointer", Sec.FileOffsetToRelocationInfo);
     W.printHex("LineNumberPointer", Sec.FileOffsetToLineNumberInfo);