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
@@ -50,6 +50,105 @@
   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 {
+  Optional<uint32_t> ParameterHashIndex;
+  Optional<uint16_t> TypeChkSectNum;
+  Optional<uint8_t> SymbolAlignmentAndType;
+  Optional<XCOFF::StorageMappingClass> StorageMappingClass;
+  Optional<uint32_t> SectionOrLengthLo;
+  Optional<uint32_t> SectionOrLengthHi;
+  Optional<uint32_t> SectionOrLength;
+  Optional<uint32_t> StabInfoIndex;
+  Optional<uint16_t> StabSectNum;
+
+  CsectAuxEnt() : AuxSymbolEnt(AuxSymbolType::AUX_CSECT) {}
+  static bool classof(const AuxSymbolEnt *S) {
+    return S->Type == AuxSymbolType::AUX_CSECT;
+  }
+};
+
+struct FunctionAuxEnt : AuxSymbolEnt {
+  Optional<uint32_t> OffsetToExceptionTbl;
+  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<uint32_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;
+  }
+};
+
+struct BlockAuxEnt : AuxSymbolEnt {
+  Optional<uint16_t> LineNumHi;
+  Optional<uint16_t> LineNumLo;
+  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;
+  }
+};
+
 struct Symbol {
   StringRef SymbolName;
   llvm::yaml::Hex64 Value; // Symbol value; storage class-dependent.
@@ -57,7 +156,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 {
@@ -81,6 +181,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 {
@@ -93,10 +194,25 @@
   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<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
@@ -46,6 +46,7 @@
   bool initRelocations(uint64_t &CurrentOffset);
   bool initStringTable();
   bool assignAddressesAndIndices();
+
   void writeFileHeader();
   void writeSectionHeader();
   bool writeSectionData();
@@ -53,6 +54,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;
@@ -187,12 +197,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();
@@ -213,9 +234,21 @@
   InitFileHdr.NumberOfSections = Obj.Sections.size();
   InitFileHdr.NumberOfSymTableEntries = Obj.Symbols.size();
 
-  for (const XCOFFYAML::Symbol &YamlSym : Obj.Symbols)
+  for (XCOFFYAML::Symbol &YamlSym : Obj.Symbols) {
+    uint8_t AuxCount = YamlSym.AuxEntries.size();
+    if (YamlSym.NumberOfAuxEntries && *YamlSym.NumberOfAuxEntries < AuxCount) {
+      ErrHandler("specified NumberOfAuxEntries " +
+                 Twine((uint32_t)*YamlSym.NumberOfAuxEntries) +
+                 " is less than the actual number "
+                 "of auxiliary entries " +
+                 Twine((uint32_t)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) {
@@ -364,6 +397,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);
@@ -406,16 +558,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)) {}
@@ -142,6 +194,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("the exception auxiliary symbol table entry is defined in "
+                  "XCOFF64 only");
+    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("the section auxiliary entry for the C_STAT Symbol is "
+                  "defined in XCOFF32 only");
+    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);
@@ -150,6 +303,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) {
@@ -160,11 +315,13 @@
 }
 
 void MappingTraits<XCOFFYAML::Object>::mapping(IO &IO, XCOFFYAML::Object &Obj) {
+  IO.setContext(&Obj);
   IO.mapTag("!XCOFF", true);
   IO.mapRequired("FileHeader", Obj.Header);
   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-defaults.yaml b/llvm/test/tools/yaml2obj/XCOFF/aux-symbols-defaults.yaml
--- a/llvm/test/tools/yaml2obj/XCOFF/aux-symbols-defaults.yaml
+++ b/llvm/test/tools/yaml2obj/XCOFF/aux-symbols-defaults.yaml
@@ -0,0 +1,231 @@
+## Test that yaml2obj sets default values for the fields of auxiliary symbols.
+
+## Check the behaviour in XCOFF32.
+# RUN: yaml2obj %s --docnum=1 -o %t1
+# RUN: llvm-readobj --syms %t1 | FileCheck %s --check-prefix=AUXSYM32
+
+# AUXSYM32:      AddressSize: 32bit
+# AUXSYM32-NEXT: Symbols [
+# AUXSYM32-NEXT:   Symbol {
+# AUXSYM32-NEXT:     Index: 0
+# AUXSYM32-NEXT:     Name: aux_fcn_csect
+# AUXSYM32-NEXT:     Value (RelocatableAddress): 0x0
+# AUXSYM32-NEXT:     Section: N_UNDEF
+# AUXSYM32-NEXT:     Type: 0x20
+# AUXSYM32-NEXT:     StorageClass: C_EXT (0x2)
+# AUXSYM32-NEXT:     NumberOfAuxEntries: 2
+# AUXSYM32-NEXT:     Function Auxiliary Entry {
+# AUXSYM32-NEXT:       Index: 1
+# AUXSYM32-NEXT:       OffsetToExceptionTable: 0x0
+# AUXSYM32-NEXT:       SizeOfFunction: 0x0
+# AUXSYM32-NEXT:       PointerToLineNum: 0x0
+# AUXSYM32-NEXT:       SymbolIndexOfNextBeyond: 0
+# AUXSYM32-NEXT:     }
+# AUXSYM32-NEXT:     CSECT Auxiliary Entry {
+# AUXSYM32-NEXT:       Index: 2
+# AUXSYM32-NEXT:       SectionLen: 0
+# AUXSYM32-NEXT:       ParameterHashIndex: 0x0
+# AUXSYM32-NEXT:       TypeChkSectNum: 0x0
+# AUXSYM32-NEXT:       SymbolAlignmentLog2: 0
+# AUXSYM32-NEXT:       SymbolType: XTY_ER (0x0)
+# AUXSYM32-NEXT:       StorageMappingClass: XMC_PR (0x0)
+# AUXSYM32-NEXT:       StabInfoIndex: 0x0
+# AUXSYM32-NEXT:       StabSectNum: 0x0
+# AUXSYM32-NEXT:     }
+# AUXSYM32-NEXT:   }
+# AUXSYM32-NEXT:   Symbol {
+# AUXSYM32-NEXT:     Index: 3
+# AUXSYM32-NEXT:     Name: aux_stat
+# AUXSYM32-NEXT:     Value (RelocatableAddress): 0x0
+# AUXSYM32-NEXT:     Section: N_UNDEF
+# AUXSYM32-NEXT:     Type: 0x0
+# AUXSYM32-NEXT:     StorageClass: C_STAT (0x3)
+# AUXSYM32-NEXT:     NumberOfAuxEntries: 1
+# AUXSYM32-NEXT:     Sect Auxiliary Entry For Stat {
+# AUXSYM32-NEXT:       Index: 4
+# AUXSYM32-NEXT:       SectionLength: 0
+# AUXSYM32-NEXT:       NumberOfRelocEnt: 0
+# AUXSYM32-NEXT:       NumberOfLineNum: 0
+# AUXSYM32-NEXT:     }
+# AUXSYM32-NEXT:   }
+# AUXSYM32-NEXT:   Symbol {
+# AUXSYM32-NEXT:     Index: 5
+# AUXSYM32-NEXT:     Name: aux_sym
+# AUXSYM32-NEXT:     Value (RelocatableAddress): 0x0
+# AUXSYM32-NEXT:     Section: N_UNDEF
+# AUXSYM32-NEXT:     Type: 0x0
+# AUXSYM32-NEXT:     StorageClass: C_BLOCK (0x64)
+# AUXSYM32-NEXT:     NumberOfAuxEntries: 1
+# AUXSYM32-NEXT:     Block Auxiliary Entry {
+# AUXSYM32-NEXT:       Index: 6
+# AUXSYM32-NEXT:       LineNumber(High 2 Bytes): 0x0
+# AUXSYM32-NEXT:       LineNumber(Low 2 Bytes): 0x0
+# AUXSYM32-NEXT:     }
+# AUXSYM32-NEXT:   }
+# AUXSYM32-NEXT:   Symbol {
+# AUXSYM32-NEXT:     Index: 7
+# AUXSYM32-NEXT:     Name: aux_file
+# AUXSYM32-NEXT:     Value (SymbolTableIndex): 0x0
+# AUXSYM32-NEXT:     Section: N_UNDEF
+# AUXSYM32-NEXT:     Source Language ID: TB_C (0x0)
+# AUXSYM32-NEXT:     CPU Version ID: 0x0
+# AUXSYM32-NEXT:     StorageClass: C_FILE (0x67)
+# AUXSYM32-NEXT:     NumberOfAuxEntries: 1
+# AUXSYM32-NEXT:     File Auxiliary Entry {
+# AUXSYM32-NEXT:       Index: 8
+# AUXSYM32-NEXT:       Name: 
+# AUXSYM32-NEXT:       Type: XFT_FN (0x0)
+# AUXSYM32-NEXT:     }
+# AUXSYM32-NEXT:   }
+# AUXSYM32-NEXT:   Symbol {
+# AUXSYM32-NEXT:     Index: 9
+# AUXSYM32-NEXT:     Name: aux_sect
+# AUXSYM32-NEXT:     Value (OffsetInDWARF): 0x0
+# AUXSYM32-NEXT:     Section: N_UNDEF
+# AUXSYM32-NEXT:     Type: 0x0
+# AUXSYM32-NEXT:     StorageClass: C_DWARF (0x70)
+# AUXSYM32-NEXT:     NumberOfAuxEntries: 1
+# AUXSYM32-NEXT:     Sect Auxiliary Entry For DWARF {
+# AUXSYM32-NEXT:       Index: 10
+# AUXSYM32-NEXT:       LengthOfSectionPortion: 0x0
+# AUXSYM32-NEXT:       NumberOfRelocEntries: 0
+# AUXSYM32-NEXT:     }
+# AUXSYM32-NEXT:   }
+# AUXSYM32-NEXT: ]
+
+--- !XCOFF
+FileHeader:
+  MagicNumber: 0x1DF
+Symbols:
+  - Name:         aux_fcn_csect
+    StorageClass: C_EXT
+    Type:         0x20
+    AuxEntries:
+      - Type: AUX_FCN
+      - Type: AUX_CSECT
+  - Name:         aux_stat
+    StorageClass: C_STAT
+    AuxEntries:
+      - Type: AUX_STAT
+  - Name:         aux_sym
+    StorageClass: C_BLOCK
+    AuxEntries:
+      - Type: AUX_SYM
+  - Name:         aux_file
+    StorageClass: C_FILE
+    AuxEntries:
+      - Type: AUX_FILE
+  - Name:         aux_sect
+    StorageClass: C_DWARF
+    AuxEntries:
+      - Type: AUX_SECT
+
+## Check the behaviour in XCOFF64.
+# RUN: yaml2obj %s --docnum=2 -o %t2
+# RUN: llvm-readobj --syms %t2 | FileCheck %s --check-prefix=AUXSYM64
+
+# AUXSYM64:      AddressSize: 64bit
+# AUXSYM64-NEXT: Symbols [
+# AUXSYM64-NEXT:   Symbol {
+# AUXSYM64-NEXT:     Index: 0
+# AUXSYM64-NEXT:     Name: aux_except_fcn_csect
+# AUXSYM64-NEXT:     Value (RelocatableAddress): 0x0
+# AUXSYM64-NEXT:     Section: N_UNDEF
+# AUXSYM64-NEXT:     Type: 0x20
+# AUXSYM64-NEXT:     StorageClass: C_EXT (0x2)
+# AUXSYM64-NEXT:     NumberOfAuxEntries: 3
+# AUXSYM64-NEXT:     Exception Auxiliary Entry {
+# AUXSYM64-NEXT:       Index: 1
+# AUXSYM64-NEXT:       OffsetToExceptionTable: 0x0
+# AUXSYM64-NEXT:       SizeOfFunction: 0x0
+# AUXSYM64-NEXT:       SymbolIndexOfNextBeyond: 0
+# AUXSYM64-NEXT:       Auxiliary Type: AUX_EXCEPT (0xFF)
+# AUXSYM64-NEXT:     }
+# AUXSYM64-NEXT:     Function Auxiliary Entry {
+# AUXSYM64-NEXT:       Index: 2
+# AUXSYM64-NEXT:       SizeOfFunction: 0x0
+# AUXSYM64-NEXT:       PointerToLineNum: 0x0
+# AUXSYM64-NEXT:       SymbolIndexOfNextBeyond: 0
+# AUXSYM64-NEXT:       Auxiliary Type: AUX_FCN (0xFE)
+# AUXSYM64-NEXT:     }
+# AUXSYM64-NEXT:     CSECT Auxiliary Entry {
+# AUXSYM64-NEXT:       Index: 3
+# AUXSYM64-NEXT:       SectionLen: 0
+# AUXSYM64-NEXT:       ParameterHashIndex: 0x0
+# AUXSYM64-NEXT:       TypeChkSectNum: 0x0
+# AUXSYM64-NEXT:       SymbolAlignmentLog2: 0
+# AUXSYM64-NEXT:       SymbolType: XTY_ER (0x0)
+# AUXSYM64-NEXT:       StorageMappingClass: XMC_PR (0x0)
+# AUXSYM64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+# AUXSYM64-NEXT:     }
+# AUXSYM64-NEXT:   }
+# AUXSYM64-NEXT:   Symbol {
+# AUXSYM64-NEXT:     Index: 4
+# AUXSYM64-NEXT:     Name: aux_sym
+# AUXSYM64-NEXT:     Value (RelocatableAddress): 0x0
+# AUXSYM64-NEXT:     Section: N_UNDEF
+# AUXSYM64-NEXT:     Type: 0x0
+# AUXSYM64-NEXT:     StorageClass: C_BLOCK (0x64)
+# AUXSYM64-NEXT:     NumberOfAuxEntries: 1
+# AUXSYM64-NEXT:     Block Auxiliary Entry {
+# AUXSYM64-NEXT:       Index: 5
+# AUXSYM64-NEXT:       LineNumber: 0x0
+# AUXSYM64-NEXT:       Auxiliary Type: AUX_SYM (0xFD)
+# AUXSYM64-NEXT:     }
+# AUXSYM64-NEXT:   }
+# AUXSYM64-NEXT:   Symbol {
+# AUXSYM64-NEXT:     Index: 6
+# AUXSYM64-NEXT:     Name: aux_file
+# AUXSYM64-NEXT:     Value (SymbolTableIndex): 0x0
+# AUXSYM64-NEXT:     Section: N_UNDEF
+# AUXSYM64-NEXT:     Source Language ID: TB_C (0x0)
+# AUXSYM64-NEXT:     CPU Version ID: 0x0
+# AUXSYM64-NEXT:     StorageClass: C_FILE (0x67)
+# AUXSYM64-NEXT:     NumberOfAuxEntries: 1
+# AUXSYM64-NEXT:     File Auxiliary Entry {
+# AUXSYM64-NEXT:       Index: 7
+# AUXSYM64-NEXT:       Name: 
+# AUXSYM64-NEXT:       Type: XFT_FN (0x0)
+# AUXSYM64-NEXT:       Auxiliary Type: AUX_FILE (0xFC)
+# AUXSYM64-NEXT:     }
+# AUXSYM64-NEXT:   }
+# AUXSYM64-NEXT:   Symbol {
+# AUXSYM64-NEXT:     Index: 8
+# AUXSYM64-NEXT:     Name: aux_sect
+# AUXSYM64-NEXT:     Value (OffsetInDWARF): 0x0
+# AUXSYM64-NEXT:     Section: N_UNDEF
+# AUXSYM64-NEXT:     Type: 0x0
+# AUXSYM64-NEXT:     StorageClass: C_DWARF (0x70)
+# AUXSYM64-NEXT:     NumberOfAuxEntries: 1
+# AUXSYM64-NEXT:     Sect Auxiliary Entry For DWARF {
+# AUXSYM64-NEXT:       Index: 9
+# AUXSYM64-NEXT:       LengthOfSectionPortion: 0x0
+# AUXSYM64-NEXT:       NumberOfRelocEntries: 0
+# AUXSYM64-NEXT:       Auxiliary Type: AUX_SECT (0xFA)
+# AUXSYM64-NEXT:     }
+# AUXSYM64-NEXT:   }
+# AUXSYM64-NEXT: ]
+
+--- !XCOFF
+FileHeader:
+  MagicNumber: 0x1F7
+Symbols:
+  - Name:         aux_except_fcn_csect
+    StorageClass: C_EXT
+    Type:         0x20
+    AuxEntries:
+      - Type: AUX_EXCEPT
+      - Type: AUX_FCN
+      - Type: AUX_CSECT
+  - Name:         aux_sym
+    StorageClass: C_BLOCK
+    AuxEntries:
+      - Type: AUX_SYM
+  - Name:         aux_file
+    StorageClass: C_FILE
+    AuxEntries:
+      - Type: AUX_FILE
+  - Name:         aux_sect
+    StorageClass: C_DWARF
+    AuxEntries:
+      - Type: AUX_SECT
diff --git a/llvm/test/tools/yaml2obj/XCOFF/aux-symbols-full-contents.yaml b/llvm/test/tools/yaml2obj/XCOFF/aux-symbols-full-contents.yaml
--- a/llvm/test/tools/yaml2obj/XCOFF/aux-symbols-full-contents.yaml
+++ b/llvm/test/tools/yaml2obj/XCOFF/aux-symbols-full-contents.yaml
@@ -0,0 +1,359 @@
+## Test that we can explicitly specify all fields for auxiliary symbols.
+
+## Check the behaviour in XCOFF32.
+# RUN: yaml2obj %s --docnum=1 -o %t1
+# RUN: llvm-readobj --syms %t1 | FileCheck %s --check-prefix=AUXSYM32
+
+# AUXSYM32:      AddressSize: 32bit
+# AUXSYM32-NEXT: Symbols [
+# AUXSYM32-NEXT:   Symbol {
+# AUXSYM32-NEXT:     Index: 0
+# AUXSYM32-NEXT:     Name: aux_fcn_csect
+# AUXSYM32-NEXT:     Value (RelocatableAddress): 0x0
+# AUXSYM32-NEXT:     Section: N_UNDEF
+# AUXSYM32-NEXT:     Type: 0x20
+# AUXSYM32-NEXT:     StorageClass: C_EXT (0x2)
+# AUXSYM32-NEXT:     NumberOfAuxEntries: 2
+# AUXSYM32-NEXT:     Function Auxiliary Entry {
+# AUXSYM32-NEXT:       Index: 1
+# AUXSYM32-NEXT:       OffsetToExceptionTable: 0x2
+# AUXSYM32-NEXT:       SizeOfFunction: 0x3
+# AUXSYM32-NEXT:       PointerToLineNum: 0x5
+# AUXSYM32-NEXT:       SymbolIndexOfNextBeyond: 4
+# AUXSYM32-NEXT:     }
+# AUXSYM32-NEXT:     CSECT Auxiliary Entry {
+# AUXSYM32-NEXT:       Index: 2
+# AUXSYM32-NEXT:       SectionLen: 4
+# AUXSYM32-NEXT:       ParameterHashIndex: 0x2
+# AUXSYM32-NEXT:       TypeChkSectNum: 0x3
+# AUXSYM32-NEXT:       SymbolAlignmentLog2: 0
+# AUXSYM32-NEXT:       SymbolType: XTY_SD (0x1)
+# AUXSYM32-NEXT:       StorageMappingClass: XMC_RO (0x1)
+# AUXSYM32-NEXT:       StabInfoIndex: 0x5
+# AUXSYM32-NEXT:       StabSectNum: 0x6
+# AUXSYM32-NEXT:     }
+# AUXSYM32-NEXT:   }
+# AUXSYM32-NEXT:   Symbol {
+# AUXSYM32-NEXT:     Index: 3
+# AUXSYM32-NEXT:     Name: aux_stat
+# AUXSYM32-NEXT:     Value (RelocatableAddress): 0x0
+# AUXSYM32-NEXT:     Section: N_UNDEF
+# AUXSYM32-NEXT:     Type: 0x0
+# AUXSYM32-NEXT:     StorageClass: C_STAT (0x3)
+# AUXSYM32-NEXT:     NumberOfAuxEntries: 1
+# AUXSYM32-NEXT:     Sect Auxiliary Entry For Stat {
+# AUXSYM32-NEXT:       Index: 4
+# AUXSYM32-NEXT:       SectionLength: 2
+# AUXSYM32-NEXT:       NumberOfRelocEnt: 3
+# AUXSYM32-NEXT:       NumberOfLineNum: 4
+# AUXSYM32-NEXT:     }
+# AUXSYM32-NEXT:   }
+# AUXSYM32-NEXT:   Symbol {
+# AUXSYM32-NEXT:     Index: 5
+# AUXSYM32-NEXT:     Name: aux_sym
+# AUXSYM32-NEXT:     Value (RelocatableAddress): 0x0
+# AUXSYM32-NEXT:     Section: N_UNDEF
+# AUXSYM32-NEXT:     Type: 0x0
+# AUXSYM32-NEXT:     StorageClass: C_BLOCK (0x64)
+# AUXSYM32-NEXT:     NumberOfAuxEntries: 1
+# AUXSYM32-NEXT:     Block Auxiliary Entry {
+# AUXSYM32-NEXT:       Index: 6
+# AUXSYM32-NEXT:       LineNumber(High 2 Bytes): 0x2
+# AUXSYM32-NEXT:       LineNumber(Low 2 Bytes): 0x3
+# AUXSYM32-NEXT:     }
+# AUXSYM32-NEXT:   }
+# AUXSYM32-NEXT:   Symbol {
+# AUXSYM32-NEXT:     Index: 7
+# AUXSYM32-NEXT:     Name: aux_file
+# AUXSYM32-NEXT:     Value (SymbolTableIndex): 0x0
+# AUXSYM32-NEXT:     Section: N_UNDEF
+# AUXSYM32-NEXT:     Source Language ID: TB_C (0x0)
+# AUXSYM32-NEXT:     CPU Version ID: 0x0
+# AUXSYM32-NEXT:     StorageClass: C_FILE (0x67)
+# AUXSYM32-NEXT:     NumberOfAuxEntries: 1
+# AUXSYM32-NEXT:     File Auxiliary Entry {
+# AUXSYM32-NEXT:       Index: 8
+# AUXSYM32-NEXT:       Name: fname
+# AUXSYM32-NEXT:       Type: XFT_CD (0x80)
+# AUXSYM32-NEXT:     }
+# AUXSYM32-NEXT:   }
+# AUXSYM32-NEXT:   Symbol {
+# AUXSYM32-NEXT:     Index: 9
+# AUXSYM32-NEXT:     Name: aux_sect
+# AUXSYM32-NEXT:     Value (OffsetInDWARF): 0x0
+# AUXSYM32-NEXT:     Section: N_UNDEF
+# AUXSYM32-NEXT:     Type: 0x0
+# AUXSYM32-NEXT:     StorageClass: C_DWARF (0x70)
+# AUXSYM32-NEXT:     NumberOfAuxEntries: 1
+# AUXSYM32-NEXT:     Sect Auxiliary Entry For DWARF {
+# AUXSYM32-NEXT:       Index: 10
+# AUXSYM32-NEXT:       LengthOfSectionPortion: 0x2
+# AUXSYM32-NEXT:       NumberOfRelocEntries: 3
+# AUXSYM32-NEXT:     }
+# AUXSYM32-NEXT:   }
+# AUXSYM32-NEXT: ]
+
+--- !XCOFF
+FileHeader:
+  MagicNumber: 0x1DF
+Symbols:
+  - Name:               aux_fcn_csect
+    StorageClass:       C_EXT
+    Type:               0x20
+    NumberOfAuxEntries: 2
+    AuxEntries:
+      - Type:                 AUX_FCN
+        OffsetToExceptionTbl: 2
+        SizeOfFunction:       3
+        SymIdxOfNextBeyond:   4
+        PtrToLineNum:         5
+      - Type:                   AUX_CSECT
+        ParameterHashIndex:     2
+        TypeChkSectNum:         3
+        SymbolAlignmentAndType: 1
+        StorageMappingClass:    XMC_RO
+        SectionOrLength:        4
+        StabInfoIndex:          5
+        StabSectNum:            6
+  - Name:               aux_stat
+    StorageClass:       C_STAT
+    NumberOfAuxEntries: 1
+    AuxEntries:
+      - Type:             AUX_STAT
+        SectionLength:    2
+        NumberOfRelocEnt: 3
+        NumberOfLineNum:  4
+  - Name:               aux_sym
+    StorageClass:       C_BLOCK
+    NumberOfAuxEntries: 1
+    AuxEntries:
+      - Type:       AUX_SYM
+        LineNumHi:  2
+        LineNumLo:  3
+  - Name:               aux_file
+    StorageClass:       C_FILE
+    NumberOfAuxEntries: 1
+    AuxEntries:
+      - Type:             AUX_FILE
+        FileNameOrString: fname
+        FileStringType:   XFT_CD
+  - Name:               aux_sect
+    StorageClass:       C_DWARF
+    NumberOfAuxEntries: 1
+    AuxEntries:
+      - Type:                   AUX_SECT
+        LengthOfSectionPortion: 2
+        NumberOfRelocEnt:       3
+
+## Check the behaviour in XCOFF64.
+# RUN: yaml2obj %s --docnum=2 -o %t2
+# RUN: llvm-readobj --syms %t2 | FileCheck %s --check-prefix=AUXSYM64
+
+# AUXSYM64:      AddressSize: 64bit
+# AUXSYM64-NEXT: Symbols [
+# AUXSYM64-NEXT:   Symbol {
+# AUXSYM64-NEXT:     Index: 0
+# AUXSYM64-NEXT:     Name: aux_except_fcn_csect
+# AUXSYM64-NEXT:     Value (RelocatableAddress): 0x0
+# AUXSYM64-NEXT:     Section: N_UNDEF
+# AUXSYM64-NEXT:     Type: 0x20
+# AUXSYM64-NEXT:     StorageClass: C_EXT (0x2)
+# AUXSYM64-NEXT:     NumberOfAuxEntries: 3
+# AUXSYM64-NEXT:     Exception Auxiliary Entry {
+# AUXSYM64-NEXT:       Index: 1
+# AUXSYM64-NEXT:       OffsetToExceptionTable: 0x2
+# AUXSYM64-NEXT:       SizeOfFunction: 0x3
+# AUXSYM64-NEXT:       SymbolIndexOfNextBeyond: 4
+# AUXSYM64-NEXT:       Auxiliary Type: AUX_EXCEPT (0xFF)
+# AUXSYM64-NEXT:     }
+# AUXSYM64-NEXT:     Function Auxiliary Entry {
+# AUXSYM64-NEXT:       Index: 2
+# AUXSYM64-NEXT:       SizeOfFunction: 0x3
+# AUXSYM64-NEXT:       PointerToLineNum: 0x5
+# AUXSYM64-NEXT:       SymbolIndexOfNextBeyond: 4
+# AUXSYM64-NEXT:       Auxiliary Type: AUX_FCN (0xFE)
+# AUXSYM64-NEXT:     }
+# AUXSYM64-NEXT:     CSECT Auxiliary Entry {
+# AUXSYM64-NEXT:       Index: 3
+# AUXSYM64-NEXT:       SectionLen: 21474836484
+# AUXSYM64-NEXT:       ParameterHashIndex: 0x2
+# AUXSYM64-NEXT:       TypeChkSectNum: 0x3
+# AUXSYM64-NEXT:       SymbolAlignmentLog2: 0
+# AUXSYM64-NEXT:       SymbolType: XTY_SD (0x1)
+# AUXSYM64-NEXT:       StorageMappingClass: XMC_RO (0x1)
+# AUXSYM64-NEXT:       Auxiliary Type: AUX_CSECT (0xFB)
+# AUXSYM64-NEXT:     }
+# AUXSYM64-NEXT:   }
+# AUXSYM64-NEXT:   Symbol {
+# AUXSYM64-NEXT:     Index: 4
+# AUXSYM64-NEXT:     Name: aux_sym
+# AUXSYM64-NEXT:     Value (RelocatableAddress): 0x0
+# AUXSYM64-NEXT:     Section: N_UNDEF
+# AUXSYM64-NEXT:     Type: 0x0
+# AUXSYM64-NEXT:     StorageClass: C_BLOCK (0x64)
+# AUXSYM64-NEXT:     NumberOfAuxEntries: 1
+# AUXSYM64-NEXT:     Block Auxiliary Entry {
+# AUXSYM64-NEXT:       Index: 5
+# AUXSYM64-NEXT:       LineNumber: 0x3
+# AUXSYM64-NEXT:       Auxiliary Type: AUX_SYM (0xFD)
+# AUXSYM64-NEXT:     }
+# AUXSYM64-NEXT:   }
+# AUXSYM64-NEXT:   Symbol {
+# AUXSYM64-NEXT:     Index: 6
+# AUXSYM64-NEXT:     Name: aux_file
+# AUXSYM64-NEXT:     Value (SymbolTableIndex): 0x0
+# AUXSYM64-NEXT:     Section: N_UNDEF
+# AUXSYM64-NEXT:     Source Language ID: TB_C (0x0)
+# AUXSYM64-NEXT:     CPU Version ID: 0x0
+# AUXSYM64-NEXT:     StorageClass: C_FILE (0x67)
+# AUXSYM64-NEXT:     NumberOfAuxEntries: 1
+# AUXSYM64-NEXT:     File Auxiliary Entry {
+# AUXSYM64-NEXT:       Index: 7
+# AUXSYM64-NEXT:       Name: fname
+# AUXSYM64-NEXT:       Type: XFT_CD (0x80)
+# AUXSYM64-NEXT:       Auxiliary Type: AUX_FILE (0xFC)
+# AUXSYM64-NEXT:     }
+# AUXSYM64-NEXT:   }
+# AUXSYM64-NEXT:   Symbol {
+# AUXSYM64-NEXT:     Index: 8
+# AUXSYM64-NEXT:     Name: aux_sect
+# AUXSYM64-NEXT:     Value (OffsetInDWARF): 0x0
+# AUXSYM64-NEXT:     Section: N_UNDEF
+# AUXSYM64-NEXT:     Type: 0x0
+# AUXSYM64-NEXT:     StorageClass: C_DWARF (0x70)
+# AUXSYM64-NEXT:     NumberOfAuxEntries: 1
+# AUXSYM64-NEXT:     Sect Auxiliary Entry For DWARF {
+# AUXSYM64-NEXT:       Index: 9
+# AUXSYM64-NEXT:       LengthOfSectionPortion: 0x2
+# AUXSYM64-NEXT:       NumberOfRelocEntries: 3
+# AUXSYM64-NEXT:       Auxiliary Type: AUX_SECT (0xFA)
+# AUXSYM64-NEXT:     }
+# AUXSYM64-NEXT:   }
+# AUXSYM64-NEXT: ]
+
+--- !XCOFF
+FileHeader:
+  MagicNumber: 0x1F7
+Symbols:
+  - Name:               aux_except_fcn_csect
+    StorageClass:       C_EXT
+    Type:               0x20
+    NumberOfAuxEntries: 3
+    AuxEntries:
+      - Type:                 AUX_EXCEPT
+        OffsetToExceptionTbl: 2
+        SizeOfFunction:       3
+        SymIdxOfNextBeyond:   4
+      - Type:               AUX_FCN
+        SizeOfFunction:     3
+        SymIdxOfNextBeyond: 4
+        PtrToLineNum:       5
+      - Type:                   AUX_CSECT
+        ParameterHashIndex:     2
+        TypeChkSectNum:         3
+        SymbolAlignmentAndType: 1
+        StorageMappingClass:    XMC_RO
+        SectionOrLengthLo:      4
+        SectionOrLengthHi:      5
+  - Name:               aux_sym
+    StorageClass:       C_BLOCK
+    NumberOfAuxEntries: 1
+    AuxEntries:
+      - Type:    AUX_SYM
+        LineNum: 3
+  - Name:               aux_file
+    StorageClass:       C_FILE
+    NumberOfAuxEntries: 1
+    AuxEntries:
+      - Type:             AUX_FILE
+        FileNameOrString: fname
+        FileStringType:   XFT_CD
+  - Name:               aux_sect
+    StorageClass:       C_DWARF
+    NumberOfAuxEntries: 1
+    AuxEntries:
+      - Type:                   AUX_SECT
+        LengthOfSectionPortion: 2
+        NumberOfRelocEnt:       3
+
+## The file name greater than 8 bytes in the AUX_FILE symbol is stored in the string table.
+# RUN: yaml2obj %s --docnum=3 -o %t3
+# RUN: llvm-readobj --syms --string-table %t3 | FileCheck %s --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
+
+## Show that yaml2obj reports an error when trying to write the AUX_STAT symbol for XCOFF32.
+# RUN: not yaml2obj %s --docnum=4 -o %t4 2>&1 | FileCheck %s --check-prefix=STAT64
+
+# STAT64: error: the section auxiliary entry for the C_STAT Symbol is defined in XCOFF32 only
+
+--- !XCOFF
+FileHeader:
+  MagicNumber: 0x1F7
+Symbols:
+  - StorageClass:       C_STAT
+    NumberOfAuxEntries: 1
+    AuxEntries:
+      - Type: AUX_STAT
+
+## Show that yaml2obj reports an error when trying to write the AUX_EXCEPT symbol for XCOFF64.
+# RUN: not yaml2obj %s --docnum=5 -o %t5 2>&1 | FileCheck %s --check-prefix=EXCEPT32
+
+# EXCEPT32: error: the exception auxiliary symbol table entry is defined in XCOFF64 only
+
+--- !XCOFF
+FileHeader:
+  MagicNumber: 0x1DF
+Symbols:
+  - StorageClass:       C_EXT
+    NumberOfAuxEntries: 1
+    AuxEntries:
+      - Type: AUX_EXCEPT
+
+
+## The specified value of NumberOfAuxEntries should greater than the actual number of aux entries.
+# RUN: not yaml2obj %s --docnum=6 -o %t6 2>&1 | FileCheck %s --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
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();