[XCOFF][yaml2obj] support for the auxiliary file header.

[Esme]

Summary

This patch adds yaml2obj supporting for the auxiliary file header of XCOFF.

[jhenderson]

llvm/lib/ObjectYAML/XCOFFEmitter.cpp

245–246

250–251

I just remembered that llvm::Optional has a getValueOr(T Value) function which gives you the input parameter, if the optional is none, or the stored value otherwise. I think that would make the code throughout much simpler.

347

Do you actually need the casts? You've explicitly specified the type for write after all. If you do need a cast, use static_cast.

465

Give the 32768 magic number a name, i.e. put it in a variable or constant somewhere. Flags are also usually written as hex in the source code, which might help make things clearer.

llvm/test/tools/yaml2obj/XCOFF/aux-hdr-32.yaml

8

This and the 64-bit test need to show that the value isn't taken from the sections if present, i.e. they need to have at least one section of each type with values different to the explicitly specified values in the YAML.

llvm/test/tools/yaml2obj/XCOFF/aux-hdr-omit.yaml

1

I think you need a 32-bit and 64-bit version of this test. In other words, show what the default is for both formats. Does that make sense to you?

I think you also need to show what happens when there are no text/data/bss sections etc from which to derive the values if not specified.

8

I might be being dumb, but the sizes below look like 2 bytes to me.

47

Assuming that a single section contributes to the field, you should use a different size here, to show that the right one is picked.

48–49

Don't you need duplicates of this and some of the other sections, like .text, to show that the first one wins in all cases?

[Esme]

llvm/lib/ObjectYAML/XCOFFEmitter.cpp

250–251

Thanks!
I used the function getValueOr(T Value) in XCOFFWriter::writeAuxFileHeader(), which make the code much simpler.
While I didn't use it here because I think it would be better to use the if condition to bail out early rather than call getValueOr() every time. As well as it will not make the code simpler here.

347

The casts were necessary in the comparison expressions.
However I don't need them anymore because the getValueOr(T Value) is adopted now.

llvm/test/tools/yaml2obj/XCOFF/aux-hdr-omit.yaml

1

Yes! The suggestions make sense to me. Thanks!

8

Because the DefaultSectionAlign is 4 in XCOFF.
If I didn't set the sizes explicitly, the calculated values are used.

[DiggerLin]

llvm/lib/ObjectYAML/XCOFFEmitter.cpp

374

should be yaml::Hex8(0) for flag.

llvm/test/tools/yaml2obj/XCOFF/aux-hdr-omit.yaml

70

in the xcoff document , some section are not multi section allow. https://www.ibm.com/docs/en/aix/7.2?topic=formats-xcoff-object-file-format#XCOFF__a2zjvh2b9shar
for example, loader section. but it is a test , it do not matter.

[DiggerLin]

there is some nit comment need to be addressed.

[jhenderson]

llvm/lib/ObjectYAML/XCOFFEmitter.cpp

350–351

I might put the comment on the same line, because it's a little confusing whether it's referring to just this one field or not.

374

Just checking: should this comment be CPU rather than CUP?

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

91–94 ↗

