[llvm-readobj][XCOFF] dump auxiliary symbols.

[Esme]

Summary

The patch adds support for dumping auxiliary symbols in llvm-readobj for XCOFF.

[jhenderson]

I recommend separating the migration to YAML from binaries into a separate successor patch, to avoid confusion.

llvm/test/tools/llvm-readobj/XCOFF/symbols-invalid.test

6

How about "a non-function C_EXT/C_WEAKEXT/C_HIDEXT symbol should have only..."?

You probably should have this test case for each of the three different types. If viable, I'd also dynamically change the warning to explicitly state the type of the symbol (i.e. something like "a non-function C_EXT symbol ..." and "a non-function C_WEAKEXT symbol ..." etc).

Finally, ideally you'd incldue the symbol's name if possible in this warning, since it's not necessarily clear out-of-context which symbol this warning refers to. Applies to each of the other warnings too.

20

Nit: double blank line.

30

Same as above: test both cases, adn consider being explicity about which particular type of symbol this is.

32

Why specifically the file auxiliary entry and not others?

llvm/tools/llvm-readobj/XCOFFDumper.cpp

298

436

Why do we only check this in the debug case? It seems like it's something that's applicable for all cases?

441

Unless you're explicitly calling printf (which you aren't) don't call a function based on that name.

511–514

Skip doing what?

[Esme]

Move the migration to YAML from binaries into a separate patch D114434.

llvm/test/tools/llvm-readobj/XCOFF/symbols-invalid.test

6

Thanks!

32

This is a case from the deleted file llvm/test/tools/llvm-readobj/XCOFF/file-aux-wrong64.test

[Higuoxing]

llvm/include/llvm/Object/XCOFFObjectFile.h

375–379

It looks that the variables' name are not consistent across this file? Is there any particular reason for that? e.g., Why use ReservedZeros_1 instead of ReservedZeros1 and LineNum_Hi instead of LineNumLo?

llvm/test/tools/llvm-readobj/XCOFF/symbols-invalid.test

63–66

Looks that the indention is broken here?

llvm/tools/llvm-readobj/XCOFFDumper.cpp

342–343

Nit: insert a blank space between the field name and the parenthesis.

359

Nit: blank line.

[jhenderson]

llvm/test/tools/llvm-readobj/XCOFF/symbols-invalid.test

6

It looks like you haven't addressed the first part of this comment?

llvm/tools/llvm-readobj/XCOFFDumper.cpp

513

Should have spotted this earlier, but it should be "at index N" not "with index N". Same goes for the other message(s).

594

I wonder if a simple function that converts enum values to strings would be useful here and elsewhere that you do similar things? I believe there are similar things in ELF.

[Esme]

Address comments.

[jhenderson]

llvm/test/tools/llvm-readobj/XCOFF/symbols-invalid.test

52

You can leave the # in the right place, and just add spaces to pad.

llvm/tools/llvm-readobj/XCOFFDumper.cpp

67

I'm slightly surprised this doesn't already exist in our code? Have you copied it from somewhere? If so, where, and could you just move such a function declaration into a common header for reuse?

[Esme]

Address comments.

[jhenderson]

llvm/lib/Object/XCOFFObjectFile.cpp

1116–1117

Is "should" appropriate here? Is it never a function? Or is it potentially a function that we can't identify? If the former, delete the word. If the latter, replace the phrase "then this symbol should not be a function" with "then treat this symbol as if it isn't a function".

llvm/tools/llvm-readobj/XCOFFDumper.cpp

532

No need for else after continue

572–574

There are several checks identical to this one. I think it would be useful to pull them into a helper lambda that takes a C_* enum and reports the message.

[Esme]

Address comments.

[jhenderson]

LGTM, but please wait for @Higuoxing too.

[thakis]

This breaks tests on windows: http://45.33.8.238/win/52389/step_11.txt

Please take a look and revert for now if it takes a while to fix.

[jhenderson]

llvm/test/tools/llvm-readobj/XCOFF/symbols-invalid.test

6

The problem is a missing {{(.exe)?}} after the tool name. Usually, we don't include tool names in the check, and just check from "warning:" onwards.

Applies throughout this test.

[thakis]

llvm/test/tools/llvm-readobj/XCOFF/symbols-invalid.test

6

Hm, normally we don't print "toolname.exe: " in diags on Windows, but just "toolname: ". We usually also don't print the full path to the tool but just the basename.

Maybe the Right Fix is to fix the diag output in llvm-readobj instead?

6

(…but that seems admittedly mostly independent of this patch here. So for relanding, just fixing the test expectations is fine too.)

[thakis]

(Reverted for now.)

llvm/include/llvm/Object/XCOFFObjectFile.h

 
 struct XCOFFSectAuxEntForStat {
   support::ubig32_t SectionLength;
   support::ubig16_t NumberOfRelocEnt;
   support::ubig16_t NumberOfLineNum;
   uint8_t Pad[10];
 }; // 32-bit XCOFF file only.
 
