[obj2yaml][XCOFF] Dump sections

[Esme]

Summary

This patch implements parsing sections for obj2yaml on AIX.

[Esme]

Gently ping.

[qiucf]

llvm/include/llvm/ObjectYAML/XCOFFYAML.h

59

Better to add brief comment like length or symbol table index, depending on symbol type.? Like D68650.

llvm/test/tools/obj2yaml/XCOFF/aix.yaml

13–76

As I see this test is not auto-generated? So can we reduce the indents to make the diff minimal?

llvm/tools/obj2yaml/xcoff2yaml.cpp

34

Why not change return type to Error?

149

Put break inside brace.

[jhenderson]

You'll need someone with XCOFF experience to review this too. Generally looks fine from my brief look though.

llvm/test/tools/obj2yaml/XCOFF/aix.yaml

1

It would be nice if we could replace the canned binary input with a YAML input and then use yaml2obj to produce the YAML for consumption by obj2yaml at some point in the future. That'll allow us proper flexibility to test all code paths.

13

Nit: add extra spaces to make things line up nicely.

Should this be a CHECK-NEXT though? If so, delete the blank line above it.

llvm/tools/obj2yaml/xcoff2yaml.cpp

40–42

60

Perhaps report this as a regular error using createStringError()? No need for report_fatal_error when we have an easy way to report the Error after all.

61–62

No need for the else here.

81

This and the similar relocation check below - do you actually need it? If a user had an invalid object, where the section type was different to what it should be (e.g. a bug in an object producer), this check would prevent using obj2yaml, yet in my mind, the YAML could easily represent this state.

[Esme]

1. Address comment.
2. Rebase on D85774 and D95505.

llvm/test/tools/obj2yaml/XCOFF/aix.yaml

1

Yes, I agree with that. However, the yaml2obj is not yet fully implemented and some fields this test need like the symbol auxiliary entries are not yet supported in yaml2obj. I will replace the canned binary input with a YAML input in the future.

[jhenderson]

llvm/test/tools/obj2yaml/XCOFF/aix.yaml

1

Is there a particular need for obj2yaml support ahead of yaml2obj support for these things? I'm just wondering whether it would be better to wait.

[Esme]

llvm/test/tools/obj2yaml/XCOFF/aix.yaml

1

There is no particular reason for obj2yaml support to be ahead of yaml2obj, except that if I can use obj2yaml to convert compiled object files to readable yaml files, it will help me to implement yaml2obj.

[jhenderson]

llvm/test/tools/obj2yaml/XCOFF/aix.yaml

1

The problem is that there's currently quite a lot of noise (e.g. the excessive section content) in this test that isn't all that useful. There are also a number of cases that aren't properly covered by this test input (e.g. sections with no relocations, empty sections etc), and you may find it difficult to cover all of them using a canned binary. Better to wait until you've got sufficient yaml2obj support for the basic structure, and then develop the two in tandem (i.e. add a feature to yaml2obj and at the same time, mirror it in obj2yaml).

There's of course nothing stopping you having this patch applied locally to help you in your yaml2obj development.

llvm/tools/obj2yaml/xcoff2yaml.cpp

85

Here and throughout, you need testing for your error cases, i.e. what obj2yaml does when this error is triggered.

138

Do you have testing for the case where this is false?

143–145

I'm not convinced this belongs at all. Why do you do this check only for debug builds?

157

Here and elsewhere - this is the more normal TODO syntax in LLVM.

[Esme]

1. Only dump sections.
2. Replace the binary input with the yaml input.

[jhenderson]

You still need testing for your error cases, i.e. showing that obj2yaml produces a suitable error (or possibly follows some fallback path) when it encounters invalid content.

llvm/test/tools/obj2yaml/XCOFF/aix.yaml

218–227

Here and below, we usually remove excessive spacing, so that the values neatly line up, as close as possible to the tags. See the suggested edit for an example of what I mean.

llvm/tools/obj2yaml/xcoff2yaml.cpp

60

Probably, this should just be errc::not_implemented (or something along those lines) - the file type is valid, we just haven't added support yet.

Is there much difference between 64 and 32-bit sections though, or could you just remove this error entirely and do the right thing?

[Esme]

Address comment.

1. Add 64-bit support and test.
2. Test error paths.

[jhenderson]

llvm/test/tools/obj2yaml/XCOFF/aix.yaml

343–348

Strictly, this should be like the inline edit (and same immediately below), but I'm not too fussed by that.

llvm/test/tools/obj2yaml/XCOFF/invalid.yaml

1 ↗

