[yaml2obj][XCOFF] parsing auxiliary symbols.

[Esme]

Summary

The patch adds support for yaml2obj parsing auxiliary symbols for XCOFF.

[jhenderson]

I'd recommend including DiggerLin in the subscriber lists for these, since he is using yaml2obj for XCOFF quite a bit. I'll get to this review in the next couple of days hopefully.

[Higuoxing]

llvm/include/llvm/ObjectYAML/XCOFFYAML.h

197

Question 1: Why we need std::unique_ptr<> here?

Question 2: It looks that AuxEntries is optional in the symbol entry. Can we wrap it with Optional<>.

llvm/lib/ObjectYAML/XCOFFEmitter.cpp

209

Nit.

211

242–243

Nit: coding style.

244

It would be great to print the values of NumberOfAuxEntries and AuxCount in the error message.

llvm/lib/ObjectYAML/XCOFFYAML.cpp

252–253

Why the names of these two entries are not consistent with other fields (e.g., SectionOrLengthLo, SectionOrLengthHi)?

[Higuoxing]

llvm/lib/ObjectYAML/XCOFFEmitter.cpp

701–717

It would be great to move these if-else statements into a helper function.

[jhenderson]

llvm/include/llvm/ObjectYAML/XCOFFYAML.h

150

I'm not sure that these comments are really useful. I'd just get rid of them.

llvm/lib/ObjectYAML/XCOFFYAML.cpp

294–295

Should this really be an error? Could you potentially have an AUX_EXCEPT symbol in a 32-bit object (albeit a malformed one)? Or is it fundamentally impossible to write such a thing? Same goes for the AUX_STAT symbol below.

Remember, in yaml2obj, we want to be as permissive as possible. If you could imagine something existing, it should be allowed, even if the file format techincally prohibits it. This then allows you to write testing for code that reads the file (e.g. llvm-readobj) to ensure it properly handles such cases.

llvm/test/tools/yaml2obj/XCOFF/aux-symbols-defaults.yaml

3 ↗