+struct XCOFFFunctionAuxEnt32 {
+  support::ubig32_t OffsetToExceptionTbl;
+  support::ubig32_t SizeOfFunction;
+  support::ubig32_t PtrToLineNum;
+  support::big32_t SymIdxOfNextBeyond;
+  uint8_t Pad[2];
+};
+
+struct XCOFFFunctionAuxEnt64 {
+  support::ubig64_t PtrToLineNum;
+  support::ubig32_t SizeOfFunction;
+  support::big32_t SymIdxOfNextBeyond;
+  uint8_t Pad;
+  XCOFF::SymbolAuxType AuxType; // Contains _AUX_FCN; Type of auxiliary entry
+};
+
+struct XCOFFExceptionAuxEnt {
+  support::ubig64_t OffsetToExceptionTbl;
+  support::ubig32_t SizeOfFunction;
+  support::big32_t SymIdxOfNextBeyond;
+  uint8_t Pad;
+  XCOFF::SymbolAuxType AuxType; // Contains _AUX_EXCEPT; Type of auxiliary entry
+};
+
+struct XCOFFBlockAuxEnt32 {
+  uint8_t ReservedZeros1[2];
+  support::ubig16_t LineNumHi;
+  support::ubig16_t LineNumLo;
+  uint8_t ReservedZeros2[12];
+};
+
+struct XCOFFBlockAuxEnt64 {
+  support::ubig32_t LineNum;
+  uint8_t Pad[13];
+  XCOFF::SymbolAuxType AuxType; // Contains _AUX_SYM; Type of auxiliary entry
+};
+
+struct XCOFFSectAuxEntForDWARF32 {
+  support::ubig32_t LengthOfSectionPortion;
+  uint8_t Pad1[4];
+  support::ubig32_t NumberOfRelocEnt;
+  uint8_t Pad2[6];
+};
+
+struct XCOFFSectAuxEntForDWARF64 {
+  support::ubig64_t LengthOfSectionPortion;
+  support::ubig64_t NumberOfRelocEnt;
+  uint8_t Pad;
+  XCOFF::SymbolAuxType AuxType; // Contains _AUX_SECT; Type of Auxillary entry
+};
+
 template <typename AddressType> struct XCOFFRelocation {
   // Masks for packing/unpacking the r_rsize field of relocations.
 
   // The msb is used to indicate if the bits being relocated are signed or
   // unsigned.
   static constexpr uint8_t XR_SIGN_INDICATOR_MASK = 0x80;
 
   // The 2nd msb is used to indicate that the binder has replaced/modified the

llvm/lib/Object/XCOFFObjectFile.cpp

 bool XCOFFSymbolRef::isFunction() const {
   if (!isCsectSymbol())
     return false;
 
   if (getSymbolType() & FunctionSym)
     return true;
 
   Expected<XCOFFCsectAuxRef> ExpCsectAuxEnt = getXCOFFCsectAuxRef();
-  if (!ExpCsectAuxEnt)
+  if (!ExpCsectAuxEnt) {
+    // If we could not get the CSECT auxiliary entry, then this symbol should
+    // not be a function. So consume the error and return `false` to move on.
+    consumeError(ExpCsectAuxEnt.takeError());
     return false;
+  }
 
   const XCOFFCsectAuxRef CsectAuxRef = ExpCsectAuxEnt.get();
 
   // A function definition should be a label definition.
   // FIXME: This is not necessarily the case when -ffunction-sections is
   // enabled.
   if (!CsectAuxRef.isLabel())
     return false;

llvm/test/tools/llvm-readobj/XCOFF/symbols-invalid.test

-## This file tests the raw data output ability when a file auxiliary entry does
-## not have the matching auxiliary type.
+## Test that we report warnings or dump raw data when symbols are invalid.
+
+# RUN: yaml2obj %s --docnum=1 -o %t1
+# RUN: llvm-readobj --syms %t1 2>&1 | FileCheck %s -DFILE=%t1 --check-prefix=CASE1
+
+# CASE1: llvm-readobj: warning: '[[FILE]]': the non-function C_EXT symbol at index 1 should have only 1 auxiliary entry, i.e. the CSECT auxiliary entry
+
+--- !XCOFF
+FileHeader:
+  MagicNumber: 0x1DF
+Symbols:
+  - Name: .sym
+  - Name:               .fun
+    StorageClass:       [[STORAGECLASS='C_EXT']]
+    NumberOfAuxEntries: 2
+
+# RUN: yaml2obj %s --docnum=1 -DSTORAGECLASS='C_WEAKEXT' -o %t2
+# RUN: llvm-readobj --syms %t2 2>&1 | FileCheck %s -DFILE=%t2 --check-prefix=CASE2
+
+# CASE2: llvm-readobj: warning: '[[FILE]]': the non-function C_WEAKEXT symbol at index 1 should have only 1 auxiliary entry, i.e. the CSECT auxiliary entry
+
+# RUN: yaml2obj %s --docnum=1 -DSTORAGECLASS='C_HIDEXT' -o %t3
+# RUN: llvm-readobj --syms %t3 2>&1 | FileCheck %s -DFILE=%t3 --check-prefix=CASE3
 
-# RUN: yaml2obj %s -o %t
-# RUN: llvm-readobj --syms %t | FileCheck %s
+# CASE3: llvm-readobj: warning: '[[FILE]]': the non-function C_HIDEXT symbol at index 1 should have only 1 auxiliary entry, i.e. the CSECT auxiliary entry
+
+# RUN: yaml2obj %s --docnum=1 -DSTORAGECLASS='C_STAT' -o %t4
+# RUN: llvm-readobj --syms %t4 2>&1 | FileCheck %s -DFILE=%t4 --check-prefix=CASE4
+
+# CASE4: llvm-readobj: warning: '[[FILE]]': the C_STAT symbol at index 1 should not have more than 1 auxiliary entry
+
+# RUN: yaml2obj %s --docnum=1 -DSTORAGECLASS='C_DWARF' -o %t5
+# RUN: llvm-readobj --syms %t5 2>&1 | FileCheck %s -DFILE=%t5 --check-prefix=CASE5
+
+# CASE5: llvm-readobj: warning: '[[FILE]]': the C_DWARF symbol at index 1 should not have more than 1 auxiliary entry
+
+# RUN: yaml2obj %s --docnum=1 -DSTORAGECLASS='C_BLOCK' -o %t6
+# RUN: llvm-readobj --syms %t6 2>&1 | FileCheck %s -DFILE=%t6 --check-prefix=CASE6
+
+# CASE6: llvm-readobj: warning: '[[FILE]]': the C_BLOCK symbol at index 1 should not have more than 1 auxiliary entry
+
+# RUN: yaml2obj %s --docnum=1 -DSTORAGECLASS='C_FCN' -o %t7
+# RUN: llvm-readobj --syms %t7 2>&1 | FileCheck %s -DFILE=%t7 --check-prefix=CASE7
+
+# CASE7: llvm-readobj: warning: '[[FILE]]': the C_FCN symbol at index 1 should not have more than 1 auxiliary entry
+
+## This case tests the raw data output ability when a file auxiliary entry does
+## not have the matching auxiliary type.
+# RUN: yaml2obj %s --docnum=2 -o %t8
+# RUN: llvm-readobj --syms %t8 | FileCheck %s --strict-whitespace --match-full-lines --check-prefix=CASE8
 
-# CHECK:      Symbols [
-# CHECK-NEXT:   Symbol {
-# CHECK-NEXT:     Index: 0
-# CHECK-NEXT:     Name: .fun
-# CHECK-NEXT:     Value (SymbolTableIndex): 0x0
-# CHECK-NEXT:     Section: N_UNDEF
-# CHECK-NEXT:     Source Language ID: TB_C (0x0)
-# CHECK-NEXT:     CPU Version ID: 0x0
-# CHECK-NEXT:     StorageClass: C_FILE (0x67)
-# CHECK-NEXT:     NumberOfAuxEntries: 1
-# CHECK-NEXT:     !Unexpected raw auxiliary entry data:
-# CHECK-NEXT:     00000000 00000001 00020300 00000000 00fb
-# CHECK-NEXT:   }
-# CHECK-NEXT: ]
+     # CASE8:Symbols [
+# CASE8-NEXT:  Symbol {
+# CASE8-NEXT:    Index: 0
+# CASE8-NEXT:    Name: .fun
+# CASE8-NEXT:    Value (SymbolTableIndex): 0x0
+# CASE8-NEXT:    Section: N_UNDEF
+# CASE8-NEXT:    Source Language ID: TB_C (0x0)
+# CASE8-NEXT:    CPU Version ID: 0x0
+# CASE8-NEXT:    StorageClass: C_FILE (0x67)
+# CASE8-NEXT:    NumberOfAuxEntries: 1
+# CASE8-NEXT:    !Unexpected raw auxiliary entry data:
+# CASE8-NEXT:    00000000 00000001 00020300 00000000 00fb
+# CASE8-NEXT:  }
+# CASE8-NEXT:]
 
 --- !XCOFF
 FileHeader:
   MagicNumber: 0x1F7
 Symbols:
   - Name:         .fun
     StorageClass: C_FILE
     AuxEntries:
       - Type:                   AUX_CSECT
         ParameterHashIndex:     1
         TypeChkSectNum:         2
         SymbolAlignmentAndType: 3
         StorageMappingClass:    XMC_PR

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

AuxEntries:
       - Type:                   AUX_CSECT
         ParameterHashIndex:     8
         TypeChkSectNum:         9
         SymbolAlignmentAndType: 1
         StorageMappingClass:    XMC_PR
         SectionOrLength:        256
         StabInfoIndex:          2
         StabSectNum:            3
+## The C_WEAKEXT symbol with a Function auxiliary entry and a CSECT auxiliary entry.
+  - Name:               .fun3
+    Value:              0x0
+    Section:            N_DEBUG
+    Type:               0x20
+    StorageClass:       C_WEAKEXT
+    NumberOfAuxEntries: 2
+    AuxEntries:
+      - Type:                 AUX_FCN
+        OffsetToExceptionTbl: 2
+        SizeOfFunction:       3
+        SymIdxOfNextBeyond:   4
+        PtrToLineNum:         5
+      - Type:                   AUX_CSECT
+        ParameterHashIndex:     11
+        TypeChkSectNum:         22
+        SymbolAlignmentAndType: 33
+        StorageMappingClass:    XMC_PR
+        SectionOrLength:        256
+        StabInfoIndex:          44
+        StabSectNum:            55
+## The C_DWARF symbol with a SECT auxiliary entry.
+  - Name:               .fun4
+    Section:            N_DEBUG
+    StorageClass:       C_DWARF
+    NumberOfAuxEntries: 1
+    AuxEntries:
+      - Type:                   AUX_SECT
+        LengthOfSectionPortion: 2
+        NumberOfRelocEnt:       3
+## The C_BLOCK symbol with a Block auxiliary entry.
+  - Name:               .fun5
+    StorageClass:       C_BLOCK
+    NumberOfAuxEntries: 1
+    AuxEntries:
+      - Type:      AUX_SYM
+        LineNumHi: 2
+        LineNumLo: 3
+## The C_FCN symbol with a Block auxiliary entry.
+  - Name:               .fun6
+    StorageClass:       C_FCN
+    NumberOfAuxEntries: 1
+    AuxEntries:
+      - Type:      AUX_SYM
+        LineNumHi: 2
+        LineNumLo: 3
 
 # SYMBOL32:      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: TB_C (0x0)

 # SYMBOL32-NEXT:       TypeChkSectNum: 0x9
 # SYMBOL32-NEXT:       SymbolAlignmentLog2: 0
 # SYMBOL32-NEXT:       SymbolType: XTY_SD (0x1)
 # SYMBOL32-NEXT:       StorageMappingClass: XMC_PR (0x0)
 # SYMBOL32-NEXT:       StabInfoIndex: 0x2
 # SYMBOL32-NEXT:       StabSectNum: 0x3
 # SYMBOL32-NEXT:     }
 # SYMBOL32-NEXT:   }
+# SYMBOL32-NEXT:   Symbol {
+# SYMBOL32-NEXT:     Index: 12
+# SYMBOL32-NEXT:     Name: .fun3
+# SYMBOL32-NEXT:     Value (RelocatableAddress): 0x0
+# SYMBOL32-NEXT:     Section: N_DEBUG
+# SYMBOL32-NEXT:     Type: 0x20
+# SYMBOL32-NEXT:     StorageClass: C_WEAKEXT (0x6F)
+# SYMBOL32-NEXT:     NumberOfAuxEntries: 2
+# SYMBOL32-NEXT:     Function Auxiliary Entry {
+# SYMBOL32-NEXT:       Index: 13
+# SYMBOL32-NEXT:       OffsetToExceptionTable: 0x2
+# SYMBOL32-NEXT:       SizeOfFunction: 0x3
+# SYMBOL32-NEXT:       PointerToLineNum: 0x5
+# SYMBOL32-NEXT:       SymbolIndexOfNextBeyond: 4
+# SYMBOL32-NEXT:     }
+# SYMBOL32-NEXT:     CSECT Auxiliary Entry {
+# SYMBOL32-NEXT:       Index: 14
+# SYMBOL32-NEXT:       SectionLen: 256
+# SYMBOL32-NEXT:       ParameterHashIndex: 0xB
+# SYMBOL32-NEXT:       TypeChkSectNum: 0x16
+# SYMBOL32-NEXT:       SymbolAlignmentLog2: 4
+# SYMBOL32-NEXT:       SymbolType: XTY_SD (0x1)
+# SYMBOL32-NEXT:       StorageMappingClass: XMC_PR (0x0)
+# SYMBOL32-NEXT:       StabInfoIndex: 0x2C
+# SYMBOL32-NEXT:       StabSectNum: 0x37
+# SYMBOL32-NEXT:     }
+# SYMBOL32-NEXT:   }
+# SYMBOL32-NEXT:   Symbol {
+# SYMBOL32-NEXT:     Index: 15
+# SYMBOL32-NEXT:     Name: .fun4
+# SYMBOL32-NEXT:     Value (OffsetInDWARF): 0x0
+# SYMBOL32-NEXT:     Section: N_DEBUG
+# SYMBOL32-NEXT:     Type: 0x0
+# SYMBOL32-NEXT:     StorageClass: C_DWARF (0x70)
+# SYMBOL32-NEXT:     NumberOfAuxEntries: 1
+# SYMBOL32-NEXT:     Sect Auxiliary Entry For DWARF {
+# SYMBOL32-NEXT:       Index: 16
+# SYMBOL32-NEXT:       LengthOfSectionPortion: 0x2
+# SYMBOL32-NEXT:       NumberOfRelocEntries: 3
+# SYMBOL32-NEXT:     }
+# SYMBOL32-NEXT:   }
+# SYMBOL32-NEXT:   Symbol {
+# SYMBOL32-NEXT:     Index: 17
+# SYMBOL32-NEXT:     Name: .fun5
+# SYMBOL32-NEXT:     Value (RelocatableAddress): 0x0
+# SYMBOL32-NEXT:     Section: N_UNDEF
+# SYMBOL32-NEXT:     Type: 0x0
+# SYMBOL32-NEXT:     StorageClass: C_BLOCK (0x64)
+# SYMBOL32-NEXT:     NumberOfAuxEntries: 1
+# SYMBOL32-NEXT:     Block Auxiliary Entry {
+# SYMBOL32-NEXT:       Index: 18
+# SYMBOL32-NEXT:       LineNumber (High 2 Bytes): 0x2
+# SYMBOL32-NEXT:       LineNumber (Low 2 Bytes): 0x3
+# SYMBOL32-NEXT:     }
+# SYMBOL32-NEXT:   }
+# SYMBOL32-NEXT:   Symbol {
+# SYMBOL32-NEXT:     Index: 19
+# SYMBOL32-NEXT:     Name: .fun6
+# SYMBOL32-NEXT:     Value (RelocatableAddress): 0x0
+# SYMBOL32-NEXT:     Section: N_UNDEF
+# SYMBOL32-NEXT:     Type: 0x0
+# SYMBOL32-NEXT:     StorageClass: C_FCN (0x65)
+# SYMBOL32-NEXT:     NumberOfAuxEntries: 1
+# SYMBOL32-NEXT:     Block Auxiliary Entry {
+# SYMBOL32-NEXT:       Index: 20
+# SYMBOL32-NEXT:       LineNumber (High 2 Bytes): 0x2
+# SYMBOL32-NEXT:       LineNumber (Low 2 Bytes): 0x3
+# SYMBOL32-NEXT:     }
+# SYMBOL32-NEXT:   }
 # SYMBOL32-NEXT: ]

llvm/test/tools/llvm-readobj/XCOFF/symbols64.test

- Name:               .fun2
     AuxEntries:
       - Type:                   AUX_CSECT
         ParameterHashIndex:     8
         TypeChkSectNum:         9
         SymbolAlignmentAndType: 1
         StorageMappingClass:    XMC_PR
         SectionOrLengthLo:      2
         SectionOrLengthHi:      3
+## The C_WEAKEXT symbol with a Function auxiliary entry and a CSECT auxiliary entry.
+  - Name:               .fun3
+    Value:              0x0
+    Section:            N_DEBUG
+    Type:               0x20
+    StorageClass:       C_WEAKEXT
+    NumberOfAuxEntries: 2
+    AuxEntries:
+      - Type:                 AUX_FCN
+        SizeOfFunction:       3
+        SymIdxOfNextBeyond:   4
+        PtrToLineNum:         5
+      - Type:                   AUX_CSECT
+        ParameterHashIndex:     2
+        TypeChkSectNum:         3
+        SymbolAlignmentAndType: 1
+        StorageMappingClass:    XMC_PR
+        SectionOrLengthLo:      4
+        SectionOrLengthHi:      5
+## The C_EXT symbol with a Function auxiliary entry, a CSECT auxiliary entry, and an Exception auxiliary entry.
+  - Name:               .fun4
+    Value:              0x0
+    Section:            .text
+    Type:               0x20
+    StorageClass:       C_EXT
+    NumberOfAuxEntries: 3
+    AuxEntries:
+      - Type:                 AUX_FCN
+        SizeOfFunction:       3
+        SymIdxOfNextBeyond:   4
+        PtrToLineNum:         5
+      - Type:                 AUX_EXCEPT
+        OffsetToExceptionTbl: 2
+        SizeOfFunction:       3
+        SymIdxOfNextBeyond:   4
+      - Type:                   AUX_CSECT
+        ParameterHashIndex:     2
+        TypeChkSectNum:         3
+        SymbolAlignmentAndType: 1
+        StorageMappingClass:    XMC_PR
+        SectionOrLengthLo:      4
+        SectionOrLengthHi:      5
+## The C_DWARF symbol with a SECT auxiliary entry.
+  - Name:               .fun5
+    Section:            N_DEBUG
+    StorageClass:       C_DWARF
+    NumberOfAuxEntries: 1
+    AuxEntries:
+      - Type:                   AUX_SECT
+        LengthOfSectionPortion: 2
+        NumberOfRelocEnt:       3
+## The C_BLOCK symbol with a Block auxiliary entry.
+  - Name:               .fun6
+    StorageClass:       C_BLOCK
+    NumberOfAuxEntries: 1
+    AuxEntries:
+      - Type:    AUX_SYM
+        LineNum: 3
+## The C_FCN symbol with a Block auxiliary entry.
+  - Name:               .fun7
+    StorageClass:       C_FCN
+    NumberOfAuxEntries: 1
+    AuxEntries:
+      - Type:    AUX_SYM
+        LineNum: 3
 
 # SYMBOL64:      Symbols [
 # SYMBOL64-NEXT:   Symbol {
 # SYMBOL64-NEXT:     Index: 0
 # SYMBOL64-NEXT:     Name: .file
 # SYMBOL64-NEXT:     Value (SymbolTableIndex): 0x0
 # SYMBOL64-NEXT:     Section: N_DEBUG
 # SYMBOL64-NEXT:     Source Language ID: TB_C (0x0)

 # SYMBOL64-NEXT:       ParameterHashIndex: 0x8
 # SYMBOL64-NEXT:       TypeChkSectNum: 0x9
 # SYMBOL64-NEXT:       SymbolAlignmentLog2: 0
 # SYMBOL64-NEXT:       SymbolType: XTY_SD (0x1)
 # SYMBOL64-NEXT:       StorageMappingClass: XMC_PR (0x0)
 # SYMBOL64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
 # SYMBOL64-NEXT:     }
 # SYMBOL64-NEXT:   }
+# SYMBOL64-NEXT:   Symbol {
+# SYMBOL64-NEXT:     Index: 10
+# SYMBOL64-NEXT:     Name: .fun3
+# SYMBOL64-NEXT:     Value (RelocatableAddress): 0x0
+# SYMBOL64-NEXT:     Section: N_DEBUG
+# SYMBOL64-NEXT:     Type: 0x20
+# SYMBOL64-NEXT:     StorageClass: C_WEAKEXT (0x6F)
+# SYMBOL64-NEXT:     NumberOfAuxEntries: 2
+# SYMBOL64-NEXT:     Function Auxiliary Entry {
+# SYMBOL64-NEXT:       Index: 11
+# SYMBOL64-NEXT:       SizeOfFunction: 0x3
+# SYMBOL64-NEXT:       PointerToLineNum: 0x5
+# SYMBOL64-NEXT:       SymbolIndexOfNextBeyond: 4
+# SYMBOL64-NEXT:       Auxiliary Type: AUX_FCN (0xFE)
+# SYMBOL64-NEXT:     }
+# SYMBOL64-NEXT:     CSECT Auxiliary Entry {
+# SYMBOL64-NEXT:       Index: 12
+# SYMBOL64-NEXT:       SectionLen: 21474836484
+# SYMBOL64-NEXT:       ParameterHashIndex: 0x2
+# SYMBOL64-NEXT:       TypeChkSectNum: 0x3
+# SYMBOL64-NEXT:       SymbolAlignmentLog2: 0
+# SYMBOL64-NEXT:       SymbolType: XTY_SD (0x1)
+# SYMBOL64-NEXT:       StorageMappingClass: XMC_PR (0x0)
+# SYMBOL64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+# SYMBOL64-NEXT:     }
+# SYMBOL64-NEXT:   }
+# SYMBOL64-NEXT:   Symbol {
+# SYMBOL64-NEXT:     Index: 13
+# SYMBOL64-NEXT:     Name: .fun4
+# SYMBOL64-NEXT:     Value (RelocatableAddress): 0x0
+# SYMBOL64-NEXT:     Section: .text
+# SYMBOL64-NEXT:     Type: 0x20
+# SYMBOL64-NEXT:     StorageClass: C_EXT (0x2)
+# SYMBOL64-NEXT:     NumberOfAuxEntries: 3
+# SYMBOL64-NEXT:     Function Auxiliary Entry {
+# SYMBOL64-NEXT:       Index: 14
+# SYMBOL64-NEXT:       SizeOfFunction: 0x3
+# SYMBOL64-NEXT:       PointerToLineNum: 0x5
+# SYMBOL64-NEXT:       SymbolIndexOfNextBeyond: 4
+# SYMBOL64-NEXT:       Auxiliary Type: AUX_FCN (0xFE)
+# SYMBOL64-NEXT:     }
+# SYMBOL64-NEXT:     Exception Auxiliary Entry {
+# SYMBOL64-NEXT:       Index: 15
+# SYMBOL64-NEXT:       OffsetToExceptionTable: 0x2
+# SYMBOL64-NEXT:       SizeOfFunction: 0x3
+# SYMBOL64-NEXT:       SymbolIndexOfNextBeyond: 4
+# SYMBOL64-NEXT:       Auxiliary Type: AUX_EXCEPT (0xFF)
+# SYMBOL64-NEXT:     }
+# SYMBOL64-NEXT:     CSECT Auxiliary Entry {
+# SYMBOL64-NEXT:       Index: 16
+# SYMBOL64-NEXT:       SectionLen: 21474836484
+# SYMBOL64-NEXT:       ParameterHashIndex: 0x2
+# SYMBOL64-NEXT:       TypeChkSectNum: 0x3
+# SYMBOL64-NEXT:       SymbolAlignmentLog2: 0
+# SYMBOL64-NEXT:       SymbolType: XTY_SD (0x1)
+# SYMBOL64-NEXT:       StorageMappingClass: XMC_PR (0x0)
+# SYMBOL64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+# SYMBOL64-NEXT:     }
+# SYMBOL64-NEXT:   }
+# SYMBOL64-NEXT:   Symbol {
+# SYMBOL64-NEXT:     Index: 17
+# SYMBOL64-NEXT:     Name: .fun5
+# SYMBOL64-NEXT:     Value (OffsetInDWARF): 0x0
+# SYMBOL64-NEXT:     Section: N_DEBUG
+# SYMBOL64-NEXT:     Type: 0x0
+# SYMBOL64-NEXT:     StorageClass: C_DWARF (0x70)
+# SYMBOL64-NEXT:     NumberOfAuxEntries: 1
+# SYMBOL64-NEXT:     Sect Auxiliary Entry For DWARF {
+# SYMBOL64-NEXT:       Index: 18
+# SYMBOL64-NEXT:       LengthOfSectionPortion: 0x2
+# SYMBOL64-NEXT:       NumberOfRelocEntries: 3
+# SYMBOL64-NEXT:       Auxiliary Type: AUX_SECT (0xFA)
+# SYMBOL64-NEXT:     }
+# SYMBOL64-NEXT:   }
+# SYMBOL64-NEXT:   Symbol {
+# SYMBOL64-NEXT:     Index: 19
+# SYMBOL64-NEXT:     Name: .fun6
+# SYMBOL64-NEXT:     Value (RelocatableAddress): 0x0
+# SYMBOL64-NEXT:     Section: N_UNDEF
+# SYMBOL64-NEXT:     Type: 0x0
+# SYMBOL64-NEXT:     StorageClass: C_BLOCK (0x64)
+# SYMBOL64-NEXT:     NumberOfAuxEntries: 1
+# SYMBOL64-NEXT:     Block Auxiliary Entry {
+# SYMBOL64-NEXT:       Index: 20
+# SYMBOL64-NEXT:       LineNumber: 0x3
+# SYMBOL64-NEXT:       Auxiliary Type: AUX_SYM (0xFD)
+# SYMBOL64-NEXT:     }
+# SYMBOL64-NEXT:   }
+# SYMBOL64-NEXT:   Symbol {
+# SYMBOL64-NEXT:     Index: 21
+# SYMBOL64-NEXT:     Name: .fun7
+# SYMBOL64-NEXT:     Value (RelocatableAddress): 0x0
+# SYMBOL64-NEXT:     Section: N_UNDEF
+# SYMBOL64-NEXT:     Type: 0x0
+# SYMBOL64-NEXT:     StorageClass: C_FCN (0x65)
+# SYMBOL64-NEXT:     NumberOfAuxEntries: 1
+# SYMBOL64-NEXT:     Block Auxiliary Entry {
+# SYMBOL64-NEXT:       Index: 22
+# SYMBOL64-NEXT:       LineNumber: 0x3
+# SYMBOL64-NEXT:       Auxiliary Type: AUX_SYM (0xFD)
+# SYMBOL64-NEXT:     }
+# SYMBOL64-NEXT:   }
 # SYMBOL64-NEXT: ]

llvm/tools/llvm-readobj/XCOFFDumper.cpp

public:
   void printStackMap() const override;
   void printNeededLibraries() override;
   void printStringTable() override;
 
 private:
   template <typename T> void printSectionHeaders(ArrayRef<T> Sections);
   template <typename T> void printGenericSectionHeader(T &Sec) const;
   template <typename T> void printOverflowSectionHeader(T &Sec) const;
+  template <typename T> const T *getAuxEntPtr(uintptr_t AuxAddress);
   void printFileAuxEnt(const XCOFFFileAuxEnt *AuxEntPtr);
   void printCsectAuxEnt(XCOFFCsectAuxRef AuxEntRef);
   void printSectAuxEntForStat(const XCOFFSectAuxEntForStat *AuxEntPtr);
+  void printExceptionAuxEnt(const XCOFFExceptionAuxEnt *AuxEntPtr);
+  void printFunctionAuxEnt(const XCOFFFunctionAuxEnt32 *AuxEntPtr);
+  void printFunctionAuxEnt(const XCOFFFunctionAuxEnt64 *AuxEntPtr);
+  void printBlockAuxEnt(const XCOFFBlockAuxEnt32 *AuxEntPtr);
+  void printBlockAuxEnt(const XCOFFBlockAuxEnt64 *AuxEntPtr);
+  template <typename T> void printSectAuxEntForDWARF(const T *AuxEntPtr);
   void printSymbol(const SymbolRef &);
   template <typename Shdr, typename RelTy>
   void printRelocations(ArrayRef<Shdr> Sections);
   void printAuxiliaryHeader(const XCOFFAuxiliaryHeader32 *AuxHeader);
   void printAuxiliaryHeader(const XCOFFAuxiliaryHeader64 *AuxHeader);
   const XCOFFObjectFile &Obj;
 };
 } // anonymous namespace
 