(On Diff #371779)

You should consider splitting this test into separate files, e.g. invalid-section and invalid-symbol, as I suspect it will grow as obj2yaml support for XCOFF improves.

13–20 ↗

(On Diff #371779)

28 ↗

(On Diff #371779)

Not for this patch, but it would be nice if we could get the actual useful error message, rather than the error code converted to an error message. That would ensure the message actually provides useful context (here the question could be raised "which section index? Where was it and what was its value?"

llvm/tools/obj2yaml/xcoff2yaml.cpp

95–96

This error path appears to be untested?

[Esme]

Address comment

[jhenderson]

LGTM!

llvm/include/llvm/ObjectYAML/XCOFFYAML.h

struct Section {
   llvm::yaml::Hex64 FileOffsetToLineNumbers; // Line number pointer. Not supported yet.
   llvm::yaml::Hex16 NumberOfRelocations;
   llvm::yaml::Hex16 NumberOfLineNumbers; // Line number counts. Not supported yet.
   uint32_t Flags;
   yaml::BinaryRef SectionData;
   std::vector<Relocation> Relocations;
 };
 
+struct FileAuxEnt {
+  StringRef FileName;
+  XCOFF::CFileStringType Type;
+};
+
+struct CsectAuxEnt32 {
+  uint32_t SectionOrLength; // If the symbol type is XTY_SD or XTY_CM, the csect
+                            // length.
+                            // If the symbol type is XTY_LD, the symbol table
+                            // index of the containing csect.
+                            // If the symbol type is XTY_ER, 0.
+  uint32_t ParameterHashIndex;
+  uint16_t TypeChkSecNum;
+  uint8_t SymbolAlignmentAndType;
+  XCOFF::StorageMappingClass StorageMappingClass;
+  uint32_t StabInfoIndex;
+  uint16_t StabSecNum;
+};
+
+struct CsectAuxEnt64 {
+  uint32_t SectionOrLength_Lo;
+  uint32_t SectionOrLength_Hi;
+  uint32_t ParameterHashIndex;
+  uint16_t TypeChkSecNum;
+  uint8_t SymbolAlignmentAndType;
+  XCOFF::StorageMappingClass StorageMappingClass;
+  uint8_t Pad;
+  uint8_t CsectAux;
+};
+
 struct Symbol {
   StringRef SymbolName;
   llvm::yaml::Hex64 Value; // Symbol value; storage class-dependent.
   StringRef SectionName;
   llvm::yaml::Hex16 Type;
   XCOFF::StorageClass StorageClass;
   uint8_t NumberOfAuxEntries;
+  FileAuxEnt FileAuxEntry;
+  CsectAuxEnt32 CsectAuxEntry;
 };
 
 struct Object {
   FileHeader Header;
   std::vector<Section> Sections;
   std::vector<Symbol> Symbols;
   Object();
 };

 template <> struct ScalarBitSetTraits<XCOFF::SectionTypeFlags> {
   static void bitset(IO &IO, XCOFF::SectionTypeFlags &Value);
 };
 
 template <> struct ScalarEnumerationTraits<XCOFF::StorageClass> {
   static void enumeration(IO &IO, XCOFF::StorageClass &Value);
 };
 
+template <> struct ScalarEnumerationTraits<XCOFF::StorageMappingClass> {
+  static void enumeration(IO &IO, XCOFF::StorageMappingClass &Value);
+};
+
+template <> struct ScalarEnumerationTraits<XCOFF::CFileStringType> {
+  static void enumeration(IO &IO, XCOFF::CFileStringType &Value);
+};
+
 template <> struct MappingTraits<XCOFFYAML::FileHeader> {
   static void mapping(IO &IO, XCOFFYAML::FileHeader &H);
 };
 
+template <> struct MappingTraits<XCOFFYAML::FileAuxEnt> {
+  static void mapping(IO &IO, XCOFFYAML::FileAuxEnt &FAE);
+};
+
+template <> struct MappingTraits<XCOFFYAML::CsectAuxEnt32> {
+  static void mapping(IO &IO, XCOFFYAML::CsectAuxEnt32 &CAE32);
+};
 
 template <> struct MappingTraits<XCOFFYAML::Symbol> {
   static void mapping(IO &IO, XCOFFYAML::Symbol &S);
 };
 
 template <> struct MappingTraits<XCOFFYAML::Relocation> {
   static void mapping(IO &IO, XCOFFYAML::Relocation &R);
 };

llvm/lib/ObjectYAML/XCOFFYAML.cpp

#define ECase(X) IO.enumCase(Value, #X, XCOFF::X)
   ECase(C_BSTAT);
   ECase(C_ESTAT);
   ECase(C_GTLS);
   ECase(C_STTLS);
   ECase(C_EFCN);
 #undef ECase
 }
 
+void ScalarEnumerationTraits<XCOFF::StorageMappingClass>::enumeration(
+    IO &IO, XCOFF::StorageMappingClass &Value) {
+#define ECase(X) IO.enumCase(Value, #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_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_UL);
+  ECase(XMC_TE);
+#undef ECase
+}
+
+void ScalarEnumerationTraits<XCOFF::CFileStringType>::enumeration(
+    IO &IO, XCOFF::CFileStringType &Value) {
+#define ECase(X) IO.enumCase(Value, #X, XCOFF::X)
+  ECase(XFT_FN);
+  ECase(XFT_CT);
+  ECase(XFT_CV);
+  ECase(XFT_CD);
+#undef ECase
+}
+
 struct NSectionFlags {
   NSectionFlags(IO &) : Flags(XCOFF::SectionTypeFlags(0)) {}
   NSectionFlags(IO &, uint32_t C) : Flags(XCOFF::SectionTypeFlags(C)) {}
 
   uint32_t denormalize(IO &) { return Flags; }
 
   XCOFF::SectionTypeFlags Flags;
 };
void MappingTraits<XCOFFYAML::Section>::mapping(IO &IO,
   IO.mapOptional("FileOffsetToLineNumbers", Sec.FileOffsetToLineNumbers);
   IO.mapOptional("NumberOfRelocations", Sec.NumberOfRelocations);
   IO.mapOptional("NumberOfLineNumbers", Sec.NumberOfLineNumbers);
   IO.mapRequired("Flags", NC->Flags);
   IO.mapOptional("SectionData", Sec.SectionData);
   IO.mapOptional("Relocations", Sec.Relocations);
 }
 
+void MappingTraits<XCOFFYAML::FileAuxEnt>::mapping(IO &IO,
+                                                   XCOFFYAML::FileAuxEnt &FAE) {
+  IO.mapOptional("FileName", FAE.FileName);
+  IO.mapOptional("Type", FAE.Type);
+}
+
+void MappingTraits<XCOFFYAML::CsectAuxEnt32>::mapping(
+    IO &IO, XCOFFYAML::CsectAuxEnt32 &CAE32) {
+  IO.mapOptional("SectionLen", CAE32.SectionOrLength);
+  IO.mapOptional("ParameterHashIndex", CAE32.ParameterHashIndex);
+  IO.mapOptional("TypeChkSectNum", CAE32.TypeChkSecNum);
+  IO.mapOptional("SymbolAlignmentAndType", CAE32.SymbolAlignmentAndType);
+  IO.mapOptional("StorageMappingClass", CAE32.StorageMappingClass);
+  IO.mapOptional("StabInfoIndex", CAE32.StabInfoIndex);
+  IO.mapOptional("StabSectNum", CAE32.StabSecNum);
+}
+
 void MappingTraits<XCOFFYAML::Symbol>::mapping(IO &IO, XCOFFYAML::Symbol &S) {
   IO.mapRequired("Name", S.SymbolName);
   IO.mapOptional("Value", S.Value);
   IO.mapRequired("Section", S.SectionName);
   IO.mapOptional("Type", S.Type);
   IO.mapOptional("StorageClass", S.StorageClass);
   IO.mapOptional("NumberOfAuxEntries", S.NumberOfAuxEntries);
+  if (S.StorageClass == XCOFF::C_EXT || S.StorageClass == XCOFF::C_WEAKEXT ||
+      S.StorageClass == XCOFF::C_HIDEXT)
+    IO.mapOptional("CsectAuxEntry", S.CsectAuxEntry);
+  if (S.StorageClass == XCOFF::C_FILE)
+    IO.mapOptional("FileAuxEntry", S.FileAuxEntry);
 }
 
 void MappingTraits<XCOFFYAML::Object>::mapping(IO &IO, XCOFFYAML::Object &Obj) {
   IO.mapTag("!XCOFF", true);
   IO.mapRequired("FileHeader", Obj.Header);
   IO.mapOptional("Sections", Obj.Sections);
   IO.mapOptional("Symbols", Obj.Symbols);
 }
 
 } // namespace yaml
 } // namespace llvm

llvm/test/tools/obj2yaml/XCOFF/aix.yaml

 # RUN: obj2yaml %S/Inputs/aix_xcoff.o | FileCheck %s
 # Test that we can parse the XCOFF object file correctly.
-# CHECK: --- !XCOFF
+
+# CHECK:      --- !XCOFF
 # CHECK-NEXT: FileHeader:
 # CHECK-NEXT:   MagicNumber:     0x1DF
 # CHECK-NEXT:   NumberOfSections: 2
 # CHECK-NEXT:   CreationTime:    1552337792
 # CHECK-NEXT:   OffsetToSymbolTable: 0x13A
 # CHECK-NEXT:   EntriesInSymbolTable: 22
 # CHECK-NEXT:   AuxiliaryHeaderSize: 0
 # CHECK-NEXT:   Flags:           0x0
-
-# CHECK: Symbols:
-# CHECK-NEXT:   - Name:      .file
-# CHECK-NEXT:     Value:     0x0
-# CHECK-NEXT:     Section: N_DEBUG
-# CHECK-NEXT:     Type:      0x3
+# CHECK-NEXT: Sections:
+# CHECK-NEXT:   - Name:            .text
+# CHECK-NEXT:     Address:         0x0
+# CHECK-NEXT:     Size:            0x60
+# CHECK-NEXT:     FileOffsetToData: 0x64
+# CHECK-NEXT:     FileOffsetToRelocations: 0xE0
+# CHECK-NEXT:     FileOffsetToLineNumbers: 0x0
+# CHECK-NEXT:     NumberOfRelocations: 0x4
+# CHECK-NEXT:     NumberOfLineNumbers: 0x0
+# CHECK-NEXT:     Flags:           [ STYP_TEXT ]
+# CHECK-NEXT:     SectionData:     93E1FFFC9421FFE07C3F0B78812200008129000039490001812200009149000081220004812900003949FFFF8122000491490000392000007D234B78383F002083E1FFFC4E8000200000000000092060800100010000004800046D61696E1F00
+# CHECK-NEXT:     Relocations:
+# CHECK-NEXT:       - Address:         0xE
+# CHECK-NEXT:         Symbol:          0x12
+# CHECK-NEXT:         Info:            0xF
+# CHECK-NEXT:         Type:            0x3
+# CHECK-NEXT:       - Address:         0x1A
+# CHECK-NEXT:         Symbol:          0x12
+# CHECK-NEXT:         Info:            0xF
+# CHECK-NEXT:         Type:            0x3
+# CHECK-NEXT:       - Address:         0x22
+# CHECK-NEXT:         Symbol:          0x14
+# CHECK-NEXT:         Info:            0xF
+# CHECK-NEXT:         Type:            0x3
+# CHECK-NEXT:       - Address:         0x2E
+# CHECK-NEXT:         Symbol:          0x14
+# CHECK-NEXT:         Info:            0xF
+# CHECK-NEXT:         Type:            0x3
+# CHECK-NEXT:   - Name:            .data
+# CHECK-NEXT:     Address:         0x60
+# CHECK-NEXT:     Size:            0x1C
+# CHECK-NEXT:     FileOffsetToData: 0xC4
+# CHECK-NEXT:     FileOffsetToRelocations: 0x108
+# CHECK-NEXT:     FileOffsetToLineNumbers: 0x0
+# CHECK-NEXT:     NumberOfRelocations: 0x5
+# CHECK-NEXT:     NumberOfLineNumbers: 0x0
+# CHECK-NEXT:     Flags:           [ STYP_DATA ]
+# CHECK-NEXT:     SectionData:     '00000000000000740000000000000000000000600000000000000000'
+# CHECK-NEXT:     Relocations:
+# CHECK-NEXT:       - Address:         0x60
+# CHECK-NEXT:         Symbol:          0x8
+# CHECK-NEXT:         Info:            0x1F
+# CHECK-NEXT:         Type:            0x0
+# CHECK-NEXT:       - Address:         0x64
+# CHECK-NEXT:         Symbol:          0x10
+# CHECK-NEXT:         Info:            0x1F
+# CHECK-NEXT:         Type:            0x0
+# CHECK-NEXT:       - Address:         0x70
+# CHECK-NEXT:         Symbol:          0x6
+# CHECK-NEXT:         Info:            0x1F
+# CHECK-NEXT:         Type:            0x0
+# CHECK-NEXT:       - Address:         0x74
+# CHECK-NEXT:         Symbol:          0x2
+# CHECK-NEXT:         Info:            0x1F
+# CHECK-NEXT:         Type:            0x0
+# CHECK-NEXT:       - Address:         0x78
+# CHECK-NEXT:         Symbol:          0x4
+# CHECK-NEXT:         Info:            0x1F
+# CHECK-NEXT:         Type:            0x0
+# CHECK-NEXT: Symbols:
+# CHECK-NEXT:   - Name:            .file
+# CHECK-NEXT:     Value:           0x0
+# CHECK-NEXT:     Section:         N_DEBUG
+# CHECK-NEXT:     Type:            0x3
 # CHECK-NEXT:     StorageClass:    C_FILE
 # CHECK-NEXT:     NumberOfAuxEntries: 1
-# CHECK-NEXT:   - Name:      i
-# CHECK-NEXT:     Value:     0x0
-# CHECK-NEXT:     Section: N_UNDEF
-# CHECK-NEXT:     Type:      0x0
+# CHECK-NEXT:     FileAuxEntry:
+# CHECK-NEXT:       FileName:        test.c
+# CHECK-NEXT:       Type:            XFT_FN
+# CHECK-NEXT:   - Name:            i
+# CHECK-NEXT:     Value:           0x0
+# CHECK-NEXT:     Section:         N_UNDEF
+# CHECK-NEXT:     Type:            0x0
 # CHECK-NEXT:     StorageClass:    C_EXT
 # CHECK-NEXT:     NumberOfAuxEntries: 1
-# CHECK-NEXT:   - Name:      TestforXcoff
-# CHECK-NEXT:     Value:     0x0
-# CHECK-NEXT:     Section: N_UNDEF
-# CHECK-NEXT:     Type:      0x0
+# CHECK-NEXT:     CsectAuxEntry:
+# CHECK-NEXT:       SectionLen:      0
+# CHECK-NEXT:       ParameterHashIndex: 0
+# CHECK-NEXT:       TypeChkSectNum:  0
+# CHECK-NEXT:       SymbolAlignmentAndType: 0
+# CHECK-NEXT:       StorageMappingClass: XMC_UA
+# CHECK-NEXT:       StabInfoIndex:   0
+# CHECK-NEXT:       StabSectNum:     0
+# CHECK-NEXT:   - Name:            TestforXcoff
+# CHECK-NEXT:     Value:           0x0
+# CHECK-NEXT:     Section:         N_UNDEF
+# CHECK-NEXT:     Type:            0x0
 # CHECK-NEXT:     StorageClass:    C_EXT
 # CHECK-NEXT:     NumberOfAuxEntries: 1
-# CHECK-NEXT:   - Name:      .text
-# CHECK-NEXT:     Value:     0x0
-# CHECK-NEXT:     Section: .text
-# CHECK-NEXT:     Type:      0x0
+# CHECK-NEXT:     CsectAuxEntry:
+# CHECK-NEXT:       SectionLen:      0
+# CHECK-NEXT:       ParameterHashIndex: 0
+# CHECK-NEXT:       TypeChkSectNum:  0
+# CHECK-NEXT:       SymbolAlignmentAndType: 0
+# CHECK-NEXT:       StorageMappingClass: XMC_UA
+# CHECK-NEXT:       StabInfoIndex:   0
+# CHECK-NEXT:       StabSectNum:     0
+# CHECK-NEXT:   - Name:            .text
+# CHECK-NEXT:     Value:           0x0
+# CHECK-NEXT:     Section:         .text
+# CHECK-NEXT:     Type:            0x0
 # CHECK-NEXT:     StorageClass:    C_HIDEXT
 # CHECK-NEXT:     NumberOfAuxEntries: 1
-# CHECK-NEXT:   - Name:      .main
-# CHECK-NEXT:     Value:     0x0
-# CHECK-NEXT:     Section: .text
-# CHECK-NEXT:     Type:      0x0
+# CHECK-NEXT:     CsectAuxEntry:
+# CHECK-NEXT:       SectionLen:      96
+# CHECK-NEXT:       ParameterHashIndex: 0
+# CHECK-NEXT:       TypeChkSectNum:  0
+# CHECK-NEXT:       SymbolAlignmentAndType: 1
+# CHECK-NEXT:       StorageMappingClass: XMC_PR
+# CHECK-NEXT:       StabInfoIndex:   0
+# CHECK-NEXT:       StabSectNum:     0
+# CHECK-NEXT:   - Name:            .main
+# CHECK-NEXT:     Value:           0x0
+# CHECK-NEXT:     Section:         .text
+# CHECK-NEXT:     Type:            0x0
 # CHECK-NEXT:     StorageClass:    C_EXT
 # CHECK-NEXT:     NumberOfAuxEntries: 1
-# CHECK-NEXT:   - Name:      main
-# CHECK-NEXT:     Value:     0x60
-# CHECK-NEXT:     Section: .data
-# CHECK-NEXT:     Type:      0x0
+# CHECK-NEXT:     CsectAuxEntry:
+# CHECK-NEXT:       SectionLen:      6
+# CHECK-NEXT:       ParameterHashIndex: 0
+# CHECK-NEXT:       TypeChkSectNum:  0
+# CHECK-NEXT:       SymbolAlignmentAndType: 2
+# CHECK-NEXT:       StorageMappingClass: XMC_PR
+# CHECK-NEXT:       StabInfoIndex:   0
+# CHECK-NEXT:       StabSectNum:     0
+# CHECK-NEXT:   - Name:            main
+# CHECK-NEXT:     Value:           0x60
+# CHECK-NEXT:     Section:         .data
+# CHECK-NEXT:     Type:            0x0
 # CHECK-NEXT:     StorageClass:    C_HIDEXT
 # CHECK-NEXT:     NumberOfAuxEntries: 1
-# CHECK-NEXT:   - Name:      main
-# CHECK-NEXT:     Value:     0x60
-# CHECK-NEXT:     Section: .data
-# CHECK-NEXT:     Type:      0x0
+# CHECK-NEXT:     CsectAuxEntry:
+# CHECK-NEXT:       SectionLen:      12
+# CHECK-NEXT:       ParameterHashIndex: 0
+# CHECK-NEXT:       TypeChkSectNum:  0
+# CHECK-NEXT:       SymbolAlignmentAndType: 1
+# CHECK-NEXT:       StorageMappingClass: XMC_DS
+# CHECK-NEXT:       StabInfoIndex:   0
+# CHECK-NEXT:       StabSectNum:     0
+# CHECK-NEXT:   - Name:            main
+# CHECK-NEXT:     Value:           0x60
+# CHECK-NEXT:     Section:         .data
+# CHECK-NEXT:     Type:            0x0
 # CHECK-NEXT:     StorageClass:    C_EXT
 # CHECK-NEXT:     NumberOfAuxEntries: 1
-# CHECK-NEXT:   - Name:      .data
-# CHECK-NEXT:     Value:     0x70
-# CHECK-NEXT:     Section: .data
-# CHECK-NEXT:     Type:      0x0
+# CHECK-NEXT:     CsectAuxEntry:
+# CHECK-NEXT:       SectionLen:      10
+# CHECK-NEXT:       ParameterHashIndex: 0
+# CHECK-NEXT:       TypeChkSectNum:  0
+# CHECK-NEXT:       SymbolAlignmentAndType: 2
+# CHECK-NEXT:       StorageMappingClass: XMC_DS
+# CHECK-NEXT:       StabInfoIndex:   0
+# CHECK-NEXT:       StabSectNum:     0
+# CHECK-NEXT:   - Name:            .data
+# CHECK-NEXT:     Value:           0x70
+# CHECK-NEXT:     Section:         .data
+# CHECK-NEXT:     Type:            0x0
 # CHECK-NEXT:     StorageClass:    C_HIDEXT
 # CHECK-NEXT:     NumberOfAuxEntries: 1
-# CHECK-NEXT:   - Name:      TOC
-# CHECK-NEXT:     Value:     0x74
-# CHECK-NEXT:     Section: .data
-# CHECK-NEXT:     Type:      0x0
+# CHECK-NEXT:     CsectAuxEntry:
+# CHECK-NEXT:       SectionLen:      4
+# CHECK-NEXT:       ParameterHashIndex: 0
+# CHECK-NEXT:       TypeChkSectNum:  0
+# CHECK-NEXT:       SymbolAlignmentAndType: 1
+# CHECK-NEXT:       StorageMappingClass: XMC_RW
+# CHECK-NEXT:       StabInfoIndex:   0
+# CHECK-NEXT:       StabSectNum:     0
+# CHECK-NEXT:   - Name:            TOC
+# CHECK-NEXT:     Value:           0x74
+# CHECK-NEXT:     Section:         .data
+# CHECK-NEXT:     Type:            0x0
 # CHECK-NEXT:     StorageClass:    C_HIDEXT
 # CHECK-NEXT:     NumberOfAuxEntries: 1
-# CHECK-NEXT:   - Name:      i
-# CHECK-NEXT:     Value:     0x74
-# CHECK-NEXT:     Section: .data
-# CHECK-NEXT:     Type:      0x0
+# CHECK-NEXT:     CsectAuxEntry:
+# CHECK-NEXT:       SectionLen:      0
+# CHECK-NEXT:       ParameterHashIndex: 0
+# CHECK-NEXT:       TypeChkSectNum:  0
+# CHECK-NEXT:       SymbolAlignmentAndType: 1
+# CHECK-NEXT:       StorageMappingClass: XMC_TC0
+# CHECK-NEXT:       StabInfoIndex:   0
+# CHECK-NEXT:       StabSectNum:     0
+# CHECK-NEXT:   - Name:            i
+# CHECK-NEXT:     Value:           0x74
+# CHECK-NEXT:     Section:         .data
+# CHECK-NEXT:     Type:            0x0
 # CHECK-NEXT:     StorageClass:    C_HIDEXT
 # CHECK-NEXT:     NumberOfAuxEntries: 1
-# CHECK-NEXT:   - Name:      TestforXcoff
-# CHECK-NEXT:     Value:     0x78
-# CHECK-NEXT:     Section: .data
-# CHECK-NEXT:     Type:      0x0
+# CHECK-NEXT:     CsectAuxEntry:
+# CHECK-NEXT:       SectionLen:      4
+# CHECK-NEXT:       ParameterHashIndex: 0
+# CHECK-NEXT:       TypeChkSectNum:  0
+# CHECK-NEXT:       SymbolAlignmentAndType: 1
+# CHECK-NEXT:       StorageMappingClass: XMC_TC
+# CHECK-NEXT:       StabInfoIndex:   0
+# CHECK-NEXT:       StabSectNum:     0
+# CHECK-NEXT:   - Name:            TestforXcoff
+# CHECK-NEXT:     Value:           0x78
+# CHECK-NEXT:     Section:         .data
+# CHECK-NEXT:     Type:            0x0
 # CHECK-NEXT:     StorageClass:    C_HIDEXT
 # CHECK-NEXT:     NumberOfAuxEntries: 1
-# CHECK-NEXT: ...
+# CHECK-NEXT:     CsectAuxEntry:
+# CHECK-NEXT:       SectionLen:      4
+# CHECK-NEXT:       ParameterHashIndex: 0
+# CHECK-NEXT:       TypeChkSectNum:  0
+# CHECK-NEXT:       SymbolAlignmentAndType: 1
+# CHECK-NEXT:       StorageMappingClass: XMC_TC
+# CHECK-NEXT:       StabInfoIndex:   0
+# CHECK-NEXT:       StabSectNum:     0

llvm/tools/obj2yaml/xcoff2yaml.cpp

 //===------ xcoff2yaml.cpp - XCOFF YAMLIO implementation --------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "obj2yaml.h"
 #include "llvm/Object/XCOFFObjectFile.h"
 #include "llvm/ObjectYAML/XCOFFYAML.h"
+#include "llvm/Support/Errc.h"
 #include "llvm/Support/YAMLTraits.h"
 
 using namespace llvm;
 using namespace llvm::object;
 namespace {
 
 class XCOFFDumper {
   const object::XCOFFObjectFile &Obj;
   XCOFFYAML::Object YAMLObj;
   void dumpHeader();
-  std::error_code dumpSymbols();
+  Error dumpSections();
+  Error dumpSymbols();
+  template <typename T> Error dumpSections(ArrayRef<T> Sections);
 
 public:
   XCOFFDumper(const object::XCOFFObjectFile &obj) : Obj(obj) {}
-  std::error_code dump();
+  Error dump();
   XCOFFYAML::Object &getYAMLObj() { return YAMLObj; }
 };
 } // namespace
 
-std::error_code XCOFFDumper::dump() {
+Error XCOFFDumper::dump() {
   dumpHeader();
+  if (Error E = dumpSections())
+    return E;
   return dumpSymbols();
 }
 
 void XCOFFDumper::dumpHeader() {
 
   YAMLObj.Header.Magic = Obj.getMagic();
   YAMLObj.Header.NumberOfSections = Obj.getNumberOfSections();
   YAMLObj.Header.TimeStamp = Obj.getTimeStamp();
 
   // TODO FIXME only dump 32 bit header for now.
   if (Obj.is64Bit())
     report_fatal_error("64-bit XCOFF files not supported yet.");
   YAMLObj.Header.SymbolTableOffset = Obj.getSymbolTableOffset32();
 
   YAMLObj.Header.NumberOfSymTableEntries =
       Obj.getRawNumberOfSymbolTableEntries32();
   YAMLObj.Header.AuxHeaderSize = Obj.getOptionalHeaderSize();
   YAMLObj.Header.Flags = Obj.getFlags();
 }
 
-std::error_code XCOFFDumper::dumpSymbols() {
+Error XCOFFDumper::dumpSections() {
+  if (Obj.is64Bit())
+    return createStringError(object_error::invalid_file_type,
+                             "64-bit XCOFF not supported yet");
+  return dumpSections(Obj.sections32());
+}
+
+template <typename T> Error XCOFFDumper::dumpSections(ArrayRef<T> Sections) {
+  std::vector<XCOFFYAML::Section> &YamlSections = YAMLObj.Sections;
+  for (const T &S : Sections) {
+    XCOFFYAML::Section YamlSec;
+    YamlSec.SectionName = S.getName();
+    YamlSec.Address = S.PhysicalAddress;
+    YamlSec.Size = S.SectionSize;
+    YamlSec.NumberOfRelocations = S.NumberOfRelocations;
+    YamlSec.NumberOfLineNumbers = S.NumberOfLineNumbers;
+    YamlSec.FileOffsetToData = S.FileOffsetToRawData;
+    YamlSec.FileOffsetToRelocations = S.FileOffsetToRelocationInfo;
+    YamlSec.FileOffsetToLineNumbers = S.FileOffsetToLineNumberInfo;
+    YamlSec.Flags = S.Flags;
+
+    // Section data.
+    if (S.FileOffsetToRawData) {
+      DataRefImpl SectionDRI;
+      SectionDRI.p = reinterpret_cast<uintptr_t>(&S);
+      Expected<ArrayRef<uint8_t>> SecDataRefOrErr =
+          Obj.getSectionContents(SectionDRI);
+      if (!SecDataRefOrErr)
+        return SecDataRefOrErr.takeError();
+      YamlSec.SectionData = SecDataRefOrErr.get();
+    }
+    // Relocations.
+    if (S.NumberOfRelocations) {
+      Expected<ArrayRef<XCOFFRelocation32>> RelRefOrErr = Obj.relocations(S);
+      if (!RelRefOrErr)
+        return RelRefOrErr.takeError();
+      for (XCOFFRelocation32 Rel : RelRefOrErr.get()) {
+        XCOFFYAML::Relocation YamlRel;
+        YamlRel.Type = Rel.Type;
+        YamlRel.Info = Rel.Info;
+        YamlRel.SymbolIndex = Rel.SymbolIndex;
+        YamlRel.VirtualAddress = Rel.VirtualAddress;
+        YamlSec.Relocations.push_back(YamlRel);
+      }
+    }
+    YamlSections.push_back(YamlSec);
+  }
+  return Error::success();
+}
+
+Error XCOFFDumper::dumpSymbols() {
   std::vector<XCOFFYAML::Symbol> &Symbols = YAMLObj.Symbols;
 
   for (const SymbolRef &S : Obj.symbols()) {
     DataRefImpl SymbolDRI = S.getRawDataRefImpl();
     const XCOFFSymbolRef SymbolEntRef = Obj.toSymbolRef(SymbolDRI);
     XCOFFYAML::Symbol Sym;
 
     Expected<StringRef> SymNameRefOrErr = Obj.getSymbolName(SymbolDRI);
     if (!SymNameRefOrErr) {
-      return errorToErrorCode(SymNameRefOrErr.takeError());
+      return SymNameRefOrErr.takeError();
     }
     Sym.SymbolName = SymNameRefOrErr.get();
 
     Sym.Value = SymbolEntRef.getValue();
 
     Expected<StringRef> SectionNameRefOrErr =
         Obj.getSymbolSectionName(SymbolEntRef);
     if (!SectionNameRefOrErr)
-      return errorToErrorCode(SectionNameRefOrErr.takeError());
+      return SectionNameRefOrErr.takeError();
 
     Sym.SectionName = SectionNameRefOrErr.get();
 
     Sym.Type = SymbolEntRef.getSymbolType();
     Sym.StorageClass = SymbolEntRef.getStorageClass();
     Sym.NumberOfAuxEntries = SymbolEntRef.getNumberOfAuxEntries();
+    // Dump auxiliary entries.
+    switch (Sym.StorageClass) {
+    case XCOFF::C_FILE:
+      // A file auxiliary entry is optional.
+      if (Sym.NumberOfAuxEntries) {
+        const XCOFFFileAuxEnt *FileAuxEntPtr =
+            reinterpret_cast<const XCOFFFileAuxEnt *>(
+                XCOFFObjectFile::getAdvancedSymbolEntryAddress(
+                    SymbolEntRef.getEntryAddress(), 1));
+#ifndef NDEBUG
+        Obj.checkSymbolEntryPointer(reinterpret_cast<uintptr_t>(FileAuxEntPtr));
+#endif
+        XCOFFYAML::FileAuxEnt &AuxEnt = Sym.FileAuxEntry;
+        Expected<StringRef> FileNameRefOrErr = Obj.getCFileName(FileAuxEntPtr);
+        if (!FileNameRefOrErr)
+          return FileNameRefOrErr.takeError();
+        AuxEnt.FileName = FileNameRefOrErr.get();
+        AuxEnt.Type = FileAuxEntPtr->Type;
+      }
+      break;
+    case XCOFF::C_EXT:
+    case XCOFF::C_WEAKEXT:
+    case XCOFF::C_HIDEXT: {
+      // TODO implement function auxiliary entry.
+      // A csect auxiliary entry is required.
+      XCOFFSymbolRef XCOFFSymRef(SymbolDRI, &Obj);
+      Expected<XCOFFCsectAuxRef> CsectAuxEntOrErr =
+          SymbolEntRef.getXCOFFCsectAuxRef();
+      if (!CsectAuxEntOrErr)
+        return CsectAuxEntOrErr.takeError();
+      auto CsectAuxEnt = CsectAuxEntOrErr.get();
+      XCOFFYAML::CsectAuxEnt32 &AuxEnt = Sym.CsectAuxEntry;
+      AuxEnt.SectionOrLength = CsectAuxEnt.getSectionOrLength();
+      AuxEnt.ParameterHashIndex = CsectAuxEnt.getParameterHashIndex();
+      AuxEnt.TypeChkSecNum = CsectAuxEnt.getTypeChkSectNum();
+      AuxEnt.SymbolAlignmentAndType = CsectAuxEnt.getSymbolType();
+      AuxEnt.StorageMappingClass = CsectAuxEnt.getStorageMappingClass();
+      AuxEnt.StabSecNum = CsectAuxEnt.getStabSectNum32();
+      AuxEnt.StabInfoIndex = CsectAuxEnt.getStabInfoIndex32();
+      break;
+    }
+    default:
+      // TODO dump auxiliary information for other symbols.
+      break;
+    }
     Symbols.push_back(Sym);
   }
 
-  return std::error_code();
+  return Error::success();
 }
 
 std::error_code xcoff2yaml(raw_ostream &Out,
                            const object::XCOFFObjectFile &Obj) {
   XCOFFDumper Dumper(Obj);
 
-  if (std::error_code EC = Dumper.dump())
-    return EC;
+  if (Error E = Dumper.dump())
+    return errorToErrorCode(std::move(E));
 
   yaml::Output Yout(Out);
   Yout << Dumper.getYAMLObj();
 
   return std::error_code();
 }