(On Diff #386099)

Rather than have one test-case per aux entry type, is it possible to have one which contains all entry types, either with a single symbol, or multiple symbols, as needed?

In the mulitple symbol case, name the symbols after their aux entry.

38 ↗

(On Diff #386099)

llvm/test/tools/yaml2obj/XCOFF/aux-symbols-full-contents.yaml

1 ↗

(On Diff #386099)

Rather than needing to duplicate the YAML between this and the defaults test case, you could consider implementing support for (if needed) and using the special [[MACRO=<none>]] syntax in the YAML. For ELF, this is equivalent to omitting the field, if no value is specified for it, which allows you to test default behaviour, using the same YAML as non-default behaviour.

llvm/tools/obj2yaml/xcoff2yaml.cpp

136–142

Maybe spin this off into another patch? Seems unrelated to getting yaml2obj to actually produce the aux symbols, and needs its own testing.

[Esme]

Address comments.

llvm/include/llvm/ObjectYAML/XCOFFYAML.h

197

I think there is no harm in using std::unique_ptr<> since it has less overhead. While wrapping it with Optional<> will cause failure in mapOptional().

llvm/lib/ObjectYAML/XCOFFYAML.cpp

294–295

I think this should be an error.

1. When parsing a 32-bit object, the AuxSymbol type is determined by the Value and StorageClass of the symbol to which it belongs. Even if we intentionally write a case of AUX_EXCEPT symbol in XCOFF32, it cannot be parsed as AUX_EXCEPT, but as some other types, and it makes sense to parse it this way.
2. As for the 64-bit object, the AuxSymbol type can also be recognized by the AuxSymbolType field, but the type XCOFF::AUX_STAT does not exist, so it is fundamentally impossible to write such a thing.

llvm/test/tools/yaml2obj/XCOFF/aux-symbols-defaults.yaml

3 ↗

(On Diff #386099)

Thanks!

llvm/test/tools/yaml2obj/XCOFF/aux-symbols-full-contents.yaml

1 ↗

(On Diff #386099)

The [[MACRO=<none>]] syntax will work well to reduce duplication when the same field is used for multiple assignments. But in this test, most of the fields only need to be tested once.
Besides, 32-bit and 64-bit may have different fields for the same aux symbol type, so I have to use two YAMLs. I don't think using [[MACRO=<none>]] here will simplify the test.
And I think it would be easier to review if I separate the default and non-default behaviors?

llvm/tools/obj2yaml/xcoff2yaml.cpp

136–142

Agree, thanks.

[jhenderson]

llvm/lib/ObjectYAML/XCOFFEmitter.cpp

241

You could store this a uint32_t to save the later cast, if you want.

244

I think we prefer static_cast

llvm/test/tools/yaml2obj/XCOFF/aux-symbols-full-contents.yaml

1 ↗

(On Diff #386099)

You've got two general test cases: the default and the non default. In both cases, you need a fair amount of basic scaffolding for the YAML to work (i.e. symbol details etc). In the default case, you can omit some fields, for the aux entries, but not in the full contents cases. I'm suggesting you merge the default and non-default YAML documents, not the 32/64 cases, so that the basic scaffolding isn't duplicated across the two files.

I don't think it's any easier to review separating default and non-default cases, personally. You'll see this pattern a lot in the ELF tests.

[Esme]

Address comments.

[Esme]

Thank you so much for your reviewing. @jhenderson @Higuoxing
Do you have more comments for this patch?
Btw. there are 2 accepted patches (D113825 and D114434) depends on this patch.

[jhenderson]

Apologies, no idea how this one slipped off the radar. Mostly looks good, but some test comments.

llvm/lib/ObjectYAML/XCOFFEmitter.cpp

643

I don't think you've got a test case for this case?

704–705

Is there testing for this case?

llvm/test/tools/yaml2obj/XCOFF/aux-symbols.yaml

3

457

497–502

This comment and error don't match up. According to the comment, I'd expect to see a complaint about using AUX_STAT in XCOFF32, but the error is soemthing about C_STAT symbols being defined in XCOFF32.

513–518

Same sort of comment as above.

528

Nit: double blank line

530–531

[Higuoxing]

In D113552#3194383, @Esme wrote:

Thank you so much for your reviewing. @jhenderson @Higuoxing
Do you have more comments for this patch?
Btw. there are 2 accepted patches (D113825 and D114434) depends on this patch.

Sorry for not responding to this thread for a long time. I'm busy with my works these days. You can land this patch once @jhenderson is happy with it :-)

[DiggerLin]

llvm/include/llvm/ObjectYAML/XCOFFYAML.h

93

there is enum define as enum SymbolAuxType in xcoff.h, I think you can use it instead of define a new one.

96

please add some comment here " it is for 64bits only"

121

I am prefer to add some comments on the data member to indicate the one is for 32bits or 64bits only, or it is for both.
and rearrange the member in the order of common field for both 32bits and 64bits first , only for 32bits, only for the 64bits.

142

ExcpetionAuxEnt is 64bit only and OffsetToExceptionTbl is 8 bytes.

197

I think it need std::unique_ptr<> here, for the AuxEntries is std::vector<> of the pointer to AuxSymbolEnt, without the std::unique_ptr<>, we have to delete all the pointer of AuxSymbolEnt manually otherwise there is memory leak.

[DiggerLin]

the x_auxtype is only for 64bits. in the implement, it means we always need to specific the AUX_type no matter it is 32bit or 64bits.

[Esme]

Thanks! @jhenderson @DiggerLin @Higuoxing
Address comments.

[Esme]

In D113552#3197920, @DiggerLin wrote:

the x_auxtype is only for 64bits. in the implement, it means we always need to specific the AUX_type no matter it is 32bit or 64bits.

Yes, I think it's convenient for users to define an aux symbol with a specified type and it's straightforward for the designing of yaml2obj behaviors.

llvm/include/llvm/ObjectYAML/XCOFFYAML.h

93

XCOFF::SymbolAuxType is only for XCOFF64, therefor the AUX_STAT for XCOFF32 is not a member of XCOFF::SymbolAuxType. But it's required in yaml2obj (as what I have designed) when writing the section auxiliary entry for the C_STAT symbol.

96

It's required to determine the aux type when reading the yaml files, even we are not going to write the _auxtype field for XCOFF32. So it's not for 64bits only here.

121

Nice comments, thanks.

llvm/lib/ObjectYAML/XCOFFEmitter.cpp

643

In fact, this is a llvm_unreachable case because the XCOFFYAML::AuxSymbolType AuxType is a required field in Yaml input and a case with unknown auxiliary symbol type can't be generated in Yaml.

[Esme]

Gently ping.

[jhenderson]

LGTM, except for one nit, but please also make sure @DiggerLin is happy.

llvm/lib/ObjectYAML/XCOFFEmitter.cpp

643

If it's unreachable, why not use llvm_unreachable?

[DiggerLin]

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;
 };
 
+enum AuxSymbolType : uint8_t {
+  AUX_EXCEPT = 255,
+  AUX_FCN = 254,
+  AUX_SYM = 253,
+  AUX_FILE = 252,
+  AUX_CSECT = 251,
+  AUX_SECT = 250,
+  AUX_STAT = 249
+};
+
+struct AuxSymbolEnt {
+  AuxSymbolType Type;
+
+  explicit AuxSymbolEnt(AuxSymbolType T) : Type(T) {}
+  virtual ~AuxSymbolEnt();
+};
+
+struct FileAuxEnt : AuxSymbolEnt {
+  Optional<StringRef> FileNameOrString;
+  Optional<XCOFF::CFileStringType> FileStringType;
+
+  FileAuxEnt() : AuxSymbolEnt(AuxSymbolType::AUX_FILE) {}
+  static bool classof(const AuxSymbolEnt *S) {
+    return S->Type == AuxSymbolType::AUX_FILE;
+  }
+};
+
+struct CsectAuxEnt : AuxSymbolEnt {
+  // Only for XCOFF32.
+  Optional<uint32_t> SectionOrLength;
+  Optional<uint32_t> StabInfoIndex;
+  Optional<uint16_t> StabSectNum;
+  // Only for XCOFF64.
+  Optional<uint32_t> SectionOrLengthLo;
+  Optional<uint32_t> SectionOrLengthHi;
+  // Common fields for both XCOFF32 and XCOFF64.
+  Optional<uint32_t> ParameterHashIndex;
+  Optional<uint16_t> TypeChkSectNum;
+  Optional<uint8_t> SymbolAlignmentAndType;
+  Optional<XCOFF::StorageMappingClass> StorageMappingClass;
+
+  CsectAuxEnt() : AuxSymbolEnt(AuxSymbolType::AUX_CSECT) {}
+  static bool classof(const AuxSymbolEnt *S) {
+    return S->Type == AuxSymbolType::AUX_CSECT;
+  }
+};
+
+struct FunctionAuxEnt : AuxSymbolEnt {
+  Optional<uint32_t> OffsetToExceptionTbl; // Only for XCOFF32.
+  Optional<uint64_t> PtrToLineNum;
+  Optional<uint32_t> SizeOfFunction;
+  Optional<int32_t> SymIdxOfNextBeyond;
+
+  FunctionAuxEnt() : AuxSymbolEnt(AuxSymbolType::AUX_FCN) {}
+  static bool classof(const AuxSymbolEnt *S) {
+    return S->Type == AuxSymbolType::AUX_FCN;
+  }
+};
+
+struct ExcpetionAuxEnt : AuxSymbolEnt {
+  Optional<uint64_t> OffsetToExceptionTbl;
+  Optional<uint32_t> SizeOfFunction;
+  Optional<int32_t> SymIdxOfNextBeyond;
+
+  ExcpetionAuxEnt() : AuxSymbolEnt(AuxSymbolType::AUX_EXCEPT) {}
+  static bool classof(const AuxSymbolEnt *S) {
+    return S->Type == AuxSymbolType::AUX_EXCEPT;
+  }
+}; // Only for XCOFF64.
+
+struct BlockAuxEnt : AuxSymbolEnt {
+  // Only for XCOFF32.
+  Optional<uint16_t> LineNumHi;
+  Optional<uint16_t> LineNumLo;
+  // Only for XCOFF64.
+  Optional<uint32_t> LineNum;
+
+  BlockAuxEnt() : AuxSymbolEnt(AuxSymbolType::AUX_SYM) {}
+  static bool classof(const AuxSymbolEnt *S) {
+    return S->Type == AuxSymbolType::AUX_SYM;
+  }
+};
+
+struct SectAuxEntForDWARF : AuxSymbolEnt {
+  Optional<uint32_t> LengthOfSectionPortion;
+  Optional<uint32_t> NumberOfRelocEnt;
+
+  SectAuxEntForDWARF() : AuxSymbolEnt(AuxSymbolType::AUX_SECT) {}
+  static bool classof(const AuxSymbolEnt *S) {
+    return S->Type == AuxSymbolType::AUX_SECT;
+  }
+};
+
+struct SectAuxEntForStat : AuxSymbolEnt {
+  Optional<uint32_t> SectionLength;
+  Optional<uint16_t> NumberOfRelocEnt;
+  Optional<uint16_t> NumberOfLineNum;
+
+  SectAuxEntForStat() : AuxSymbolEnt(AuxSymbolType::AUX_STAT) {}
+  static bool classof(const AuxSymbolEnt *S) {
+    return S->Type == AuxSymbolType::AUX_STAT;
+  }
+}; // Only for XCOFF32.
+
 struct Symbol {
   StringRef SymbolName;
   llvm::yaml::Hex64 Value; // Symbol value; storage class-dependent.
   Optional<StringRef> SectionName;
   Optional<uint16_t> SectionIndex;
   llvm::yaml::Hex16 Type;
   XCOFF::StorageClass StorageClass;
-  uint8_t NumberOfAuxEntries;
+  Optional<uint8_t> NumberOfAuxEntries;
+  std::vector<std::unique_ptr<AuxSymbolEnt>> AuxEntries;
 };
 
 struct StringTable {
   Optional<uint32_t> ContentSize; // The total size of the string table.
   Optional<uint32_t> Length;      // The value of the length field for the first
                                   // 4 bytes of the table.
   Optional<std::vector<StringRef>> Strings;
   Optional<yaml::BinaryRef> RawContent;
 };
 
 struct Object {
   FileHeader Header;
   Optional<AuxiliaryHeader> AuxHeader;
   std::vector<Section> Sections;
   std::vector<Symbol> Symbols;
   StringTable StrTbl;
   Object();
 };
 } // namespace XCOFFYAML
 } // namespace llvm
 
 LLVM_YAML_IS_SEQUENCE_VECTOR(XCOFFYAML::Symbol)
 LLVM_YAML_IS_SEQUENCE_VECTOR(XCOFFYAML::Relocation)
 LLVM_YAML_IS_SEQUENCE_VECTOR(XCOFFYAML::Section)
+LLVM_YAML_IS_SEQUENCE_VECTOR(std::unique_ptr<llvm::XCOFFYAML::AuxSymbolEnt>)
 
 namespace llvm {
 namespace yaml {
 
 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 &Type);
+};
+
+template <> struct ScalarEnumerationTraits<XCOFFYAML::AuxSymbolType> {
+  static void enumeration(IO &IO, XCOFFYAML::AuxSymbolType &Type);
+};
+
 template <> struct MappingTraits<XCOFFYAML::FileHeader> {
   static void mapping(IO &IO, XCOFFYAML::FileHeader &H);
 };
 
 template <> struct MappingTraits<XCOFFYAML::AuxiliaryHeader> {
   static void mapping(IO &IO, XCOFFYAML::AuxiliaryHeader &AuxHdr);
 };
 
+template <> struct MappingTraits<std::unique_ptr<XCOFFYAML::AuxSymbolEnt>> {
+  static void mapping(IO &IO, std::unique_ptr<XCOFFYAML::AuxSymbolEnt> &AuxSym);
+};
+
 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/XCOFFEmitter.cpp

 private:
   bool nameShouldBeInStringTable(StringRef SymbolName);
   bool initFileHeader(uint64_t CurrentOffset);
   void initAuxFileHeader();
   bool initSectionHeader(uint64_t &CurrentOffset);
   bool initRelocations(uint64_t &CurrentOffset);
   bool initStringTable();
   bool assignAddressesAndIndices();
+
   void writeFileHeader();
   void writeAuxFileHeader();
   void writeSectionHeader();
   bool writeSectionData();
   bool writeRelocations();
   bool writeSymbols();
   void writeStringTable();
 
+  void writeAuxSymbol(const XCOFFYAML::CsectAuxEnt &AuxSym);
+  void writeAuxSymbol(const XCOFFYAML::FileAuxEnt &AuxSym);
+  void writeAuxSymbol(const XCOFFYAML::FunctionAuxEnt &AuxSym);
+  void writeAuxSymbol(const XCOFFYAML::ExcpetionAuxEnt &AuxSym);
+  void writeAuxSymbol(const XCOFFYAML::BlockAuxEnt &AuxSym);
+  void writeAuxSymbol(const XCOFFYAML::SectAuxEntForDWARF &AuxSym);
+  void writeAuxSymbol(const XCOFFYAML::SectAuxEntForStat &AuxSym);
+  void writeAuxSymbol(const std::unique_ptr<XCOFFYAML::AuxSymbolEnt> &AuxSym);
+
   XCOFFYAML::Object &Obj;
   bool Is64Bit = false;
   support::endian::Writer W;
   yaml::ErrorHandler ErrHandler;
   StringTableBuilder StrTblBuilder;
   uint64_t StartOffset;
   // Map the section name to its corrresponding section index.
   DenseMap<StringRef, int16_t> SectionIndexMap = {
for (XCOFFYAML::Symbol &YamlSym : Obj.Symbols) {
           ++StrTblIdx;
         } else
           // Names that are not overwritten are still stored in the string
           // table.
           StrTblBuilder.add(YamlSym.SymbolName);
       }
     }
   } else {
-    for (XCOFFYAML::Symbol &YamlSym : Obj.Symbols) {
+    for (const XCOFFYAML::Symbol &YamlSym : Obj.Symbols) {
       if (nameShouldBeInStringTable(YamlSym.SymbolName))
         StrTblBuilder.add(YamlSym.SymbolName);
     }
   }
 
+  // Check if the file name in the File Auxiliary Entry should be added to the
+  // string table.
+  for (const XCOFFYAML::Symbol &YamlSym : Obj.Symbols) {
+    for (const std::unique_ptr<XCOFFYAML::AuxSymbolEnt> &AuxSym :
+         YamlSym.AuxEntries) {
+      if (auto AS = dyn_cast<XCOFFYAML::FileAuxEnt>(AuxSym.get()))
+        if (nameShouldBeInStringTable(AS->FileNameOrString.getValueOr("")))
+          StrTblBuilder.add(AS->FileNameOrString.getValueOr(""));
+    }
+  }
+
   StrTblBuilder.finalize();
 
   size_t StrTblSize = StrTblBuilder.getSize();
   if (Obj.StrTbl.ContentSize && *Obj.StrTbl.ContentSize < StrTblSize) {
     ErrHandler("specified ContentSize (" + Twine(*Obj.StrTbl.ContentSize) +
                ") is less than the size of the data that would otherwise be "
                "written (" +
                Twine(StrTblSize) + ")");
     return false;
   }
 
   return true;
 }
 
 bool XCOFFWriter::initFileHeader(uint64_t CurrentOffset) {
   // The default format of the object file is XCOFF32.
   InitFileHdr.Magic = XCOFF::XCOFF32;
   InitFileHdr.NumberOfSections = Obj.Sections.size();
   InitFileHdr.NumberOfSymTableEntries = Obj.Symbols.size();
 
-  for (const XCOFFYAML::Symbol &YamlSym : Obj.Symbols)
+  for (XCOFFYAML::Symbol &YamlSym : Obj.Symbols) {
+    uint32_t AuxCount = YamlSym.AuxEntries.size();
+    if (YamlSym.NumberOfAuxEntries && *YamlSym.NumberOfAuxEntries < AuxCount) {
+      ErrHandler("specified NumberOfAuxEntries " +
+                 Twine(static_cast<uint32_t>(*YamlSym.NumberOfAuxEntries)) +
+                 " is less than the actual number "
+                 "of auxiliary entries " +
+                 Twine(AuxCount));
+      return false;
+    }
+    YamlSym.NumberOfAuxEntries =
+        YamlSym.NumberOfAuxEntries.getValueOr(AuxCount);
     // Add the number of auxiliary symbols to the total number.
-    InitFileHdr.NumberOfSymTableEntries += YamlSym.NumberOfAuxEntries;
+    InitFileHdr.NumberOfSymTableEntries += *YamlSym.NumberOfAuxEntries;
+  }
 
   // Calculate SymbolTableOffset for the file header.
   if (InitFileHdr.NumberOfSymTableEntries) {
     InitFileHdr.SymbolTableOffset = CurrentOffset;
     CurrentOffset +=
         InitFileHdr.NumberOfSymTableEntries * XCOFF::SymbolTableEntrySize;
     if (CurrentOffset > MaxRawDataSize) {
       ErrHandler("maximum object size of" + Twine(MaxRawDataSize) +
if (!YamlSec.Relocations.empty()) {
         W.write<uint8_t>(YamlRel.Info);
         W.write<uint8_t>(YamlRel.Type);
       }
     }
   }
   return true;
 }
 
+void XCOFFWriter::writeAuxSymbol(const XCOFFYAML::CsectAuxEnt &AuxSym) {
+  if (Is64Bit) {
+    W.write<uint32_t>(AuxSym.SectionOrLengthLo.getValueOr(0));
+    W.write<uint32_t>(AuxSym.ParameterHashIndex.getValueOr(0));
+    W.write<uint16_t>(AuxSym.TypeChkSectNum.getValueOr(0));
+    W.write<uint8_t>(AuxSym.SymbolAlignmentAndType.getValueOr(0));
+    W.write<uint8_t>(AuxSym.StorageMappingClass.getValueOr(XCOFF::XMC_PR));
+    W.write<uint32_t>(AuxSym.SectionOrLengthHi.getValueOr(0));
+    W.write<uint8_t>(0);
+    W.write<uint8_t>(XCOFF::AUX_CSECT);
+  } else {
+    W.write<uint32_t>(AuxSym.SectionOrLength.getValueOr(0));
+    W.write<uint32_t>(AuxSym.ParameterHashIndex.getValueOr(0));
+    W.write<uint16_t>(AuxSym.TypeChkSectNum.getValueOr(0));
+    W.write<uint8_t>(AuxSym.SymbolAlignmentAndType.getValueOr(0));
+    W.write<uint8_t>(AuxSym.StorageMappingClass.getValueOr(XCOFF::XMC_PR));
+    W.write<uint32_t>(AuxSym.StabInfoIndex.getValueOr(0));
+    W.write<uint16_t>(AuxSym.StabSectNum.getValueOr(0));
+  }
+}
+
+void XCOFFWriter::writeAuxSymbol(const XCOFFYAML::ExcpetionAuxEnt &AuxSym) {
+  assert(Is64Bit && "can't write the exception auxiliary symbol for XCOFF32");
+  W.write<uint64_t>(AuxSym.OffsetToExceptionTbl.getValueOr(0));
+  W.write<uint32_t>(AuxSym.SizeOfFunction.getValueOr(0));
+  W.write<uint32_t>(AuxSym.SymIdxOfNextBeyond.getValueOr(0));
+  W.write<uint8_t>(0);
+  W.write<uint8_t>(XCOFF::AUX_EXCEPT);
+}
+
+void XCOFFWriter::writeAuxSymbol(const XCOFFYAML::FunctionAuxEnt &AuxSym) {
+  if (Is64Bit) {
+    W.write<uint64_t>(AuxSym.PtrToLineNum.getValueOr(0));
+    W.write<uint32_t>(AuxSym.SizeOfFunction.getValueOr(0));
+    W.write<uint32_t>(AuxSym.SymIdxOfNextBeyond.getValueOr(0));
+    W.write<uint8_t>(0);
+    W.write<uint8_t>(XCOFF::AUX_FCN);
+  } else {
+    W.write<uint32_t>(AuxSym.OffsetToExceptionTbl.getValueOr(0));
+    W.write<uint32_t>(AuxSym.SizeOfFunction.getValueOr(0));
+    W.write<uint32_t>(AuxSym.PtrToLineNum.getValueOr(0));
+    W.write<uint32_t>(AuxSym.SymIdxOfNextBeyond.getValueOr(0));
+    W.OS.write_zeros(2);
+  }
+}
+
+void XCOFFWriter::writeAuxSymbol(const XCOFFYAML::FileAuxEnt &AuxSym) {
+  StringRef FileName = AuxSym.FileNameOrString.getValueOr("");
+  if (nameShouldBeInStringTable(FileName)) {
+    W.write<int32_t>(0);
+    W.write<uint32_t>(StrTblBuilder.getOffset(FileName));
+  } else {
+    writeName(FileName, W);
+  }
+  W.OS.write_zeros(XCOFF::FileNamePadSize);
+  W.write<uint8_t>(AuxSym.FileStringType.getValueOr(XCOFF::XFT_FN));
+  if (Is64Bit) {
+    W.OS.write_zeros(2);
+    W.write<uint8_t>(XCOFF::AUX_FILE);
+  } else {
+    W.OS.write_zeros(3);
+  }
+}
+
+void XCOFFWriter::writeAuxSymbol(const XCOFFYAML::BlockAuxEnt &AuxSym) {
+  if (Is64Bit) {
+    W.write<uint32_t>(AuxSym.LineNum.getValueOr(0));
+    W.OS.write_zeros(13);
+    W.write<uint8_t>(XCOFF::AUX_SYM);
+  } else {
+    W.OS.write_zeros(2);
+    W.write<uint16_t>(AuxSym.LineNumHi.getValueOr(0));
+    W.write<uint16_t>(AuxSym.LineNumLo.getValueOr(0));
+    W.OS.write_zeros(12);
+  }
+}
+
+void XCOFFWriter::writeAuxSymbol(const XCOFFYAML::SectAuxEntForDWARF &AuxSym) {
+  if (Is64Bit) {
+    W.write<uint64_t>(AuxSym.LengthOfSectionPortion.getValueOr(0));
+    W.write<uint64_t>(AuxSym.NumberOfRelocEnt.getValueOr(0));
+    W.write<uint8_t>(0);
+    W.write<uint8_t>(XCOFF::AUX_SECT);
+  } else {
+    W.write<uint32_t>(AuxSym.LengthOfSectionPortion.getValueOr(0));
+    W.OS.write_zeros(4);
+    W.write<uint32_t>(AuxSym.NumberOfRelocEnt.getValueOr(0));
+    W.OS.write_zeros(6);
+  }
+}
+
+void XCOFFWriter::writeAuxSymbol(const XCOFFYAML::SectAuxEntForStat &AuxSym) {
+  assert(!Is64Bit && "can't write the stat auxiliary symbol for XCOFF64");
+  W.write<uint32_t>(AuxSym.SectionLength.getValueOr(0));
+  W.write<uint16_t>(AuxSym.NumberOfRelocEnt.getValueOr(0));
+  W.write<uint16_t>(AuxSym.NumberOfLineNum.getValueOr(0));
+  W.OS.write_zeros(10);
+}
+
+void XCOFFWriter::writeAuxSymbol(
+    const std::unique_ptr<XCOFFYAML::AuxSymbolEnt> &AuxSym) {
+  if (auto AS = dyn_cast<XCOFFYAML::CsectAuxEnt>(AuxSym.get()))
+    writeAuxSymbol(*AS);
+  else if (auto AS = dyn_cast<XCOFFYAML::FunctionAuxEnt>(AuxSym.get()))
+    writeAuxSymbol(*AS);
+  else if (auto AS = dyn_cast<XCOFFYAML::ExcpetionAuxEnt>(AuxSym.get()))
+    writeAuxSymbol(*AS);
+  else if (auto AS = dyn_cast<XCOFFYAML::FileAuxEnt>(AuxSym.get()))
+    writeAuxSymbol(*AS);
+  else if (auto AS = dyn_cast<XCOFFYAML::BlockAuxEnt>(AuxSym.get()))
+    writeAuxSymbol(*AS);
+  else if (auto AS = dyn_cast<XCOFFYAML::SectAuxEntForDWARF>(AuxSym.get()))
+    writeAuxSymbol(*AS);
+  else if (auto AS = dyn_cast<XCOFFYAML::SectAuxEntForStat>(AuxSym.get()))
+    writeAuxSymbol(*AS);
+  else
+    ErrHandler("unknown auxiliary symbol type: " + Twine(AuxSym->Type));
+}
+
 bool XCOFFWriter::writeSymbols() {
   int64_t PaddingSize =
       (uint64_t)InitFileHdr.SymbolTableOffset - (W.OS.tell() - StartOffset);
   if (PaddingSize < 0) {
     ErrHandler("redundant data was written before symbols");
     return false;
   }
   W.OS.write_zeros(PaddingSize);
if (YamlSym.SectionName) {
         return false;
       }
       W.write<int16_t>(SectionIndexMap[*YamlSym.SectionName]);
     } else {
       W.write<int16_t>(YamlSym.SectionIndex ? *YamlSym.SectionIndex : 0);
     }
     W.write<uint16_t>(YamlSym.Type);
     W.write<uint8_t>(YamlSym.StorageClass);
-    W.write<uint8_t>(YamlSym.NumberOfAuxEntries);
 
-    // Now output the auxiliary entry.
-    for (uint8_t I = 0, E = YamlSym.NumberOfAuxEntries; I < E; ++I) {
-      // TODO: Auxiliary entry is not supported yet.
-      // The auxiliary entries for a symbol follow its symbol table entry. The
-      // length of each auxiliary entry is the same as a symbol table entry (18
-      // bytes). The format and quantity of auxiliary entries depend on the
-      // storage class (n_sclass) and type (n_type) of the symbol table entry.
-      W.OS.write_zeros(XCOFF::SymbolTableEntrySize);
+    uint8_t NumOfAuxSym = YamlSym.NumberOfAuxEntries.getValueOr(0);
+    W.write<uint8_t>(NumOfAuxSym);
+
+    if (!NumOfAuxSym && !YamlSym.AuxEntries.size())
+      continue;
+
+    // Now write auxiliary entries.
+    if (!YamlSym.AuxEntries.size()) {
+      W.OS.write_zeros(XCOFF::SymbolTableEntrySize * NumOfAuxSym);
+    } else {
+      for (const std::unique_ptr<XCOFFYAML::AuxSymbolEnt> &AuxSym :
+           YamlSym.AuxEntries) {
+        writeAuxSymbol(AuxSym);
+      }
+      // Pad with zeros.
+      if (NumOfAuxSym > YamlSym.AuxEntries.size())
+        W.OS.write_zeros(XCOFF::SymbolTableEntrySize *
+                         (NumOfAuxSym - YamlSym.AuxEntries.size()));
     }
   }
   return true;
 }
 
 void XCOFFWriter::writeStringTable() {
   if (Obj.StrTbl.RawContent) {
     Obj.StrTbl.RawContent->writeAsBinary(W.OS);
     if (Obj.StrTbl.ContentSize) {
       assert(*Obj.StrTbl.ContentSize >= Obj.StrTbl.RawContent->binary_size() &&
              "Specified ContentSize is less than the RawContent size.");
       W.OS.write_zeros(*Obj.StrTbl.ContentSize -
                        Obj.StrTbl.RawContent->binary_size());
     }
     return;
   }
 
   size_t StrTblBuilderSize = StrTblBuilder.getSize();
   // If neither Length nor ContentSize is specified, write the StrTblBuilder

llvm/lib/ObjectYAML/XCOFFYAML.cpp

 #include "llvm/BinaryFormat/XCOFF.h"
 #include <string.h>
 
 namespace llvm {
 namespace XCOFFYAML {
 
 Object::Object() { memset(&Header, 0, sizeof(Header)); }
 
+AuxSymbolEnt::~AuxSymbolEnt() = default;
+
 } // namespace XCOFFYAML
 
 namespace yaml {
 
 void ScalarBitSetTraits<XCOFF::SectionTypeFlags>::bitset(
     IO &IO, XCOFF::SectionTypeFlags &Value) {
 #define ECase(X) IO.bitSetCase(Value, #X, XCOFF::X)
   ECase(STYP_PAD);
#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_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<XCOFFYAML::AuxSymbolType>::enumeration(
+    IO &IO, XCOFFYAML::AuxSymbolType &Type) {
+#define ECase(X) IO.enumCase(Type, #X, XCOFFYAML::X)
+  ECase(AUX_EXCEPT);
+  ECase(AUX_FCN);
+  ECase(AUX_SYM);
+  ECase(AUX_FILE);
+  ECase(AUX_CSECT);
+  ECase(AUX_SECT);
+  ECase(AUX_STAT);
+#undef ECase
+}
+
+void ScalarEnumerationTraits<XCOFF::CFileStringType>::enumeration(
+    IO &IO, XCOFF::CFileStringType &Type) {
+#define ECase(X) IO.enumCase(Type, #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.mapOptional("Flags", NC->Flags);
   IO.mapOptional("SectionData", Sec.SectionData);
   IO.mapOptional("Relocations", Sec.Relocations);
 }
 
+static void auxSymMapping(IO &IO, XCOFFYAML::CsectAuxEnt &AuxSym, bool Is64) {
+  IO.mapOptional("ParameterHashIndex", AuxSym.ParameterHashIndex);
+  IO.mapOptional("TypeChkSectNum", AuxSym.TypeChkSectNum);
+  IO.mapOptional("SymbolAlignmentAndType", AuxSym.SymbolAlignmentAndType);
+  IO.mapOptional("StorageMappingClass", AuxSym.StorageMappingClass);
+  if (Is64) {
+    IO.mapOptional("SectionOrLengthLo", AuxSym.SectionOrLengthLo);
+    IO.mapOptional("SectionOrLengthHi", AuxSym.SectionOrLengthHi);
+  } else {
+    IO.mapOptional("SectionOrLength", AuxSym.SectionOrLength);
+    IO.mapOptional("StabInfoIndex", AuxSym.StabInfoIndex);
+    IO.mapOptional("StabSectNum", AuxSym.StabSectNum);
+  }
+}
+
+static void auxSymMapping(IO &IO, XCOFFYAML::FileAuxEnt &AuxSym) {
+  IO.mapOptional("FileNameOrString", AuxSym.FileNameOrString);
+  IO.mapOptional("FileStringType", AuxSym.FileStringType);
+}
+
+static void auxSymMapping(IO &IO, XCOFFYAML::BlockAuxEnt &AuxSym, bool Is64) {
+  if (Is64) {
+    IO.mapOptional("LineNum", AuxSym.LineNum);
+  } else {
+    IO.mapOptional("LineNumHi", AuxSym.LineNumHi);
+    IO.mapOptional("LineNumLo", AuxSym.LineNumLo);
+  }
+}
+
+static void auxSymMapping(IO &IO, XCOFFYAML::FunctionAuxEnt &AuxSym,
+                          bool Is64) {
+  if (!Is64)
+    IO.mapOptional("OffsetToExceptionTbl", AuxSym.OffsetToExceptionTbl);
+  IO.mapOptional("SizeOfFunction", AuxSym.SizeOfFunction);
+  IO.mapOptional("SymIdxOfNextBeyond", AuxSym.SymIdxOfNextBeyond);
+  IO.mapOptional("PtrToLineNum", AuxSym.PtrToLineNum);
+}
+
+static void auxSymMapping(IO &IO, XCOFFYAML::ExcpetionAuxEnt &AuxSym) {
+  IO.mapOptional("OffsetToExceptionTbl", AuxSym.OffsetToExceptionTbl);
+  IO.mapOptional("SizeOfFunction", AuxSym.SizeOfFunction);
+  IO.mapOptional("SymIdxOfNextBeyond", AuxSym.SymIdxOfNextBeyond);
+}
+
+static void auxSymMapping(IO &IO, XCOFFYAML::SectAuxEntForDWARF &AuxSym) {
+  IO.mapOptional("LengthOfSectionPortion", AuxSym.LengthOfSectionPortion);
+  IO.mapOptional("NumberOfRelocEnt", AuxSym.NumberOfRelocEnt);
+}
+
+static void auxSymMapping(IO &IO, XCOFFYAML::SectAuxEntForStat &AuxSym) {
+  IO.mapOptional("SectionLength", AuxSym.SectionLength);
+  IO.mapOptional("NumberOfRelocEnt", AuxSym.NumberOfRelocEnt);
+  IO.mapOptional("NumberOfLineNum", AuxSym.NumberOfLineNum);
+}
+
+void MappingTraits<std::unique_ptr<XCOFFYAML::AuxSymbolEnt>>::mapping(
+    IO &IO, std::unique_ptr<XCOFFYAML::AuxSymbolEnt> &AuxSym) {
+  assert(!IO.outputting() && "We don't dump aux symbols currently.");
+  const bool Is64 =
+      static_cast<XCOFFYAML::Object *>(IO.getContext())->Header.Magic ==
+      (llvm::yaml::Hex16)XCOFF::XCOFF64;
+  XCOFFYAML::AuxSymbolType AuxType;
+  IO.mapRequired("Type", AuxType);
+  switch (AuxType) {
+  case XCOFFYAML::AUX_EXCEPT:
+    if (!Is64)
+      IO.setError("an auxiliary symbol of type AUX_EXCEPT cannot be defined in "
+                  "XCOFF32");
+    AuxSym.reset(new XCOFFYAML::ExcpetionAuxEnt());
+    auxSymMapping(IO, *cast<XCOFFYAML::ExcpetionAuxEnt>(AuxSym.get()));
+    break;
+  case XCOFFYAML::AUX_FCN:
+    AuxSym.reset(new XCOFFYAML::FunctionAuxEnt());
+    auxSymMapping(IO, *cast<XCOFFYAML::FunctionAuxEnt>(AuxSym.get()), Is64);
+    break;
+  case XCOFFYAML::AUX_SYM:
+    AuxSym.reset(new XCOFFYAML::BlockAuxEnt());
+    auxSymMapping(IO, *cast<XCOFFYAML::BlockAuxEnt>(AuxSym.get()), Is64);
+    break;
+  case XCOFFYAML::AUX_FILE:
+    AuxSym.reset(new XCOFFYAML::FileAuxEnt());
+    auxSymMapping(IO, *cast<XCOFFYAML::FileAuxEnt>(AuxSym.get()));
+    break;
+  case XCOFFYAML::AUX_CSECT:
+    AuxSym.reset(new XCOFFYAML::CsectAuxEnt());
+    auxSymMapping(IO, *cast<XCOFFYAML::CsectAuxEnt>(AuxSym.get()), Is64);
+    break;
+  case XCOFFYAML::AUX_SECT:
+    AuxSym.reset(new XCOFFYAML::SectAuxEntForDWARF());
+    auxSymMapping(IO, *cast<XCOFFYAML::SectAuxEntForDWARF>(AuxSym.get()));
+    break;
+  case XCOFFYAML::AUX_STAT:
+    if (Is64)
+      IO.setError(
+          "an auxiliary symbol of type AUX_STAT cannot be defined in XCOFF64");
+    AuxSym.reset(new XCOFFYAML::SectAuxEntForStat());
+    auxSymMapping(IO, *cast<XCOFFYAML::SectAuxEntForStat>(AuxSym.get()));
+    break;
+  }
+}
+
 void MappingTraits<XCOFFYAML::Symbol>::mapping(IO &IO, XCOFFYAML::Symbol &S) {
   IO.mapOptional("Name", S.SymbolName);
   IO.mapOptional("Value", S.Value);
   IO.mapOptional("Section", S.SectionName);
   IO.mapOptional("SectionIndex", S.SectionIndex);
   IO.mapOptional("Type", S.Type);
   IO.mapOptional("StorageClass", S.StorageClass);
   IO.mapOptional("NumberOfAuxEntries", S.NumberOfAuxEntries);
+  if (!IO.outputting())
+    IO.mapOptional("AuxEntries", S.AuxEntries);
 }
 
 void MappingTraits<XCOFFYAML::StringTable>::mapping(IO &IO, XCOFFYAML::StringTable &Str) {
   IO.mapOptional("ContentSize", Str.ContentSize);
   IO.mapOptional("Length", Str.Length);
   IO.mapOptional("Strings", Str.Strings);
   IO.mapOptional("RawContent", Str.RawContent);
 }
 
 void MappingTraits<XCOFFYAML::Object>::mapping(IO &IO, XCOFFYAML::Object &Obj) {
+  IO.setContext(&Obj);
   IO.mapTag("!XCOFF", true);
   IO.mapRequired("FileHeader", Obj.Header);
   IO.mapOptional("AuxiliaryHeader", Obj.AuxHeader);
   IO.mapOptional("Sections", Obj.Sections);
   IO.mapOptional("Symbols", Obj.Symbols);
   IO.mapOptional("StringTable", Obj.StrTbl);
+  IO.setContext(nullptr);
 }
 
 } // namespace yaml
 } // namespace llvm

llvm/test/tools/yaml2obj/XCOFF/aux-symbols.yaml

+## Check that we are able to dump auxiliary symbols.
+## 1. We can use default values for the fields of auxiliary symbols.
+## 2. We can explicitly specify all fields for auxiliary symbols.
+
+## Case1: check the default behaviour in XCOFF32.
+# RUN: yaml2obj %s --docnum=1 -o %t1
+# RUN: llvm-readobj --syms %t1 | FileCheck %s --check-prefix=DEFAULT32
+
+# DEFAULT32:     Symbols [
+# DEFAULT32-NEXT:   Symbol {
+# DEFAULT32-NEXT:     Index: 0
+# DEFAULT32-NEXT:     Name: aux_fcn_csect
+# DEFAULT32-NEXT:     Value (RelocatableAddress): 0x0
+# DEFAULT32-NEXT:     Section: N_UNDEF
+# DEFAULT32-NEXT:     Type: 0x20
+# DEFAULT32-NEXT:     StorageClass: C_EXT (0x2)
+# DEFAULT32-NEXT:     NumberOfAuxEntries: 2
+# DEFAULT32-NEXT:     Function Auxiliary Entry {
+# DEFAULT32-NEXT:       Index: 1
+# DEFAULT32-NEXT:       OffsetToExceptionTable: 0x0
+# DEFAULT32-NEXT:       SizeOfFunction: 0x0
+# DEFAULT32-NEXT:       PointerToLineNum: 0x0
+# DEFAULT32-NEXT:       SymbolIndexOfNextBeyond: 0
+# DEFAULT32-NEXT:     }
+# DEFAULT32-NEXT:     CSECT Auxiliary Entry {
+# DEFAULT32-NEXT:       Index: 2
+# DEFAULT32-NEXT:       SectionLen: 0
+# DEFAULT32-NEXT:       ParameterHashIndex: 0x0
+# DEFAULT32-NEXT:       TypeChkSectNum: 0x0
+# DEFAULT32-NEXT:       SymbolAlignmentLog2: 0
+# DEFAULT32-NEXT:       SymbolType: XTY_ER (0x0)
+# DEFAULT32-NEXT:       StorageMappingClass: XMC_PR (0x0)
+# DEFAULT32-NEXT:       StabInfoIndex: 0x0
+# DEFAULT32-NEXT:       StabSectNum: 0x0
+# DEFAULT32-NEXT:     }
+# DEFAULT32-NEXT:   }
+# DEFAULT32-NEXT:   Symbol {
+# DEFAULT32-NEXT:     Index: 3
+# DEFAULT32-NEXT:     Name: aux_stat
+# DEFAULT32-NEXT:     Value (RelocatableAddress): 0x0
+# DEFAULT32-NEXT:     Section: N_UNDEF
+# DEFAULT32-NEXT:     Type: 0x0
+# DEFAULT32-NEXT:     StorageClass: C_STAT (0x3)
+# DEFAULT32-NEXT:     NumberOfAuxEntries: 1
+# DEFAULT32-NEXT:     Sect Auxiliary Entry For Stat {
+# DEFAULT32-NEXT:       Index: 4
+# DEFAULT32-NEXT:       SectionLength: 0
+# DEFAULT32-NEXT:       NumberOfRelocEnt: 0
+# DEFAULT32-NEXT:       NumberOfLineNum: 0
+# DEFAULT32-NEXT:     }
+# DEFAULT32-NEXT:   }
+# DEFAULT32-NEXT:   Symbol {
+# DEFAULT32-NEXT:     Index: 5
+# DEFAULT32-NEXT:     Name: aux_sym
+# DEFAULT32-NEXT:     Value (RelocatableAddress): 0x0
+# DEFAULT32-NEXT:     Section: N_UNDEF
+# DEFAULT32-NEXT:     Type: 0x0
+# DEFAULT32-NEXT:     StorageClass: C_BLOCK (0x64)
+# DEFAULT32-NEXT:     NumberOfAuxEntries: 1
+# DEFAULT32-NEXT:     Block Auxiliary Entry {
+# DEFAULT32-NEXT:       Index: 6
+# DEFAULT32-NEXT:       LineNumber (High 2 Bytes): 0x0
+# DEFAULT32-NEXT:       LineNumber (Low 2 Bytes): 0x0
+# DEFAULT32-NEXT:     }
+# DEFAULT32-NEXT:   }
+# DEFAULT32-NEXT:   Symbol {
+# DEFAULT32-NEXT:     Index: 7
+# DEFAULT32-NEXT:     Name: aux_file
+# DEFAULT32-NEXT:     Value (SymbolTableIndex): 0x0
+# DEFAULT32-NEXT:     Section: N_UNDEF
+# DEFAULT32-NEXT:     Source Language ID: TB_C (0x0)
+# DEFAULT32-NEXT:     CPU Version ID: 0x0
+# DEFAULT32-NEXT:     StorageClass: C_FILE (0x67)
+# DEFAULT32-NEXT:     NumberOfAuxEntries: 1
+# DEFAULT32-NEXT:     File Auxiliary Entry {
+# DEFAULT32-NEXT:       Index: 8
+# DEFAULT32-NEXT:       Name: 
+# DEFAULT32-NEXT:       Type: XFT_FN (0x0)
+# DEFAULT32-NEXT:     }
+# DEFAULT32-NEXT:   }
+# DEFAULT32-NEXT:   Symbol {
+# DEFAULT32-NEXT:     Index: 9
+# DEFAULT32-NEXT:     Name: aux_sect
+# DEFAULT32-NEXT:     Value (OffsetInDWARF): 0x0
+# DEFAULT32-NEXT:     Section: N_UNDEF
+# DEFAULT32-NEXT:     Type: 0x0
+# DEFAULT32-NEXT:     StorageClass: C_DWARF (0x70)
+# DEFAULT32-NEXT:     NumberOfAuxEntries: 1
+# DEFAULT32-NEXT:     Sect Auxiliary Entry For DWARF {
+# DEFAULT32-NEXT:       Index: 10
+# DEFAULT32-NEXT:       LengthOfSectionPortion: 0x0
+# DEFAULT32-NEXT:       NumberOfRelocEntries: 0
+# DEFAULT32-NEXT:     }
+# DEFAULT32-NEXT:   }
+# DEFAULT32-NEXT: ]
+
+--- !XCOFF
+FileHeader:
+  MagicNumber: 0x1DF
+Symbols:
+  - Name:               aux_fcn_csect
+    StorageClass:       C_EXT
+    Type:               0x20
+    AuxEntries:
+      - Type:                 AUX_FCN
+        OffsetToExceptionTbl: [[OFFTOEXP=<none>]]
+        SizeOfFunction:       [[SIZEOFFUN=<none>]]
+        SymIdxOfNextBeyond:   [[SYMIDXOFNEXT=<none>]]
+        PtrToLineNum:         [[PTRTOLINE=<none>]]
+      - Type:                   AUX_CSECT
+        ParameterHashIndex:     [[HASHIDX=<none>]]
+        TypeChkSectNum:         [[TYPECHKNUM=<none>]]
+        SymbolAlignmentAndType: [[SYMALIGN=<none>]]
+        StorageMappingClass:    [[STORMAPCLASS=<none>]]
+        SectionOrLength:        [[SECTORLEN=<none>]]
+        StabInfoIndex:          [[STABIDX=<none>]]
+        StabSectNum:            [[STABNUM=<none>]]
+  - Name:               aux_stat
+    StorageClass:       C_STAT
+    AuxEntries:
+      - Type:             AUX_STAT
+        SectionLength:    [[SECTLEN=<none>]]
+        NumberOfRelocEnt: [[NUMOFREL=<none>]]
+        NumberOfLineNum:  [[NUMOFLINE=<none>]]
+  - Name:               aux_sym
+    StorageClass:       C_BLOCK
+    AuxEntries:
+      - Type:       AUX_SYM
+        LineNumHi:  [[LINEHI=<none>]]
+        LineNumLo:  [[LINELO=<none>]]
+  - Name:               aux_file
+    StorageClass:       C_FILE
+    AuxEntries:
+      - Type:             AUX_FILE
+        FileNameOrString: [[FILENAME=<none>]]
+        FileStringType:   [[FILETYPE=<none>]]
+  - Name:               aux_sect
+    StorageClass:       C_DWARF
+    AuxEntries:
+      - Type:                   AUX_SECT
+        LengthOfSectionPortion: [[LENOFSEC=<none>]]
+        NumberOfRelocEnt:       [[NUMOFRELOC=<none>]]
+
+## Case2: check the non-default behaviour in XCOFF32.
+# RUN: yaml2obj %s --docnum=1 -o %t2 -DOFFTOEXP=2 -DSIZEOFFUN=3 \
+# RUN:   -DSYMIDXOFNEXT=4 -DPTRTOLINE=5 -DHASHIDX=2 -DTYPECHKNUM=3 \
+# RUN:   -DSYMALIGN=4 -DSTORMAPCLASS=XMC_RO -DSECTORLEN=6 -DSTABIDX=7 \
+# RUN:   -DSTABNUM=8 -DSECTLEN=2 -DNUMOFREL=3 -DNUMOFLINE=4 \
+# RUN:   -DLINEHI=2 -DLINELO=3 -DFILENAME='fname' -DFILETYPE=XFT_CD \
+# RUN:   -DLENOFSEC=2 -DNUMOFRELOC=3
+# RUN: llvm-readobj --syms %t2 | FileCheck %s --check-prefix=NON-DEFAULT32
+
+# NON-DEFAULT32:      Symbols [
+# NON-DEFAULT32-NEXT:   Symbol {
+# NON-DEFAULT32-NEXT:     Index: 0
+# NON-DEFAULT32-NEXT:     Name: aux_fcn_csect
+# NON-DEFAULT32-NEXT:     Value (RelocatableAddress): 0x0
+# NON-DEFAULT32-NEXT:     Section: N_UNDEF
+# NON-DEFAULT32-NEXT:     Type: 0x20
+# NON-DEFAULT32-NEXT:     StorageClass: C_EXT (0x2)
+# NON-DEFAULT32-NEXT:     NumberOfAuxEntries: 2
+# NON-DEFAULT32-NEXT:     Function Auxiliary Entry {
+# NON-DEFAULT32-NEXT:       Index: 1
+# NON-DEFAULT32-NEXT:       OffsetToExceptionTable: 0x2
+# NON-DEFAULT32-NEXT:       SizeOfFunction: 0x3
+# NON-DEFAULT32-NEXT:       PointerToLineNum: 0x5
+# NON-DEFAULT32-NEXT:       SymbolIndexOfNextBeyond: 4
+# NON-DEFAULT32-NEXT:     }
+# NON-DEFAULT32-NEXT:     CSECT Auxiliary Entry {
+# NON-DEFAULT32-NEXT:       Index: 2
+# NON-DEFAULT32-NEXT:       SectionLen: 6
+# NON-DEFAULT32-NEXT:       ParameterHashIndex: 0x2
+# NON-DEFAULT32-NEXT:       TypeChkSectNum: 0x3
+# NON-DEFAULT32-NEXT:       SymbolAlignmentLog2: 0
+# NON-DEFAULT32-NEXT:       SymbolType: 0x4
+# NON-DEFAULT32-NEXT:       StorageMappingClass: XMC_RO (0x1)
+# NON-DEFAULT32-NEXT:       StabInfoIndex: 0x7
+# NON-DEFAULT32-NEXT:       StabSectNum: 0x8
+# NON-DEFAULT32-NEXT:     }
+# NON-DEFAULT32-NEXT:   }
+# NON-DEFAULT32-NEXT:   Symbol {
+# NON-DEFAULT32-NEXT:     Index: 3
+# NON-DEFAULT32-NEXT:     Name: aux_stat
+# NON-DEFAULT32-NEXT:     Value (RelocatableAddress): 0x0
+# NON-DEFAULT32-NEXT:     Section: N_UNDEF
+# NON-DEFAULT32-NEXT:     Type: 0x0
+# NON-DEFAULT32-NEXT:     StorageClass: C_STAT (0x3)
+# NON-DEFAULT32-NEXT:     NumberOfAuxEntries: 1
+# NON-DEFAULT32-NEXT:     Sect Auxiliary Entry For Stat {
+# NON-DEFAULT32-NEXT:       Index: 4
+# NON-DEFAULT32-NEXT:       SectionLength: 2
+# NON-DEFAULT32-NEXT:       NumberOfRelocEnt: 3
+# NON-DEFAULT32-NEXT:       NumberOfLineNum: 4
+# NON-DEFAULT32-NEXT:     }
+# NON-DEFAULT32-NEXT:   }
+# NON-DEFAULT32-NEXT:   Symbol {
+# NON-DEFAULT32-NEXT:     Index: 5
+# NON-DEFAULT32-NEXT:     Name: aux_sym
+# NON-DEFAULT32-NEXT:     Value (RelocatableAddress): 0x0
+# NON-DEFAULT32-NEXT:     Section: N_UNDEF
+# NON-DEFAULT32-NEXT:     Type: 0x0
+# NON-DEFAULT32-NEXT:     StorageClass: C_BLOCK (0x64)
+# NON-DEFAULT32-NEXT:     NumberOfAuxEntries: 1
+# NON-DEFAULT32-NEXT:     Block Auxiliary Entry {
+# NON-DEFAULT32-NEXT:       Index: 6
+# NON-DEFAULT32-NEXT:       LineNumber (High 2 Bytes): 0x2
+# NON-DEFAULT32-NEXT:       LineNumber (Low 2 Bytes): 0x3
+# NON-DEFAULT32-NEXT:     }
+# NON-DEFAULT32-NEXT:   }
+# NON-DEFAULT32-NEXT:   Symbol {
+# NON-DEFAULT32-NEXT:     Index: 7
+# NON-DEFAULT32-NEXT:     Name: aux_file
+# NON-DEFAULT32-NEXT:     Value (SymbolTableIndex): 0x0
+# NON-DEFAULT32-NEXT:     Section: N_UNDEF
+# NON-DEFAULT32-NEXT:     Source Language ID: TB_C (0x0)
+# NON-DEFAULT32-NEXT:     CPU Version ID: 0x0
+# NON-DEFAULT32-NEXT:     StorageClass: C_FILE (0x67)
+# NON-DEFAULT32-NEXT:     NumberOfAuxEntries: 1
+# NON-DEFAULT32-NEXT:     File Auxiliary Entry {
+# NON-DEFAULT32-NEXT:       Index: 8
+# NON-DEFAULT32-NEXT:       Name: fname
+# NON-DEFAULT32-NEXT:       Type: XFT_CD (0x80)
+# NON-DEFAULT32-NEXT:     }
+# NON-DEFAULT32-NEXT:   }
+# NON-DEFAULT32-NEXT:   Symbol {
+# NON-DEFAULT32-NEXT:     Index: 9
+# NON-DEFAULT32-NEXT:     Name: aux_sect
+# NON-DEFAULT32-NEXT:     Value (OffsetInDWARF): 0x0
+# NON-DEFAULT32-NEXT:     Section: N_UNDEF
+# NON-DEFAULT32-NEXT:     Type: 0x0
+# NON-DEFAULT32-NEXT:     StorageClass: C_DWARF (0x70)
+# NON-DEFAULT32-NEXT:     NumberOfAuxEntries: 1
+# NON-DEFAULT32-NEXT:     Sect Auxiliary Entry For DWARF {
+# NON-DEFAULT32-NEXT:       Index: 10
+# NON-DEFAULT32-NEXT:       LengthOfSectionPortion: 0x2
+# NON-DEFAULT32-NEXT:       NumberOfRelocEntries: 3
+# NON-DEFAULT32-NEXT:     }
+# NON-DEFAULT32-NEXT:   }
+# NON-DEFAULT32-NEXT: ]
+
+## Case3: check the default behaviour in XCOFF64.
+# RUN: yaml2obj %s --docnum=2 -o %t3
+# RUN: llvm-readobj --syms %t3 | FileCheck %s --check-prefix=DEFAULT64
+
+# DEFAULT64:      Symbols [
+# DEFAULT64-NEXT:   Symbol {
+# DEFAULT64-NEXT:     Index: 0
+# DEFAULT64-NEXT:     Name: aux_except_fcn_csect
+# DEFAULT64-NEXT:     Value (RelocatableAddress): 0x0
+# DEFAULT64-NEXT:     Section: N_UNDEF
+# DEFAULT64-NEXT:     Type: 0x20
+# DEFAULT64-NEXT:     StorageClass: C_EXT (0x2)
+# DEFAULT64-NEXT:     NumberOfAuxEntries: 3
+# DEFAULT64-NEXT:     Exception Auxiliary Entry {
+# DEFAULT64-NEXT:       Index: 1
+# DEFAULT64-NEXT:       OffsetToExceptionTable: 0x0
+# DEFAULT64-NEXT:       SizeOfFunction: 0x0
+# DEFAULT64-NEXT:       SymbolIndexOfNextBeyond: 0
+# DEFAULT64-NEXT:       Auxiliary Type: AUX_EXCEPT (0xFF)
+# DEFAULT64-NEXT:     }
+# DEFAULT64-NEXT:     Function Auxiliary Entry {
+# DEFAULT64-NEXT:       Index: 2
+# DEFAULT64-NEXT:       SizeOfFunction: 0x0
+# DEFAULT64-NEXT:       PointerToLineNum: 0x0
+# DEFAULT64-NEXT:       SymbolIndexOfNextBeyond: 0
+# DEFAULT64-NEXT:       Auxiliary Type: AUX_FCN (0xFE)
+# DEFAULT64-NEXT:     }
+# DEFAULT64-NEXT:     CSECT Auxiliary Entry {
+# DEFAULT64-NEXT:       Index: 3
+# DEFAULT64-NEXT:       SectionLen: 0
+# DEFAULT64-NEXT:       ParameterHashIndex: 0x0
+# DEFAULT64-NEXT:       TypeChkSectNum: 0x0
+# DEFAULT64-NEXT:       SymbolAlignmentLog2: 0
+# DEFAULT64-NEXT:       SymbolType: XTY_ER (0x0)
+# DEFAULT64-NEXT:       StorageMappingClass: XMC_PR (0x0)
+# DEFAULT64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+# DEFAULT64-NEXT:     }
+# DEFAULT64-NEXT:   }
+# DEFAULT64-NEXT:   Symbol {
+# DEFAULT64-NEXT:     Index: 4
+# DEFAULT64-NEXT:     Name: aux_sym
+# DEFAULT64-NEXT:     Value (RelocatableAddress): 0x0
+# DEFAULT64-NEXT:     Section: N_UNDEF
+# DEFAULT64-NEXT:     Type: 0x0
+# DEFAULT64-NEXT:     StorageClass: C_BLOCK (0x64)
+# DEFAULT64-NEXT:     NumberOfAuxEntries: 1
+# DEFAULT64-NEXT:     Block Auxiliary Entry {
+# DEFAULT64-NEXT:       Index: 5
+# DEFAULT64-NEXT:       LineNumber: 0x0
+# DEFAULT64-NEXT:       Auxiliary Type: AUX_SYM (0xFD)
+# DEFAULT64-NEXT:     }
+# DEFAULT64-NEXT:   }
+# DEFAULT64-NEXT:   Symbol {
+# DEFAULT64-NEXT:     Index: 6
+# DEFAULT64-NEXT:     Name: aux_file
+# DEFAULT64-NEXT:     Value (SymbolTableIndex): 0x0
+# DEFAULT64-NEXT:     Section: N_UNDEF
+# DEFAULT64-NEXT:     Source Language ID: TB_C (0x0)
+# DEFAULT64-NEXT:     CPU Version ID: 0x0
+# DEFAULT64-NEXT:     StorageClass: C_FILE (0x67)
+# DEFAULT64-NEXT:     NumberOfAuxEntries: 1
+# DEFAULT64-NEXT:     File Auxiliary Entry {
+# DEFAULT64-NEXT:       Index: 7
+# DEFAULT64-NEXT:       Name: 
+# DEFAULT64-NEXT:       Type: XFT_FN (0x0)
+# DEFAULT64-NEXT:       Auxiliary Type: AUX_FILE (0xFC)
+# DEFAULT64-NEXT:     }
+# DEFAULT64-NEXT:   }
+# DEFAULT64-NEXT:   Symbol {
+# DEFAULT64-NEXT:     Index: 8
+# DEFAULT64-NEXT:     Name: aux_sect
+# DEFAULT64-NEXT:     Value (OffsetInDWARF): 0x0
+# DEFAULT64-NEXT:     Section: N_UNDEF
+# DEFAULT64-NEXT:     Type: 0x0
+# DEFAULT64-NEXT:     StorageClass: C_DWARF (0x70)
+# DEFAULT64-NEXT:     NumberOfAuxEntries: 1
+# DEFAULT64-NEXT:     Sect Auxiliary Entry For DWARF {
+# DEFAULT64-NEXT:       Index: 9
+# DEFAULT64-NEXT:       LengthOfSectionPortion: 0x0
+# DEFAULT64-NEXT:       NumberOfRelocEntries: 0
+# DEFAULT64-NEXT:       Auxiliary Type: AUX_SECT (0xFA)
+# DEFAULT64-NEXT:     }
+# DEFAULT64-NEXT:   }
+# DEFAULT64-NEXT: ]
+
+--- !XCOFF
+FileHeader:
+  MagicNumber: 0x1F7
+Symbols:
+  - Name:               aux_except_fcn_csect
+    StorageClass:       C_EXT
+    Type:               0x20
+    AuxEntries:
+      - Type:                 AUX_EXCEPT
+        OffsetToExceptionTbl: [[OFFTOEXP=<none>]]
+        SizeOfFunction:       [[SIZEOFFUN=<none>]]
+        SymIdxOfNextBeyond:   [[SYMIDXOFNEXT=<none>]]
+      - Type:               AUX_FCN
+        SizeOfFunction:     [[SIZEOFFUN2=<none>]]
+        SymIdxOfNextBeyond: [[SYMIDXOFNEXT2=<none>]]
+        PtrToLineNum:       [[PTRTOLINE=<none>]]
+      - Type:                   AUX_CSECT
+        ParameterHashIndex:     [[HASHIDX=<none>]]
+        TypeChkSectNum:         [[TYPECHKNUM=<none>]]
+        SymbolAlignmentAndType: [[SYMALIGN=<none>]]
+        StorageMappingClass:    [[STORMAPCLASS=<none>]]
+        SectionOrLengthLo:      [[SECTLENLO=<none>]]
+        SectionOrLengthHi:      [[SECTLENHI=<none>]]
+  - Name:               aux_sym
+    StorageClass:       C_BLOCK
+    AuxEntries:
+      - Type:    AUX_SYM
+        LineNum: [[LINENUM=<none>]]
+  - Name:               aux_file
+    StorageClass:       C_FILE
+    AuxEntries:
+      - Type:             AUX_FILE
+        FileNameOrString: [[FILENAME=<none>]]
+        FileStringType:   [[FILETYPE=<none>]]
+  - Name:               aux_sect
+    StorageClass:       C_DWARF
+    AuxEntries:
+      - Type:                   AUX_SECT
+        LengthOfSectionPortion: [[LENOFSEC=<none>]]
+        NumberOfRelocEnt:       [[NUMOFRELOC=<none>]]
+
+## Case4: check the non-default behaviour in XCOFF64.
+# RUN: yaml2obj %s --docnum=2 -o %t4 -DOFFTOEXP=2 -DSIZEOFFUN=3 \
+# RUN:   -DSYMIDXOFNEXT=4 -DSIZEOFFUN2=2 -DSYMIDXOFNEXT2=3 -DPTRTOLINE=4 \
+# RUN:   -DHASHIDX=2 -DTYPECHKNUM=3 -DSYMALIGN=4 -DSTORMAPCLASS=XMC_RO \
+# RUN:   -DSECTLENLO=5 -DSECTLENHI=1 -DLINENUM=2 -DFILENAME='fname' \
+# RUN:   -DFILETYPE=XFT_CD -DLENOFSEC=2 -DNUMOFRELOC=3
+# RUN: llvm-readobj --syms %t4 | FileCheck %s --check-prefix=NON-DEFAULT64
+
+# NON-DEFAULT64:      Symbols [
+# NON-DEFAULT64-NEXT:   Symbol {
+# NON-DEFAULT64-NEXT:     Index: 0
+# NON-DEFAULT64-NEXT:     Name: aux_except_fcn_csect
+# NON-DEFAULT64-NEXT:     Value (RelocatableAddress): 0x0
+# NON-DEFAULT64-NEXT:     Section: N_UNDEF
+# NON-DEFAULT64-NEXT:     Type: 0x20
+# NON-DEFAULT64-NEXT:     StorageClass: C_EXT (0x2)
+# NON-DEFAULT64-NEXT:     NumberOfAuxEntries: 3
+# NON-DEFAULT64-NEXT:     Exception Auxiliary Entry {
+# NON-DEFAULT64-NEXT:       Index: 1
+# NON-DEFAULT64-NEXT:       OffsetToExceptionTable: 0x2
+# NON-DEFAULT64-NEXT:       SizeOfFunction: 0x3
+# NON-DEFAULT64-NEXT:       SymbolIndexOfNextBeyond: 4
+# NON-DEFAULT64-NEXT:       Auxiliary Type: AUX_EXCEPT (0xFF)
+# NON-DEFAULT64-NEXT:     }
+# NON-DEFAULT64-NEXT:     Function Auxiliary Entry {
+# NON-DEFAULT64-NEXT:       Index: 2
+# NON-DEFAULT64-NEXT:       SizeOfFunction: 0x2
+# NON-DEFAULT64-NEXT:       PointerToLineNum: 0x4
+# NON-DEFAULT64-NEXT:       SymbolIndexOfNextBeyond: 3
+# NON-DEFAULT64-NEXT:       Auxiliary Type: AUX_FCN (0xFE)
+# NON-DEFAULT64-NEXT:     }
+# NON-DEFAULT64-NEXT:     CSECT Auxiliary Entry {
+# NON-DEFAULT64-NEXT:       Index: 3
+# NON-DEFAULT64-NEXT:       SectionLen: 4294967301
+# NON-DEFAULT64-NEXT:       ParameterHashIndex: 0x2
+# NON-DEFAULT64-NEXT:       TypeChkSectNum: 0x3
+# NON-DEFAULT64-NEXT:       SymbolAlignmentLog2: 0
+# NON-DEFAULT64-NEXT:       SymbolType: 0x4
+# NON-DEFAULT64-NEXT:       StorageMappingClass: XMC_RO (0x1)
+# NON-DEFAULT64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+# NON-DEFAULT64-NEXT:     }
+# NON-DEFAULT64-NEXT:   }
+# NON-DEFAULT64-NEXT:   Symbol {
+# NON-DEFAULT64-NEXT:     Index: 4
+# NON-DEFAULT64-NEXT:     Name: aux_sym
+# NON-DEFAULT64-NEXT:     Value (RelocatableAddress): 0x0
+# NON-DEFAULT64-NEXT:     Section: N_UNDEF
+# NON-DEFAULT64-NEXT:     Type: 0x0
+# NON-DEFAULT64-NEXT:     StorageClass: C_BLOCK (0x64)
+# NON-DEFAULT64-NEXT:     NumberOfAuxEntries: 1
+# NON-DEFAULT64-NEXT:     Block Auxiliary Entry {
+# NON-DEFAULT64-NEXT:       Index: 5
+# NON-DEFAULT64-NEXT:       LineNumber: 0x2
+# NON-DEFAULT64-NEXT:       Auxiliary Type: AUX_SYM (0xFD)
+# NON-DEFAULT64-NEXT:     }
+# NON-DEFAULT64-NEXT:   }
+# NON-DEFAULT64-NEXT:   Symbol {
+# NON-DEFAULT64-NEXT:     Index: 6
+# NON-DEFAULT64-NEXT:     Name: aux_file
+# NON-DEFAULT64-NEXT:     Value (SymbolTableIndex): 0x0
+# NON-DEFAULT64-NEXT:     Section: N_UNDEF
+# NON-DEFAULT64-NEXT:     Source Language ID: TB_C (0x0)
+# NON-DEFAULT64-NEXT:     CPU Version ID: 0x0
+# NON-DEFAULT64-NEXT:     StorageClass: C_FILE (0x67)
+# NON-DEFAULT64-NEXT:     NumberOfAuxEntries: 1
+# NON-DEFAULT64-NEXT:     File Auxiliary Entry {
+# NON-DEFAULT64-NEXT:       Index: 7
+# NON-DEFAULT64-NEXT:       Name: fname
+# NON-DEFAULT64-NEXT:       Type: XFT_CD (0x80)
+# NON-DEFAULT64-NEXT:       Auxiliary Type: AUX_FILE (0xFC)
+# NON-DEFAULT64-NEXT:     }
+# NON-DEFAULT64-NEXT:   }
+# NON-DEFAULT64-NEXT:   Symbol {
+# NON-DEFAULT64-NEXT:     Index: 8
+# NON-DEFAULT64-NEXT:     Name: aux_sect
+# NON-DEFAULT64-NEXT:     Value (OffsetInDWARF): 0x0
+# NON-DEFAULT64-NEXT:     Section: N_UNDEF
+# NON-DEFAULT64-NEXT:     Type: 0x0
+# NON-DEFAULT64-NEXT:     StorageClass: C_DWARF (0x70)
+# NON-DEFAULT64-NEXT:     NumberOfAuxEntries: 1
+# NON-DEFAULT64-NEXT:     Sect Auxiliary Entry For DWARF {
+# NON-DEFAULT64-NEXT:       Index: 9
+# NON-DEFAULT64-NEXT:       LengthOfSectionPortion: 0x2
+# NON-DEFAULT64-NEXT:       NumberOfRelocEntries: 3
+# NON-DEFAULT64-NEXT:       Auxiliary Type: AUX_SECT (0xFA)
+# NON-DEFAULT64-NEXT:     }
+# NON-DEFAULT64-NEXT:   }
+# NON-DEFAULT64-NEXT: ]
+
+## Case5: a file name longer than 8 bytes in the AUX_FILE symbol
+##        is stored in the string table.
+# RUN: yaml2obj %s --docnum=3 -o %t5
+# RUN: llvm-readobj --syms --string-table %t5 | FileCheck %s \
+# RUN:   --check-prefix=FILENAME
+
+# FILENAME:      Symbols [
+# FILENAME-NEXT:   Symbol {
+# FILENAME-NEXT:     Index: 0
+# FILENAME-NEXT:     Name: aux_file
+# FILENAME-NEXT:     Value (SymbolTableIndex): 0x0
+# FILENAME-NEXT:     Section: N_UNDEF
+# FILENAME-NEXT:     Source Language ID: TB_C (0x0)
+# FILENAME-NEXT:     CPU Version ID: 0x0
+# FILENAME-NEXT:     StorageClass: C_FILE (0x67)
+# FILENAME-NEXT:     NumberOfAuxEntries: 1
+# FILENAME-NEXT:     File Auxiliary Entry {
+# FILENAME-NEXT:       Index: 1
+# FILENAME-NEXT:       Name: fileNameInStringTable
+# FILENAME-NEXT:       Type: XFT_CD (0x80)
+# FILENAME-NEXT:     }
+# FILENAME-NEXT:   }
+# FILENAME-NEXT: ]
+# FILENAME-NEXT: StringTable {
+# FILENAME-NEXT:   Length: 26
+# FILENAME-NEXT:   [     4]   fileNameInStringTable  
+# FILENAME-NEXT: }
+
+--- !XCOFF
+FileHeader:
+  MagicNumber: 0x1DF
+Symbols:
+  - Name:               aux_file
+    StorageClass:       C_FILE
+    NumberOfAuxEntries: 1
+    AuxEntries:
+      - Type:             AUX_FILE
+        FileNameOrString: fileNameInStringTable
+        FileStringType:   XFT_CD
+
+## Case6: show that yaml2obj reports an error when trying to write
+##        the AUX_STAT symbol for XCOFF64.
+# RUN: not yaml2obj %s --docnum=4 -o %t6 2>&1 | FileCheck %s \
+# RUN:   --check-prefix=STAT64
+
+# STAT64: error: an auxiliary symbol of type AUX_STAT cannot be defined in XCOFF64
+
+--- !XCOFF
+FileHeader:
+  MagicNumber: 0x1F7
+Symbols:
+  - StorageClass:       C_STAT
+    NumberOfAuxEntries: 1
+    AuxEntries:
+      - Type: AUX_STAT
+
+## Case7: show that yaml2obj reports an error when trying to write
+##        the AUX_EXCEPT symbol for XCOFF32.
+# RUN: not yaml2obj %s --docnum=5 -o %t7 2>&1 | FileCheck %s \
+# RUN:   --check-prefix=EXCEPT32
+
+# EXCEPT32: error: an auxiliary symbol of type AUX_EXCEPT cannot be defined in XCOFF32
+
+--- !XCOFF
+FileHeader:
+  MagicNumber: 0x1DF
+Symbols:
+  - StorageClass:       C_EXT
+    NumberOfAuxEntries: 1
+    AuxEntries:
+      - Type: AUX_EXCEPT
+
+## Case8: show that yaml2obj reports an error when the specified value
+##        of NumberOfAuxEntries is less than the actual number.
+# RUN: not yaml2obj %s --docnum=6 -o %t8 2>&1 | FileCheck %s \
+# RUN:   --check-prefix=AUXCOUNT
+
+# AUXCOUNT: yaml2obj: error: specified NumberOfAuxEntries 1 is less than the actual number of auxiliary entries 2
+
+--- !XCOFF
+FileHeader:
+  MagicNumber: 0x1DF
+Symbols:
+  - StorageClass:       C_EXT
+    NumberOfAuxEntries: 1
+    AuxEntries:
+      - Type: AUX_FCN
+      - Type: AUX_CSECT
+
+## Case9: pad with zeros when the specified value of NumberOfAuxEntries
+##        is greater than the actual number.
+# RUN: yaml2obj %s --docnum=7 -o %t9
+# RUN: llvm-readobj --syms %t9 | FileCheck %s --check-prefix=AUXNUM
+
+# AUXNUM:      Symbols [
+# AUXNUM-NEXT:   Symbol {
+# AUXNUM-NEXT:     Index: 0
+# AUXNUM-NEXT:     Name: 
+# AUXNUM-NEXT:     Value (SymbolTableIndex): 0x0
+# AUXNUM-NEXT:     Section: N_UNDEF
+# AUXNUM-NEXT:     Source Language ID: TB_C (0x0)
+# AUXNUM-NEXT:     CPU Version ID: 0x0
+# AUXNUM-NEXT:     StorageClass: C_FILE (0x67)
+# AUXNUM-NEXT:     NumberOfAuxEntries: 2
+# AUXNUM-NEXT:     File Auxiliary Entry {
+# AUXNUM-NEXT:       Index: 1
+# AUXNUM-NEXT:       Name: foo
+# AUXNUM-NEXT:       Type: XFT_FN (0x0)
+# AUXNUM-NEXT:     }
+# AUXNUM-NEXT:     File Auxiliary Entry {
+# AUXNUM-NEXT:       Index: 2
+# AUXNUM-NEXT:       Name: 
+# AUXNUM-NEXT:       Type: XFT_FN (0x0)
+# AUXNUM-NEXT:     }
+# AUXNUM-NEXT:   }
+# AUXNUM-NEXT: ]
+
+--- !XCOFF
+FileHeader:
+  MagicNumber: 0x1DF
+Symbols:
+  - StorageClass:       C_FILE
+    NumberOfAuxEntries: 2
+    AuxEntries:
+      - Type: AUX_FILE
+        FileNameOrString: foo

llvm/tools/obj2yaml/xcoff2yaml.cpp

for (const SymbolRef &S : Obj.symbols()) {
     if (!SectionNameRefOrErr)
       return SectionNameRefOrErr.takeError();
 
     Sym.SectionName = SectionNameRefOrErr.get();
 
     Sym.Type = SymbolEntRef.getSymbolType();
     Sym.StorageClass = SymbolEntRef.getStorageClass();
     Sym.NumberOfAuxEntries = SymbolEntRef.getNumberOfAuxEntries();
-    Symbols.push_back(Sym);
+
+    Symbols.push_back(std::move(Sym));
   }
 
   return Error::success();
 }
 
 Error xcoff2yaml(raw_ostream &Out, const object::XCOFFObjectFile &Obj) {
   XCOFFDumper Dumper(Obj);
 
   if (Error E = Dumper.dump())
     return E;
 
   yaml::Output Yout(Out);
   Yout << Dumper.getYAMLObj();
 
   return Error::success();
 }