+template <typename T, typename TEnum>
+static std::string enum2String(T Value,
+                               ArrayRef<EnumEntry<TEnum>> EnumValues) {
+  for (const EnumEntry<TEnum> &EnumItem : EnumValues)
+    if (EnumItem.Value == Value)
+      return std::string(EnumItem.AltName);
+  return to_hexString(Value, false);
+}
+
 void XCOFFDumper::printFileHeaders() {
   DictScope DS(W, "FileHeader");
   W.printHex("Magic", Obj.getMagic());
   W.printNumber("NumberOfSections", Obj.getNumberOfSections());
 
   // Negative timestamp values are reserved for future use.
   int32_t TimeStamp = Obj.getTimeStamp();
   if (TimeStamp > 0) {
void XCOFFDumper::printSectAuxEntForStat(
   W.printNumber("SectionLength", AuxEntPtr->SectionLength);
 
   // Unlike the corresponding fields in the section header, NumberOfRelocEnt
   // and NumberOfLineNum do not handle values greater than 65535.
   W.printNumber("NumberOfRelocEnt", AuxEntPtr->NumberOfRelocEnt);
   W.printNumber("NumberOfLineNum", AuxEntPtr->NumberOfLineNum);
 }
 
+void XCOFFDumper::printExceptionAuxEnt(const XCOFFExceptionAuxEnt *AuxEntPtr) {
+  assert(Obj.is64Bit() && "64-bit interface called on 32-bit object file.");
+
+  DictScope SymDs(W, "Exception Auxiliary Entry");
+  W.printNumber("Index",
+                Obj.getSymbolIndex(reinterpret_cast<uintptr_t>(AuxEntPtr)));
+  W.printHex("OffsetToExceptionTable", AuxEntPtr->OffsetToExceptionTbl);
+  W.printHex("SizeOfFunction", AuxEntPtr->SizeOfFunction);
+  W.printNumber("SymbolIndexOfNextBeyond", AuxEntPtr->SymIdxOfNextBeyond);
+  W.printEnum("Auxiliary Type", static_cast<uint8_t>(AuxEntPtr->AuxType),
+              makeArrayRef(SymAuxType));
+}
+
+void XCOFFDumper::printFunctionAuxEnt(const XCOFFFunctionAuxEnt32 *AuxEntPtr) {
+  assert(!Obj.is64Bit() && "32-bit interface called on 64-bit object file.");
+
+  DictScope SymDs(W, "Function Auxiliary Entry");
+  W.printNumber("Index",
+                Obj.getSymbolIndex(reinterpret_cast<uintptr_t>(AuxEntPtr)));
+  W.printHex("OffsetToExceptionTable", AuxEntPtr->OffsetToExceptionTbl);
+  W.printHex("SizeOfFunction", AuxEntPtr->SizeOfFunction);
+  W.printHex("PointerToLineNum", AuxEntPtr->PtrToLineNum);
+  W.printNumber("SymbolIndexOfNextBeyond", AuxEntPtr->SymIdxOfNextBeyond);
+}
+
+void XCOFFDumper::printFunctionAuxEnt(const XCOFFFunctionAuxEnt64 *AuxEntPtr) {
+  assert(Obj.is64Bit() && "64-bit interface called on 32-bit object file.");
+
+  DictScope SymDs(W, "Function Auxiliary Entry");
+  W.printNumber("Index",
+                Obj.getSymbolIndex(reinterpret_cast<uintptr_t>(AuxEntPtr)));
+  W.printHex("SizeOfFunction", AuxEntPtr->SizeOfFunction);
+  W.printHex("PointerToLineNum", AuxEntPtr->PtrToLineNum);
+  W.printNumber("SymbolIndexOfNextBeyond", AuxEntPtr->SymIdxOfNextBeyond);
+  W.printEnum("Auxiliary Type", static_cast<uint8_t>(AuxEntPtr->AuxType),
+              makeArrayRef(SymAuxType));
+}
+
+void XCOFFDumper::printBlockAuxEnt(const XCOFFBlockAuxEnt32 *AuxEntPtr) {
+  assert(!Obj.is64Bit() && "32-bit interface called on 64-bit object file.");
+
+  DictScope SymDs(W, "Block Auxiliary Entry");
+  W.printNumber("Index",
+                Obj.getSymbolIndex(reinterpret_cast<uintptr_t>(AuxEntPtr)));
+  W.printHex("LineNumber (High 2 Bytes)", AuxEntPtr->LineNumHi);
+  W.printHex("LineNumber (Low 2 Bytes)", AuxEntPtr->LineNumLo);
+}
+
+void XCOFFDumper::printBlockAuxEnt(const XCOFFBlockAuxEnt64 *AuxEntPtr) {
+  assert(Obj.is64Bit() && "64-bit interface called on 32-bit object file.");
+
+  DictScope SymDs(W, "Block Auxiliary Entry");
+  W.printNumber("Index",
+                Obj.getSymbolIndex(reinterpret_cast<uintptr_t>(AuxEntPtr)));
+  W.printHex("LineNumber", AuxEntPtr->LineNum);
+  W.printEnum("Auxiliary Type", static_cast<uint8_t>(AuxEntPtr->AuxType),
+              makeArrayRef(SymAuxType));
+}
+
+template <typename T>
+void XCOFFDumper::printSectAuxEntForDWARF(const T *AuxEntPtr) {
+  DictScope SymDs(W, "Sect Auxiliary Entry For DWARF");
+  W.printNumber("Index",
+                Obj.getSymbolIndex(reinterpret_cast<uintptr_t>(AuxEntPtr)));
+  W.printHex("LengthOfSectionPortion", AuxEntPtr->LengthOfSectionPortion);
+  W.printNumber("NumberOfRelocEntries", AuxEntPtr->NumberOfRelocEnt);
+  if (Obj.is64Bit())
+    W.printEnum("Auxiliary Type", static_cast<uint8_t>(XCOFF::AUX_SECT),
+                makeArrayRef(SymAuxType));
+}
+
 const EnumEntry<XCOFF::StorageClass> SymStorageClass[] = {
 #define ECase(X)                                                               \
   { #X, XCOFF::X }
     ECase(C_NULL),  ECase(C_AUTO),    ECase(C_EXT),     ECase(C_STAT),
     ECase(C_REG),   ECase(C_EXTDEF),  ECase(C_LABEL),   ECase(C_ULABEL),
     ECase(C_MOS),   ECase(C_ARG),     ECase(C_STRTAG),  ECase(C_MOU),
     ECase(C_UNTAG), ECase(C_TPDEF),   ECase(C_USTATIC), ECase(C_ENTAG),
     ECase(C_MOE),   ECase(C_REGPARM), ECase(C_FIELD),   ECase(C_BLOCK),

 };
 
 static StringRef GetSymbolValueName(XCOFF::StorageClass SC) {
   switch (SC) {
   case XCOFF::C_EXT:
   case XCOFF::C_WEAKEXT:
   case XCOFF::C_HIDEXT:
   case XCOFF::C_STAT:
+  case XCOFF::C_FCN:
+  case XCOFF::C_BLOCK:
     return "Value (RelocatableAddress)";
   case XCOFF::C_FILE:
     return "Value (SymbolTableIndex)";
-  case XCOFF::C_FCN:
-  case XCOFF::C_BLOCK:
+  case XCOFF::C_DWARF:
+    return "Value (OffsetInDWARF)";
   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:
     assert(false && "This StorageClass for the symbol is not yet implemented.");
     return "";
   default:
     return "Value";
   }
 }
 
 const EnumEntry<XCOFF::CFileLangId> CFileLangIdClass[] = {
 #define ECase(X)                                                               \
   { #X, XCOFF::X }
     ECase(TB_C), ECase(TB_CPLUSPLUS)
 #undef ECase
 };
 
 const EnumEntry<XCOFF::CFileCpuId> CFileCpuIdClass[] = {
 #define ECase(X)                                                               \
   { #X, XCOFF::X }
     ECase(TCPU_PPC64), ECase(TCPU_COM), ECase(TCPU_970)
 #undef ECase
 };
 
+template <typename T> const T *XCOFFDumper::getAuxEntPtr(uintptr_t AuxAddress) {
+  const T *AuxEntPtr = reinterpret_cast<const T *>(AuxAddress);
+  Obj.checkSymbolEntryPointer(reinterpret_cast<uintptr_t>(AuxEntPtr));
+  return AuxEntPtr;
+}
+
+static void printUnexpectedRawAuxEnt(ScopedPrinter &W, uintptr_t AuxAddress) {
+  W.startLine() << "!Unexpected raw auxiliary entry data:\n";
+  W.startLine() << format_bytes(
+                       ArrayRef<uint8_t>(
+                           reinterpret_cast<const uint8_t *>(AuxAddress),
+                           XCOFF::SymbolTableEntrySize),
+                       None, XCOFF::SymbolTableEntrySize)
+                << "\n";
+}
+
 void XCOFFDumper::printSymbol(const SymbolRef &S) {
   DataRefImpl SymbolDRI = S.getRawDataRefImpl();
   XCOFFSymbolRef SymbolEntRef = Obj.toSymbolRef(SymbolDRI);
 
   uint8_t NumberOfAuxEntries = SymbolEntRef.getNumberOfAuxEntries();
 
   DictScope SymDs(W, "Symbol");
 
   StringRef SymbolName =
       unwrapOrError(Obj.getFileName(), SymbolEntRef.getName());
 
-  W.printNumber("Index", Obj.getSymbolIndex(SymbolEntRef.getEntryAddress()));
+  uint32_t SymbolIdx = Obj.getSymbolIndex(SymbolEntRef.getEntryAddress());
+  XCOFF::StorageClass SymbolClass = SymbolEntRef.getStorageClass();
+
+  W.printNumber("Index", SymbolIdx);
   W.printString("Name", SymbolName);
-  W.printHex(GetSymbolValueName(SymbolEntRef.getStorageClass()),
-             SymbolEntRef.getValue());
+  W.printHex(GetSymbolValueName(SymbolClass), SymbolEntRef.getValue());
 
   StringRef SectionName =
       unwrapOrError(Obj.getFileName(), Obj.getSymbolSectionName(SymbolEntRef));
 
   W.printString("Section", SectionName);
-  if (SymbolEntRef.getStorageClass() == XCOFF::C_FILE) {
+  if (SymbolClass == XCOFF::C_FILE) {
     W.printEnum("Source Language ID", SymbolEntRef.getLanguageIdForCFile(),
                 makeArrayRef(CFileLangIdClass));
     W.printEnum("CPU Version ID", SymbolEntRef.getCPUTypeIddForCFile(),
                 makeArrayRef(CFileCpuIdClass));
   } else
     W.printHex("Type", SymbolEntRef.getSymbolType());
 
-  W.printEnum("StorageClass",
-              static_cast<uint8_t>(SymbolEntRef.getStorageClass()),
+  W.printEnum("StorageClass", static_cast<uint8_t>(SymbolClass),
               makeArrayRef(SymStorageClass));
   W.printNumber("NumberOfAuxEntries", NumberOfAuxEntries);
 
   if (NumberOfAuxEntries == 0)
     return;
 
-  switch (SymbolEntRef.getStorageClass()) {
+  switch (SymbolClass) {
   case XCOFF::C_FILE:
     // If the symbol is C_FILE and has auxiliary entries...
     for (int I = 1; I <= NumberOfAuxEntries; I++) {
       uintptr_t AuxAddress = XCOFFObjectFile::getAdvancedSymbolEntryAddress(
           SymbolEntRef.getEntryAddress(), I);
 
       if (Obj.is64Bit() &&
           *Obj.getSymbolAuxType(AuxAddress) != XCOFF::SymbolAuxType::AUX_FILE) {
-        W.startLine() << "!Unexpected raw auxiliary entry data:\n";
-        W.startLine() << format_bytes(
-                             ArrayRef<uint8_t>(
-                                 reinterpret_cast<const uint8_t *>(AuxAddress),
-                                 XCOFF::SymbolTableEntrySize),
-                             0, XCOFF::SymbolTableEntrySize)
-                      << "\n";
+        printUnexpectedRawAuxEnt(W, AuxAddress);
         continue;
       }
 
       const XCOFFFileAuxEnt *FileAuxEntPtr =
-          reinterpret_cast<const XCOFFFileAuxEnt *>(AuxAddress);
-#ifndef NDEBUG
-      Obj.checkSymbolEntryPointer(reinterpret_cast<uintptr_t>(FileAuxEntPtr));
-#endif
+          getAuxEntPtr<XCOFFFileAuxEnt>(AuxAddress);
       printFileAuxEnt(FileAuxEntPtr);
     }
     break;
   case XCOFF::C_EXT:
   case XCOFF::C_WEAKEXT:
   case XCOFF::C_HIDEXT: {
-    // If the symbol is for a function, and it has more than 1 auxiliary entry,
-    // then one of them must be function auxiliary entry which we do not
-    // support yet.
-    if (SymbolEntRef.isFunction() && NumberOfAuxEntries >= 2)
-      report_fatal_error("Function auxiliary entry printing is unimplemented.");
-
-    // If there is more than 1 auxiliary entry, instead of printing out
-    // error information, print out the raw Auxiliary entry.
-    // For 32-bit object, print from first to the last - 1. The last one must be
-    // a CSECT Auxiliary Entry.
-    // For 64-bit object, print from first to last and skips if SymbolAuxType is
-    // AUX_CSECT.
+    if (!SymbolEntRef.isFunction() && NumberOfAuxEntries > 1)
+      reportUniqueWarning("the non-function " +
+                          enum2String(static_cast<uint8_t>(SymbolClass),
+                                      makeArrayRef(SymStorageClass)) +
+                          " symbol at index " + Twine(SymbolIdx) +
+                          " should have only 1 auxiliary entry, i.e. the CSECT "
+                          "auxiliary entry");
+
+    // For 32-bit objects, print the function auxiliary symbol table entry. The
+    // last one must be a CSECT auxiliary entry.
+    // For 64-bit objects, both a function auxiliary entry and an exception
+    // auxiliary entry may appear, print them in the loop and skip printing the
+    // CSECT auxiliary entry, which will be printed outside the loop.
     for (int I = 1; I <= NumberOfAuxEntries; I++) {
-      if (I == NumberOfAuxEntries && !Obj.is64Bit())
+      if ((I == NumberOfAuxEntries && !Obj.is64Bit()) ||
+          !SymbolEntRef.isFunction())
         break;
 
       uintptr_t AuxAddress = XCOFFObjectFile::getAdvancedSymbolEntryAddress(
           SymbolEntRef.getEntryAddress(), I);
-      if (Obj.is64Bit() &&
-          *Obj.getSymbolAuxType(AuxAddress) == XCOFF::SymbolAuxType::AUX_CSECT)
-        continue;
 
-      W.startLine() << "!Unexpected raw auxiliary entry data:\n";
-      W.startLine() << format_bytes(
-          ArrayRef<uint8_t>(reinterpret_cast<const uint8_t *>(AuxAddress),
-                            XCOFF::SymbolTableEntrySize));
+      if (Obj.is64Bit()) {
+        XCOFF::SymbolAuxType Type = *Obj.getSymbolAuxType(AuxAddress);
+        if (Type == XCOFF::SymbolAuxType::AUX_CSECT)
+          continue;
+        else if (Type == XCOFF::SymbolAuxType::AUX_FCN) {
+          const XCOFFFunctionAuxEnt64 *AuxEntPtr =
+              getAuxEntPtr<XCOFFFunctionAuxEnt64>(AuxAddress);
+          printFunctionAuxEnt(AuxEntPtr);
+        } else if (Type == XCOFF::SymbolAuxType::AUX_EXCEPT) {
+          const XCOFFExceptionAuxEnt *AuxEntPtr =
+              getAuxEntPtr<XCOFFExceptionAuxEnt>(AuxAddress);
+          printExceptionAuxEnt(AuxEntPtr);
+        } else {
+          printUnexpectedRawAuxEnt(W, AuxAddress);
+        }
+      } else {
+        const XCOFFFunctionAuxEnt32 *AuxEntPtr =
+            getAuxEntPtr<XCOFFFunctionAuxEnt32>(AuxAddress);
+        printFunctionAuxEnt(AuxEntPtr);
+      }
     }
 
+    // Print the CSECT auxiliary entry.
     auto ErrOrCsectAuxRef = SymbolEntRef.getXCOFFCsectAuxRef();
     if (!ErrOrCsectAuxRef)
       reportUniqueWarning(ErrOrCsectAuxRef.takeError());
     else
       printCsectAuxEnt(*ErrOrCsectAuxRef);
 
     break;
   }
-  case XCOFF::C_STAT:
+  case XCOFF::C_STAT: {
     if (NumberOfAuxEntries > 1)
-      report_fatal_error(
-          "C_STAT symbol should not have more than 1 auxiliary entry.");
+      reportUniqueWarning("the C_STAT symbol at index " + Twine(SymbolIdx) +
+                          " should not have more than 1 auxiliary entry");
 
-    const XCOFFSectAuxEntForStat *StatAuxEntPtr;
-    StatAuxEntPtr = reinterpret_cast<const XCOFFSectAuxEntForStat *>(
+    const XCOFFSectAuxEntForStat *StatAuxEntPtr =
+        getAuxEntPtr<XCOFFSectAuxEntForStat>(
             XCOFFObjectFile::getAdvancedSymbolEntryAddress(
                 SymbolEntRef.getEntryAddress(), 1));
-#ifndef NDEBUG
-    Obj.checkSymbolEntryPointer(reinterpret_cast<uintptr_t>(StatAuxEntPtr));
-#endif
     printSectAuxEntForStat(StatAuxEntPtr);
     break;
-  case XCOFF::C_DWARF:
+  }
+  case XCOFF::C_DWARF: {
+    if (NumberOfAuxEntries > 1)
+      reportUniqueWarning("the C_DWARF symbol at index " + Twine(SymbolIdx) +
+                          " should not have more than 1 auxiliary entry");
+
+    uintptr_t AuxAddress = XCOFFObjectFile::getAdvancedSymbolEntryAddress(
+        SymbolEntRef.getEntryAddress(), 1);
+
+    if (Obj.is64Bit()) {
+      const XCOFFSectAuxEntForDWARF64 *AuxEntPtr =
+          getAuxEntPtr<XCOFFSectAuxEntForDWARF64>(AuxAddress);
+      printSectAuxEntForDWARF<XCOFFSectAuxEntForDWARF64>(AuxEntPtr);
+    } else {
+      const XCOFFSectAuxEntForDWARF32 *AuxEntPtr =
+          getAuxEntPtr<XCOFFSectAuxEntForDWARF32>(AuxAddress);
+      printSectAuxEntForDWARF<XCOFFSectAuxEntForDWARF32>(AuxEntPtr);
+    }
+    break;
+  }
   case XCOFF::C_BLOCK:
-  case XCOFF::C_FCN:
-    report_fatal_error("Symbol table entry printing for this storage class "
-                       "type is unimplemented.");
+  case XCOFF::C_FCN: {
+    if (NumberOfAuxEntries > 1)
+      reportUniqueWarning("the " +
+                          enum2String(static_cast<uint8_t>(SymbolClass),
+                                      makeArrayRef(SymStorageClass)) +
+                          " symbol at index " + Twine(SymbolIdx) +
+                          " should not have more than 1 "
+                          "auxiliary entry");
+
+    uintptr_t AuxAddress = XCOFFObjectFile::getAdvancedSymbolEntryAddress(
+        SymbolEntRef.getEntryAddress(), 1);
+
+    if (Obj.is64Bit()) {
+      const XCOFFBlockAuxEnt64 *AuxEntPtr =
+          getAuxEntPtr<XCOFFBlockAuxEnt64>(AuxAddress);
+      printBlockAuxEnt(AuxEntPtr);
+    } else {
+      const XCOFFBlockAuxEnt32 *AuxEntPtr =
+          getAuxEntPtr<XCOFFBlockAuxEnt32>(AuxAddress);
+      printBlockAuxEnt(AuxEntPtr);
+    }
     break;
+  }
   default:
     for (int i = 1; i <= NumberOfAuxEntries; i++) {
-      W.startLine() << "!Unexpected raw auxiliary entry data:\n";
-      W.startLine() << format_bytes(
-          ArrayRef<uint8_t>(reinterpret_cast<const uint8_t *>(
-                                XCOFFObjectFile::getAdvancedSymbolEntryAddress(
-                                    SymbolEntRef.getEntryAddress(), i)),
-                            XCOFF::SymbolTableEntrySize));
+      printUnexpectedRawAuxEnt(W,
+                                   SymbolEntRef.getEntryAddress(), i));
     }
     break;
   }
 }
 
 void XCOFFDumper::printSymbols() {
   ListScope Group(W, "Symbols");
   for (const SymbolRef &S : Obj.symbols())