(On Diff #380586)

These numbers aren't obviously arbitrary, I'd suggest making them more obviously so, e.g. 0x1111, 0x2222 etc.

llvm/test/tools/yaml2obj/XCOFF/aux-hdr-omit.yaml

2

Perhaps rename the test to aux-hdr-defaults.yaml.

8

So in XCOFF are sections tail padded? In ELF, there are just unlabelled gaps between sections, if alignment padding is required.

51

Probably fill with non-zero values all the way. Maybe also add a comment why you have two of each section.

70

Remember, this is yaml2obj, so we should be as flexible as possible.

75

Same below.

I wonder if you could reuse most of the FileCheck data here with the 32-bit case, rather than duplicating it? I've not looked too closely, but perhaps multiple check-prefixes would be appropriate, e.g. --check-prefixes=COMMON1,CASE1-64?

114

[DiggerLin]

llvm/test/tools/yaml2obj/XCOFF/aux-hdr-omit.yaml

75

the data members and the order the data members of auxiliary header between 32bit and 64bit are different , if using COMMON1,CASE1-64 , I think it maybe more difficult to read the test case.

[Esme]

Address comments.

llvm/test/tools/yaml2obj/XCOFF/aux-hdr-omit.yaml

8

Yes, it's required that the section address aligned to DefaultSectionAlign.

51

I think setting section content with non-zero values is enough since the size and address will be derived automatically.

75

Thanks for your comments and agree with Digger to keep the current check-style.

[jhenderson]

Two minor comments, otherwise LGTM.

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

17 ↗

(On Diff #385389)

Could we add something before .text so that the .text section start address is non-zero? (This may not make sense from a file format perspective, so fine if not)

50 ↗

(On Diff #385389)

[Esme]

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

17 ↗

(On Diff #385389)

Yes, it sounds reasonable to me.

[RKSimon]

llvm/lib/ObjectYAML/XCOFFEmitter.cpp

355

This is failing on MSVC builds:

E:\llvm\llvm-project\llvm\include\llvm/ADT/Optional.h(298): note: No user-defined-conversion operator available that can perform this conversion, or the operator cannot be called
E:\llvm\llvm-project\llvm\lib\ObjectYAML\XCOFFEmitter.cpp(356): note: see reference to function template instantiation 'T llvm::Optional<T>::getValueOr<llvm::yaml::Hex32>(U &&) const &' being compiled
        with
        [
            T=llvm::yaml::Hex64,
            U=llvm::yaml::Hex32
        ]

llvm/include/llvm/BinaryFormat/XCOFF.h

 namespace XCOFF {
 
 // Constants used in the XCOFF definition.
 
 constexpr size_t FileNamePadSize = 6;
 constexpr size_t NameSize = 8;
 constexpr size_t FileHeaderSize32 = 20;
 constexpr size_t FileHeaderSize64 = 24;
+constexpr size_t AuxFileHeaderSize32 = 72;
+constexpr size_t AuxFileHeaderSize64 = 110;
 constexpr size_t SectionHeaderSize32 = 40;
 constexpr size_t SectionHeaderSize64 = 72;
 constexpr size_t SymbolTableEntrySize = 18;
 constexpr size_t RelocationSerializationSize32 = 10;
 constexpr size_t RelocationSerializationSize64 = 14;
 constexpr uint16_t RelocOverflow = 65535;
 constexpr uint8_t AllocRegNo = 31;
 

llvm/include/llvm/ObjectYAML/XCOFFYAML.h

struct FileHeader {
   uint16_t NumberOfSections;
   int32_t TimeStamp;
   llvm::yaml::Hex64 SymbolTableOffset;
   uint32_t NumberOfSymTableEntries;
   uint16_t AuxHeaderSize;
   llvm::yaml::Hex16 Flags;
 };
 
+struct AuxiliaryHeader {
+  Optional<llvm::yaml::Hex16> Magic;
+  Optional<llvm::yaml::Hex16> Version;
+  Optional<llvm::yaml::Hex64> TextStartAddr;
+  Optional<llvm::yaml::Hex64> DataStartAddr;
+  Optional<llvm::yaml::Hex64> TOCAnchorAddr;
+  Optional<uint16_t> SecNumOfEntryPoint;
+  Optional<uint16_t> SecNumOfText;
+  Optional<uint16_t> SecNumOfData;
+  Optional<uint16_t> SecNumOfTOC;
+  Optional<uint16_t> SecNumOfLoader;
+  Optional<uint16_t> SecNumOfBSS;
+  Optional<llvm::yaml::Hex16> MaxAlignOfText;
+  Optional<llvm::yaml::Hex16> MaxAlignOfData;
+  Optional<llvm::yaml::Hex16> ModuleType;
+  Optional<llvm::yaml::Hex8> CpuFlag;
+  Optional<llvm::yaml::Hex8> CpuType;
+  Optional<llvm::yaml::Hex8> TextPageSize;
+  Optional<llvm::yaml::Hex8> DataPageSize;
+  Optional<llvm::yaml::Hex8> StackPageSize;
+  Optional<llvm::yaml::Hex8> FlagAndTDataAlignment;
+  Optional<llvm::yaml::Hex64> TextSize;
+  Optional<llvm::yaml::Hex64> InitDataSize;
+  Optional<llvm::yaml::Hex64> BssDataSize;
+  Optional<llvm::yaml::Hex64> EntryPointAddr;
+  Optional<llvm::yaml::Hex64> MaxStackSize;
+  Optional<llvm::yaml::Hex64> MaxDataSize;
+  Optional<uint16_t> SecNumOfTData;
+  Optional<uint16_t> SecNumOfTBSS;
+  Optional<llvm::yaml::Hex16> Flag;
+};
+
 struct Relocation {
   llvm::yaml::Hex64 VirtualAddress;
   llvm::yaml::Hex64 SymbolIndex;
   llvm::yaml::Hex8 Info;
   llvm::yaml::Hex8 Type;
 };
 
 struct Section {
struct StringTable {
   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
 

 template <> struct ScalarEnumerationTraits<XCOFF::StorageClass> {
   static void enumeration(IO &IO, XCOFF::StorageClass &Value);
 };
 
 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<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

XCOFFWriter(XCOFFYAML::Object &Obj, raw_ostream &OS, yaml::ErrorHandler EH)
         StrTblBuilder(StringTableBuilder::XCOFF) {
     Is64Bit = Obj.Header.Magic == (llvm::yaml::Hex16)XCOFF::XCOFF64;
   }
   bool writeXCOFF();
 
 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();
 
   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 = {
       {StringRef("N_DEBUG"), XCOFF::N_DEBUG},
       {StringRef("N_ABS"), XCOFF::N_ABS},
       {StringRef("N_UNDEF"), XCOFF::N_UNDEF}};
   XCOFFYAML::FileHeader InitFileHdr = Obj.Header;
+  XCOFFYAML::AuxiliaryHeader InitAuxFileHdr;
   std::vector<XCOFFYAML::Section> InitSections = Obj.Sections;
 };
 
 static void writeName(StringRef StrName, support::endian::Writer W) {
   char Name[XCOFF::NameSize];
   memset(Name, 0, XCOFF::NameSize);
   char SrcName[] = "";
   memcpy(Name, StrName.size() ? StrName.data() : SrcName, StrName.size());
if (CurrentOffset > MaxRawDataSize) {
                  "exceeded when writing symbols");
       return false;
     }
   }
   // TODO: Calculate FileOffsetToLineNumbers when line number supported.
   return true;
 }
 
+void XCOFFWriter::initAuxFileHeader() {
+  InitAuxFileHdr = *Obj.AuxHeader;
+  // In general, an object file might contain multiple sections of a given type,
+  // but in a loadable module, there must be exactly one .text, .data, .bss, and
+  // .loader section. A loadable object might also have one .tdata section and
+  // one .tbss section.
+  // Set these section-related values if not set explicitly. We assume that the
+  // input YAML matches the format of the loadable object. But if input sections
+  // still have same type, the first section with that type prevails.
+  for (uint16_t I = 0, E = InitSections.size(); I < E; ++I) {
+    switch (InitSections[I].Flags) {
+    case XCOFF::STYP_TEXT:
+      if (!InitAuxFileHdr.TextSize)
+        InitAuxFileHdr.TextSize = InitSections[I].Size;
+      if (!InitAuxFileHdr.TextStartAddr)
+        InitAuxFileHdr.TextStartAddr = InitSections[I].Address;
+      if (!InitAuxFileHdr.SecNumOfText)
+        InitAuxFileHdr.SecNumOfText = I + 1;
+      break;
+    case XCOFF::STYP_DATA:
+      if (!InitAuxFileHdr.InitDataSize)
+        InitAuxFileHdr.InitDataSize = InitSections[I].Size;
+      if (!InitAuxFileHdr.DataStartAddr)
+        InitAuxFileHdr.DataStartAddr = InitSections[I].Address;
+      if (!InitAuxFileHdr.SecNumOfData)
+        InitAuxFileHdr.SecNumOfData = I + 1;
+      break;
+    case XCOFF::STYP_BSS:
+      if (!InitAuxFileHdr.BssDataSize)
+        InitAuxFileHdr.BssDataSize = InitSections[I].Size;
+      if (!InitAuxFileHdr.SecNumOfBSS)
+        InitAuxFileHdr.SecNumOfBSS = I + 1;
+      break;
+    case XCOFF::STYP_TDATA:
+      if (!InitAuxFileHdr.SecNumOfTData)
+        InitAuxFileHdr.SecNumOfTData = I + 1;
+      break;
+    case XCOFF::STYP_TBSS:
+      if (!InitAuxFileHdr.SecNumOfTData)
+        InitAuxFileHdr.SecNumOfTData = I + 1;
+      break;
+    case XCOFF::STYP_LOADER:
+      if (!InitAuxFileHdr.SecNumOfLoader)
+        InitAuxFileHdr.SecNumOfLoader = I + 1;
+      break;
+    default:
+      break;
+    }
+  }
+}
+
 bool XCOFFWriter::assignAddressesAndIndices() {
   uint64_t FileHdrSize =
       Is64Bit ? XCOFF::FileHeaderSize64 : XCOFF::FileHeaderSize32;
+  uint64_t AuxFileHdrSize = 0;
+  if (Obj.AuxHeader)
+    AuxFileHdrSize = Obj.Header.AuxHeaderSize
+                         ? Obj.Header.AuxHeaderSize
+                         : (Is64Bit ? XCOFF::AuxFileHeaderSize64
+                                    : XCOFF::AuxFileHeaderSize32);
   uint64_t SecHdrSize =
       Is64Bit ? XCOFF::SectionHeaderSize64 : XCOFF::SectionHeaderSize32;
-  uint64_t CurrentOffset = FileHdrSize /* TODO: + auxiliaryHeaderSize() */ +
-                           InitSections.size() * SecHdrSize;
+  uint64_t CurrentOffset =
+      FileHdrSize + AuxFileHdrSize + InitSections.size() * SecHdrSize;
 
   // Calculate section header info.
   if (!initSectionHeader(CurrentOffset))
     return false;
+  InitFileHdr.AuxHeaderSize = AuxFileHdrSize;
 
   // Calculate file header info.
   if (!initFileHeader(CurrentOffset))
     return false;
 
+  // Initialize the auxiliary file header.
+  if (Obj.AuxHeader)
+    initAuxFileHeader();
+
   // Initialize the string table.
   return initStringTable();
 }
 
 void XCOFFWriter::writeFileHeader() {
   W.write<uint16_t>(Obj.Header.Magic ? Obj.Header.Magic : InitFileHdr.Magic);
   W.write<uint16_t>(Obj.Header.NumberOfSections ? Obj.Header.NumberOfSections
                                                 : InitFileHdr.NumberOfSections);
   W.write<int32_t>(Obj.Header.TimeStamp);
   if (Is64Bit) {
     W.write<uint64_t>(Obj.Header.SymbolTableOffset
                           ? Obj.Header.SymbolTableOffset
                           : InitFileHdr.SymbolTableOffset);
-    W.write<uint16_t>(Obj.Header.AuxHeaderSize);
+    W.write<uint16_t>(InitFileHdr.AuxHeaderSize);
     W.write<uint16_t>(Obj.Header.Flags);
     W.write<int32_t>(Obj.Header.NumberOfSymTableEntries
                          ? Obj.Header.NumberOfSymTableEntries
                          : InitFileHdr.NumberOfSymTableEntries);
   } else {
     W.write<uint32_t>(Obj.Header.SymbolTableOffset
                           ? Obj.Header.SymbolTableOffset
                           : InitFileHdr.SymbolTableOffset);
     W.write<int32_t>(Obj.Header.NumberOfSymTableEntries
                          ? Obj.Header.NumberOfSymTableEntries
                          : InitFileHdr.NumberOfSymTableEntries);
-    W.write<uint16_t>(Obj.Header.AuxHeaderSize);
+    W.write<uint16_t>(InitFileHdr.AuxHeaderSize);
     W.write<uint16_t>(Obj.Header.Flags);
   }
 }
 
+void XCOFFWriter::writeAuxFileHeader() {
+  W.write<uint16_t>(InitAuxFileHdr.Magic ? (uint16_t)*InitAuxFileHdr.Magic : 1);
+  W.write<uint16_t>(InitAuxFileHdr.Version ? (uint16_t)*InitAuxFileHdr.Version
+                                           : 1);
+  if (Is64Bit) {
+    // Reserved for debugger.
+    W.OS.write_zeros(4);
+    W.write<uint64_t>(InitAuxFileHdr.TextStartAddr
+                          ? (uint64_t)*InitAuxFileHdr.TextStartAddr
+                          : 0);
+    W.write<uint64_t>(InitAuxFileHdr.DataStartAddr
+                          ? (uint64_t)*InitAuxFileHdr.DataStartAddr
+                          : 0);
+    W.write<uint64_t>(InitAuxFileHdr.TOCAnchorAddr
+                          ? (uint64_t)*InitAuxFileHdr.TOCAnchorAddr
+                          : 0);
+  } else {
+    W.write<uint32_t>(
+        InitAuxFileHdr.TextSize ? (uint32_t)*InitAuxFileHdr.TextSize : 0);
+    W.write<uint32_t>(InitAuxFileHdr.InitDataSize
+                          ? (uint32_t)*InitAuxFileHdr.InitDataSize
+                          : 0);
+    W.write<uint32_t>(
+        InitAuxFileHdr.BssDataSize ? (uint32_t)*InitAuxFileHdr.BssDataSize : 0);
+    W.write<uint32_t>(InitAuxFileHdr.EntryPointAddr
+                          ? (uint32_t)*InitAuxFileHdr.EntryPointAddr
+                          : 0);
+    W.write<uint32_t>(InitAuxFileHdr.TextStartAddr
+                          ? (uint32_t)*InitAuxFileHdr.TextStartAddr
+                          : 0);
+    W.write<uint32_t>(InitAuxFileHdr.DataStartAddr
+                          ? (uint32_t)*InitAuxFileHdr.DataStartAddr
+                          : 0);
+    W.write<uint32_t>(InitAuxFileHdr.TOCAnchorAddr
+                          ? (uint32_t)*InitAuxFileHdr.TOCAnchorAddr
+                          : 0);
+  }
+  W.write<uint16_t>(InitAuxFileHdr.SecNumOfEntryPoint
+                        ? (uint16_t)*InitAuxFileHdr.SecNumOfEntryPoint
+                        : 0);
+  W.write<uint16_t>(
+      InitAuxFileHdr.SecNumOfText ? (uint16_t)*InitAuxFileHdr.SecNumOfText : 0);
+  W.write<uint16_t>(
+      InitAuxFileHdr.SecNumOfData ? (uint16_t)*InitAuxFileHdr.SecNumOfData : 0);
+  W.write<uint16_t>(
+      InitAuxFileHdr.SecNumOfTOC ? (uint16_t)*InitAuxFileHdr.SecNumOfTOC : 0);
+  W.write<uint16_t>(InitAuxFileHdr.SecNumOfLoader
+                        ? (uint16_t)*InitAuxFileHdr.SecNumOfLoader
+                        : 0);
+  W.write<uint16_t>(
+      InitAuxFileHdr.SecNumOfBSS ? (uint16_t)*InitAuxFileHdr.SecNumOfBSS : 0);
+  W.write<uint16_t>(InitAuxFileHdr.MaxAlignOfText
+                        ? (uint16_t)*InitAuxFileHdr.MaxAlignOfText
+                        : 0);
+  W.write<uint16_t>(InitAuxFileHdr.MaxAlignOfData
+                        ? (uint16_t)*InitAuxFileHdr.MaxAlignOfData
+                        : 0);
+  W.write<uint16_t>(
+      InitAuxFileHdr.ModuleType ? (uint16_t)*InitAuxFileHdr.ModuleType : 0);
+  W.write<uint8_t>(InitAuxFileHdr.CpuFlag ? (uint8_t)*InitAuxFileHdr.CpuFlag
+                                          : 0);
+  // Reserved for CUP type.
+  W.write<uint8_t>(0);
+  if (Is64Bit) {
+    W.write<uint8_t>(InitAuxFileHdr.TextPageSize
+                         ? (uint8_t)*InitAuxFileHdr.TextPageSize
+                         : 0);
+    W.write<uint8_t>(InitAuxFileHdr.DataPageSize
+                         ? (uint8_t)*InitAuxFileHdr.DataPageSize
+                         : 0);
+    W.write<uint8_t>(InitAuxFileHdr.StackPageSize
+                         ? (uint8_t)*InitAuxFileHdr.StackPageSize
+                         : 0);
+    W.write<uint8_t>(InitAuxFileHdr.FlagAndTDataAlignment
+                         ? (uint8_t)*InitAuxFileHdr.FlagAndTDataAlignment
+                         : 128);
+    W.write<uint64_t>(
+        InitAuxFileHdr.TextSize ? (uint64_t)*InitAuxFileHdr.TextSize : 0);
+    W.write<uint64_t>(InitAuxFileHdr.InitDataSize
+                          ? (uint64_t)*InitAuxFileHdr.InitDataSize
+                          : 0);
+    W.write<uint64_t>(
+        InitAuxFileHdr.BssDataSize ? (uint64_t)*InitAuxFileHdr.BssDataSize : 0);
+    W.write<uint64_t>(InitAuxFileHdr.EntryPointAddr
+                          ? (uint64_t)*InitAuxFileHdr.EntryPointAddr
+                          : 0);
+    W.write<uint64_t>(InitAuxFileHdr.MaxStackSize
+                          ? (uint64_t)*InitAuxFileHdr.MaxStackSize
+                          : 0);
+    W.write<uint64_t>(
+        InitAuxFileHdr.MaxDataSize ? (uint64_t)*InitAuxFileHdr.MaxDataSize : 0);
+  } else {
+    W.write<uint32_t>(InitAuxFileHdr.MaxStackSize
+                          ? (uint32_t)*InitAuxFileHdr.MaxStackSize
+                          : 0);
+    W.write<uint32_t>(
+        InitAuxFileHdr.MaxDataSize ? (uint32_t)*InitAuxFileHdr.MaxDataSize : 0);
+    // Reserved for debugger.
+    W.OS.write_zeros(4);
+    W.write<uint8_t>(InitAuxFileHdr.TextPageSize
+                         ? (uint8_t)*InitAuxFileHdr.TextPageSize
+                         : 0);
+    W.write<uint8_t>(InitAuxFileHdr.DataPageSize
+                         ? (uint8_t)*InitAuxFileHdr.DataPageSize
+                         : 0);
+    W.write<uint8_t>(InitAuxFileHdr.StackPageSize
+                         ? (uint8_t)*InitAuxFileHdr.StackPageSize
+                         : 0);
+    W.write<uint8_t>(InitAuxFileHdr.FlagAndTDataAlignment
+                         ? (uint8_t)*InitAuxFileHdr.FlagAndTDataAlignment
+                         : 0);
+  }
+  W.write<uint16_t>(InitAuxFileHdr.SecNumOfTData
+                        ? (uint16_t)*InitAuxFileHdr.SecNumOfTData
+                        : 0);
+  W.write<uint16_t>(
+      InitAuxFileHdr.SecNumOfTBSS ? (uint16_t)*InitAuxFileHdr.SecNumOfTBSS : 0);
+  if (Is64Bit) {
+    W.write<uint16_t>(InitAuxFileHdr.Flag ? (uint16_t)*InitAuxFileHdr.Flag
+                                          : 32768);
+    if (InitFileHdr.AuxHeaderSize > XCOFF::AuxFileHeaderSize64)
+      W.OS.write_zeros(InitFileHdr.AuxHeaderSize - XCOFF::AuxFileHeaderSize64);
+  } else if (InitFileHdr.AuxHeaderSize > XCOFF::AuxFileHeaderSize32) {
+    W.OS.write_zeros(InitFileHdr.AuxHeaderSize - XCOFF::AuxFileHeaderSize32);
+  }
+}
+
 void XCOFFWriter::writeSectionHeader() {
   for (uint16_t I = 0, E = Obj.Sections.size(); I < E; ++I) {
     XCOFFYAML::Section YamlSec = Obj.Sections[I];
     XCOFFYAML::Section DerivedSec = InitSections[I];
     writeName(YamlSec.SectionName, W);
     // Virtual address is the same as physical address.
     uint64_t SectionAddress =
         YamlSec.Address ? YamlSec.Address : DerivedSec.Address;
void XCOFFWriter::writeStringTable() {
   }
 }
 
 bool XCOFFWriter::writeXCOFF() {
   if (!assignAddressesAndIndices())
     return false;
   StartOffset = W.OS.tell();
   writeFileHeader();
+  if (Obj.AuxHeader)
+    writeAuxFileHeader();
   if (!Obj.Sections.empty()) {
     writeSectionHeader();
     if (!writeSectionData())
       return false;
     if (!writeRelocations())
       return false;
   }
   if (!Obj.Symbols.empty() && !writeSymbols())

llvm/lib/ObjectYAML/XCOFFYAML.cpp

void MappingTraits<XCOFFYAML::FileHeader>::mapping(
   IO.mapOptional("NumberOfSections", FileHdr.NumberOfSections);
   IO.mapOptional("CreationTime", FileHdr.TimeStamp);
   IO.mapOptional("OffsetToSymbolTable", FileHdr.SymbolTableOffset);
   IO.mapOptional("EntriesInSymbolTable", FileHdr.NumberOfSymTableEntries);
   IO.mapOptional("AuxiliaryHeaderSize", FileHdr.AuxHeaderSize);
   IO.mapOptional("Flags", FileHdr.Flags);
 }
 
+void MappingTraits<XCOFFYAML::AuxiliaryHeader>::mapping(
+    IO &IO, XCOFFYAML::AuxiliaryHeader &AuxHdr) {
+  IO.mapOptional("Magic", AuxHdr.Magic);
+  IO.mapOptional("Version", AuxHdr.Version);
+  IO.mapOptional("TextStartAddr", AuxHdr.TextStartAddr);
+  IO.mapOptional("DataStartAddr", AuxHdr.DataStartAddr);
+  IO.mapOptional("TOCAnchorAddr", AuxHdr.TOCAnchorAddr);
+  IO.mapOptional("TextSectionSize", AuxHdr.TextSize);
+  IO.mapOptional("DataSectionSize", AuxHdr.InitDataSize);
+  IO.mapOptional("BssSectionSize", AuxHdr.BssDataSize);
+  IO.mapOptional("SecNumOfEntryPoint", AuxHdr.SecNumOfEntryPoint);
+  IO.mapOptional("SecNumOfText", AuxHdr.SecNumOfText);
+  IO.mapOptional("SecNumOfData", AuxHdr.SecNumOfData);
+  IO.mapOptional("SecNumOfTOC", AuxHdr.SecNumOfTOC);
+  IO.mapOptional("SecNumOfLoader", AuxHdr.SecNumOfLoader);
+  IO.mapOptional("SecNumOfBSS", AuxHdr.SecNumOfBSS);
+  IO.mapOptional("MaxAlignOfText", AuxHdr.MaxAlignOfText);
+  IO.mapOptional("MaxAlignOfData", AuxHdr.MaxAlignOfData);
+  IO.mapOptional("ModuleType", AuxHdr.CpuFlag);
+  IO.mapOptional("TextPageSize", AuxHdr.TextPageSize);
+  IO.mapOptional("DataPageSize", AuxHdr.DataPageSize);
+  IO.mapOptional("StackPageSize", AuxHdr.StackPageSize);
+  IO.mapOptional("FlagAndTDataAlignment", AuxHdr.FlagAndTDataAlignment);
+  IO.mapOptional("EntryPointAddr", AuxHdr.EntryPointAddr);
+  IO.mapOptional("MaxStackSize", AuxHdr.MaxStackSize);
+  IO.mapOptional("MaxDataSize", AuxHdr.MaxDataSize);
+  IO.mapOptional("SecNumOfTData", AuxHdr.SecNumOfTData);
+  IO.mapOptional("SecNumOfTBSS", AuxHdr.SecNumOfTBSS);
+  IO.mapOptional("Flag", AuxHdr.Flag);
+}
+
 void MappingTraits<XCOFFYAML::Relocation>::mapping(IO &IO,
                                                    XCOFFYAML::Relocation &R) {
   IO.mapOptional("Address", R.VirtualAddress);
   IO.mapOptional("Symbol", R.SymbolIndex);
   IO.mapOptional("Info", R.Info);
   IO.mapOptional("Type", R.Type);
 }
 
void MappingTraits<XCOFFYAML::StringTable>::mapping(IO &IO, XCOFFYAML::StringTable &Str) {
   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.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);
 }
 
 } // namespace yaml
 } // namespace llvm

llvm/test/tools/yaml2obj/XCOFF/aux-hdr-32.yaml

+## Test that we can explicitly specify all fields of the auxiliary file header.
+# RUN: yaml2obj %s -o %t
+# RUN: llvm-readobj --auxiliary-header %t | FileCheck %s
+
+# CHECK:      AuxiliaryHeader {
+# CHECK-NEXT:   Magic: 0x10B
+# CHECK-NEXT:   Version: 0x1
+# CHECK-NEXT:   Size of .text section: 0x6
+# CHECK-NEXT:   Size of .data section: 0x15
+# CHECK-NEXT:   Size of .bss section: 0x4
+# CHECK-NEXT:   Entry point address: 0x2824
+# CHECK-NEXT:   .text section start address: 0x1128
+# CHECK-NEXT:   .data section start address: 0x2740
+# CHECK-NEXT:   TOC anchor address: 0x2844
+# CHECK-NEXT:   Section number of entryPoint: 2
+# CHECK-NEXT:   Section number of .text: 1
+# CHECK-NEXT:   Section number of .data: 2
+# CHECK-NEXT:   Section number of TOC: 2
+# CHECK-NEXT:   Section number of loader data: 4
+# CHECK-NEXT:   Section number of .bss: 3
+# CHECK-NEXT:   Maxium alignment of .text: 0x7
+# CHECK-NEXT:   Maxium alignment of .data: 0x3
+# CHECK-NEXT:   Module type: 0x0
+# CHECK-NEXT:   Cpu type of objects: 0x1
+# CHECK-NEXT:   (Reserved): 0x0
+# CHECK-NEXT:   Maximum stack size: 0x0
+# CHECK-NEXT:   Maximum data size: 0x0
+# CHECK-NEXT:   Reserved for debugger: 0x0
+# CHECK-NEXT:   Text page size: 0x1
+# CHECK-NEXT:   Data page size: 0x1
+# CHECK-NEXT:   Stack page size: 0x1
+# CHECK-NEXT:   Flag: 0x0
+# CHECK-NEXT:   Alignment of thread-local storage: 0x1
+# CHECK-NEXT:   Section number for .tdata: 1
+# CHECK-NEXT:   Section number for .tbss: 1
+# CHECK-NEXT: }
+
+--- !XCOFF
+FileHeader:
+  MagicNumber: 0x1DF
+AuxiliaryHeader:
+  Magic:                 0x10B
+  Version:               0x1
+  TextSectionSize:       0x6
+  DataSectionSize:       0x15
+  BssSectionSize:        0x4
+  EntryPointAddr:        0x2824
+  TextStartAddr:         0x1128
+  DataStartAddr:         0x2740
+  TOCAnchorAddr:         0x2844
+  SecNumOfEntryPoint:    2
+  SecNumOfText:          1
+  SecNumOfData:          2
+  SecNumOfTOC:           2
+  SecNumOfLoader:        4
+  SecNumOfBSS:           3
+  MaxAlignOfText:        0x7
+  MaxAlignOfData:        0x3
+  ModuleType:            0x1
+  TextPageSize:          0x1
+  DataPageSize:          0x1
+  StackPageSize:         0x1
+  SecNumOfTData:         0x1
+  SecNumOfTBSS:          0x1
+  FlagAndTDataAlignment: 0x1

llvm/test/tools/yaml2obj/XCOFF/aux-hdr-64.yaml

+## Test that we can explicitly specify all fields of the auxiliary file header.
+# RUN: yaml2obj %s -o %t
+# RUN: llvm-readobj --auxiliary-header %t | FileCheck %s
+
+# CHECK:      AuxiliaryHeader {
+# CHECK-NEXT:   Magic: 0x10B
+# CHECK-NEXT:   Version: 0x1
+# CHECK-NEXT:   Reserved for debugger: 0x0
+# CHECK-NEXT:   .text section start address: 0x11F8
+# CHECK-NEXT:   .data section start address: 0x1740
+# CHECK-NEXT:   TOC anchor address: 0x18A0
+# CHECK-NEXT:   Section number of entryPoint: 2
+# CHECK-NEXT:   Section number of .text: 1
+# CHECK-NEXT:   Section number of .data: 2
+# CHECK-NEXT:   Section number of TOC: 2
+# CHECK-NEXT:   Section number of loader data: 4
+# CHECK-NEXT:   Section number of .bss: 3
+# CHECK-NEXT:   Maxium alignment of .text: 0x7
+# CHECK-NEXT:   Maxium alignment of .data: 0x3
+# CHECK-NEXT:   Module type: 0x0
+# CHECK-NEXT:   Cpu type of objects: 0x1
+# CHECK-NEXT:   (Reserved): 0x0
+# CHECK-NEXT:   Text page size: 0x1
+# CHECK-NEXT:   Data page size: 0x1
+# CHECK-NEXT:   Stack page size: 0x1
+# CHECK-NEXT:   Flag: 0x0
+# CHECK-NEXT:   Alignment of thread-local storage: 0x0
+# CHECK-NEXT:   Size of .text section: 0x6
+# CHECK-NEXT:   Size of .data section: 0x15
+# CHECK-NEXT:   Size of .bss section: 0x4
+# CHECK-NEXT:   Entry point address: 0x1860
+# CHECK-NEXT:   Maximum stack size: 0x0
+# CHECK-NEXT:   Maximum data size: 0x0
+# CHECK-NEXT:   Section number for .tdata: 1
+# CHECK-NEXT:   Section number for .tbss: 1
+# CHECK-NEXT:   Additional flags 64-bit XCOFF: 0x2
+# CHECK-NEXT: }
+
+--- !XCOFF
+FileHeader:
+  MagicNumber: 0x1F7
+AuxiliaryHeader:
+  Magic:                 0x10B
+  Version:               0x1
+  TextSectionSize:       0x6
+  DataSectionSize:       0x15
+  BssSectionSize:        0x4
+  EntryPointAddr:        0x1860
+  TextStartAddr:         0x11F8
+  DataStartAddr:         0x1740
+  TOCAnchorAddr:         0x18A0
+  SecNumOfEntryPoint:    2
+  SecNumOfText:          1
+  SecNumOfData:          2
+  SecNumOfTOC:           2
+  SecNumOfLoader:        4
+  SecNumOfBSS:           3
+  MaxAlignOfText:        0x7
+  MaxAlignOfData:        0x3
+  ModuleType:            0x1
+  TextPageSize:          0x1
+  DataPageSize:          0x1
+  StackPageSize:         0x1
+  SecNumOfTData:         0x1
+  SecNumOfTBSS:          0x1
+  FlagAndTDataAlignment: 0x1
+  Flag:                  0x2

llvm/test/tools/yaml2obj/XCOFF/aux-hdr-omit.yaml

+## Test that yaml2obj automatically sets omited fields of the auxiliary file header if not set explicitly.
+# RUN: yaml2obj %s -o %t
+# RUN: llvm-readobj --auxiliary-header %t | FileCheck %s
+
+# CHECK:      AuxiliaryHeader {
+# CHECK-NEXT:   Magic: 0x10B
+# CHECK-NEXT:   Version: 0x1
+# CHECK-NEXT:   Size of .text section: 0x4
+# CHECK-NEXT:   Size of .data section: 0x4
+# CHECK-NEXT:   Size of .bss section: 0x4
+# CHECK-NEXT:   Entry point address: 0x0
+# CHECK-NEXT:   .text section start address: 0x0
+# CHECK-NEXT:   .data section start address: 0x8
+# CHECK-NEXT:   TOC anchor address: 0x0
+# CHECK-NEXT:   Section number of entryPoint: 0
+# CHECK-NEXT:   Section number of .text: 1
+# CHECK-NEXT:   Section number of .data: 3
+# CHECK-NEXT:   Section number of TOC: 0
+# CHECK-NEXT:   Section number of loader data: 6
+# CHECK-NEXT:   Section number of .bss: 4
+# CHECK-NEXT:   Maxium alignment of .text: 0x0
+# CHECK-NEXT:   Maxium alignment of .data: 0x0
+# CHECK-NEXT:   Module type: 0x0
+# CHECK-NEXT:   Cpu type of objects: 0x0
+# CHECK-NEXT:   (Reserved): 0x0
+# CHECK-NEXT:   Maximum stack size: 0x0
+# CHECK-NEXT:   Maximum data size: 0x0
+# CHECK-NEXT:   Reserved for debugger: 0x0
+# CHECK-NEXT:   Text page size: 0x0
+# CHECK-NEXT:   Data page size: 0x0
+# CHECK-NEXT:   Stack page size: 0x0
+# CHECK-NEXT:   Flag: 0x0
+# CHECK-NEXT:   Alignment of thread-local storage: 0x0
+# CHECK-NEXT:   Section number for .tdata: 5
+# CHECK-NEXT:   Section number for .tbss: 0
+# CHECK-NEXT: }
+
+--- !XCOFF
+FileHeader:
+  MagicNumber: 0x1DF
+AuxiliaryHeader:
+  Magic: 0x10B
+Sections:
+  - Flags:       [ STYP_TEXT ]
+    SectionData: "12"
+  - Flags:       [ STYP_TEXT ]
+    SectionData: "34"
+  - Flags:       [ STYP_DATA ]
+    SectionData: "56"
+  - Flags:       [ STYP_BSS ]
+    SectionData: "78"
+  - Flags:       [ STYP_TDATA ]
+    SectionData: "0910"
+  - Flags:       [ STYP_LOADER ]
+    SectionData: "1011"