diff --git a/llvm/include/llvm/ObjectYAML/XCOFFYAML.h b/llvm/include/llvm/ObjectYAML/XCOFFYAML.h
--- a/llvm/include/llvm/ObjectYAML/XCOFFYAML.h
+++ b/llvm/include/llvm/ObjectYAML/XCOFFYAML.h
@@ -82,6 +82,110 @@
   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.
@@ -89,7 +193,8 @@
   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 {
@@ -114,6 +219,7 @@
 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 {
@@ -126,6 +232,18 @@
   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);
 };
@@ -134,6 +252,10 @@
   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);
 };
diff --git a/llvm/lib/ObjectYAML/XCOFFEmitter.cpp b/llvm/lib/ObjectYAML/XCOFFEmitter.cpp
--- a/llvm/lib/ObjectYAML/XCOFFEmitter.cpp
+++ b/llvm/lib/ObjectYAML/XCOFFEmitter.cpp
@@ -47,6 +47,7 @@
   bool initRelocations(uint64_t &CurrentOffset);
   bool initStringTable();
   bool assignAddressesAndIndices();
+
   void writeFileHeader();
   void writeAuxFileHeader();
   void writeSectionHeader();
@@ -55,6 +56,15 @@
   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;
@@ -190,12 +200,23 @@
       }
     }
   } 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();
@@ -216,9 +237,21 @@
   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) {
@@ -491,6 +524,125 @@
   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);
@@ -533,16 +685,25 @@
     }
     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;
diff --git a/llvm/lib/ObjectYAML/XCOFFYAML.cpp b/llvm/lib/ObjectYAML/XCOFFYAML.cpp
--- a/llvm/lib/ObjectYAML/XCOFFYAML.cpp
+++ b/llvm/lib/ObjectYAML/XCOFFYAML.cpp
@@ -19,6 +19,8 @@
 
 Object::Object() { memset(&Header, 0, sizeof(Header)); }
 
+AuxSymbolEnt::~AuxSymbolEnt() = default;
+
 } // namespace XCOFFYAML
 
 namespace yaml {
@@ -98,6 +100,56 @@
 #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)) {}
@@ -173,6 +225,107 @@
   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);
@@ -181,6 +334,8 @@
   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) {
@@ -191,12 +346,14 @@
 }
 
 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
diff --git a/llvm/test/tools/yaml2obj/XCOFF/aux-symbols.yaml b/llvm/test/tools/yaml2obj/XCOFF/aux-symbols.yaml
--- a/llvm/test/tools/yaml2obj/XCOFF/aux-symbols.yaml
+++ b/llvm/test/tools/yaml2obj/XCOFF/aux-symbols.yaml
@@ -0,0 +1,581 @@
+## 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
diff --git a/llvm/tools/obj2yaml/xcoff2yaml.cpp b/llvm/tools/obj2yaml/xcoff2yaml.cpp
--- a/llvm/tools/obj2yaml/xcoff2yaml.cpp
+++ b/llvm/tools/obj2yaml/xcoff2yaml.cpp
@@ -132,7 +132,8 @@
     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();