[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.

348

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.

466

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 ↗

(On Diff #378567)

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 ↗

(On Diff #378567)

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 ↗

(On Diff #378567)

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

47 ↗

(On Diff #378567)

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 ↗

(On Diff #378567)

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.

348

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 ↗

(On Diff #378567)

Yes! The suggestions make sense to me. Thanks!

8 ↗

(On Diff #378567)

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

375

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

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

69 ↗

(On Diff #380586)

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

351–352

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.

375

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

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

92–95

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

1 ↗

(On Diff #380586)

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

50 ↗

(On Diff #380586)

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

69 ↗

(On Diff #380586)

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

74 ↗

(On Diff #380586)

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?

113 ↗

(On Diff #380586)

8 ↗

(On Diff #378567)

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

[DiggerLin]

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

74 ↗

(On Diff #380586)

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

50 ↗

(On Diff #380586)

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

74 ↗

(On Diff #380586)

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

8 ↗

(On Diff #378567)

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

[jhenderson]

Two minor comments, otherwise LGTM.

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

18

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)

51

[Esme]

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

18

Yes, it sounds reasonable to me.

[RKSimon]

llvm/lib/ObjectYAML/XCOFFEmitter.cpp

356

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;
 
 enum ReservedSectionNum : int16_t { N_DEBUG = -2, N_ABS = -1, N_UNDEF = 0 };
 
 enum MagicNumber : uint16_t { XCOFF32 = 0x01DF, XCOFF64 = 0x01F7 };
 
+// This field only exists in the XCOFF64 definition.
+enum AuxHeaderFlags64 : uint16_t {
+  SHR_SYMTAB = 0x8000,  ///< At exec time, create shared symbol table for program
+                        ///< (main program only).
+  FORK_POLICY = 0x4000, ///< Forktree policy specified (main program only).
+  FORK_COR = 0x2000     ///< If _AOUT_FORK_POLICY is set, specify copy-on-reference
+                        ///< if this bit is set. Specify copy-on- write otherwise.
+                        ///< If _AOUT_FORK_POLICY is 0, this bit is reserved for
+                        ///< future use and should be set to 0.
+};
+
 // x_smclas field of x_csect from system header: /usr/include/syms.h
 /// Storage Mapping Class definitions.
 enum StorageMappingClass : uint8_t {
   //     READ ONLY CLASSES
   XMC_PR = 0,      ///< Program Code
   XMC_RO = 1,      ///< Read Only Constant
   XMC_DB = 2,      ///< Debug Dictionary Table
   XMC_GL = 6,      ///< Global Linkage (Interfile Interface Code)

llvm/include/llvm/ObjectYAML/XCOFFYAML.h

struct FileHeader {
   uint16_t NumberOfSections;
   int32_t TimeStamp;
   llvm::yaml::Hex64 SymbolTableOffset;
   int32_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 multiple input
+  // sections still have the 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.SecNumOfTBSS)
+        InitAuxFileHdr.SecNumOfTBSS = 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.getValueOr(yaml::Hex16(1)));
+  W.write<uint16_t>(InitAuxFileHdr.Version.getValueOr(yaml::Hex16(1)));
+  if (Is64Bit) {
+    W.OS.write_zeros(4); // Reserved for debugger.
+    W.write<uint64_t>(InitAuxFileHdr.TextStartAddr.getValueOr(yaml::Hex64(0)));
+    W.write<uint64_t>(InitAuxFileHdr.DataStartAddr.getValueOr(yaml::Hex64(0)));
+    W.write<uint64_t>(InitAuxFileHdr.TOCAnchorAddr.getValueOr(yaml::Hex64(0)));
+  } else {
+    W.write<uint32_t>(InitAuxFileHdr.TextSize.getValueOr(yaml::Hex32(0)));
+    W.write<uint32_t>(InitAuxFileHdr.InitDataSize.getValueOr(yaml::Hex32(0)));
+    W.write<uint32_t>(InitAuxFileHdr.BssDataSize.getValueOr(yaml::Hex32(0)));
+    W.write<uint32_t>(InitAuxFileHdr.EntryPointAddr.getValueOr(yaml::Hex32(0)));
+    W.write<uint32_t>(InitAuxFileHdr.TextStartAddr.getValueOr(yaml::Hex32(0)));
+    W.write<uint32_t>(InitAuxFileHdr.DataStartAddr.getValueOr(yaml::Hex32(0)));
+    W.write<uint32_t>(InitAuxFileHdr.TOCAnchorAddr.getValueOr(yaml::Hex32(0)));
+  }
+  W.write<uint16_t>(InitAuxFileHdr.SecNumOfEntryPoint.getValueOr(0));
+  W.write<uint16_t>(InitAuxFileHdr.SecNumOfText.getValueOr(0));
+  W.write<uint16_t>(InitAuxFileHdr.SecNumOfData.getValueOr(0));
+  W.write<uint16_t>(InitAuxFileHdr.SecNumOfTOC.getValueOr(0));
+  W.write<uint16_t>(InitAuxFileHdr.SecNumOfLoader.getValueOr(0));
+  W.write<uint16_t>(InitAuxFileHdr.SecNumOfBSS.getValueOr(0));
+  W.write<uint16_t>(InitAuxFileHdr.MaxAlignOfText.getValueOr(yaml::Hex16(0)));
+  W.write<uint16_t>(InitAuxFileHdr.MaxAlignOfData.getValueOr(yaml::Hex16(0)));
+  W.write<uint16_t>(InitAuxFileHdr.ModuleType.getValueOr(yaml::Hex16(0)));
+  W.write<uint8_t>(InitAuxFileHdr.CpuFlag.getValueOr(yaml::Hex8(0)));
+  W.write<uint8_t>(0); // Reserved for CPU type.
+  if (Is64Bit) {
+    W.write<uint8_t>(InitAuxFileHdr.TextPageSize.getValueOr(yaml::Hex8(0)));
+    W.write<uint8_t>(InitAuxFileHdr.DataPageSize.getValueOr(yaml::Hex8(0)));
+    W.write<uint8_t>(InitAuxFileHdr.StackPageSize.getValueOr(yaml::Hex8(0)));
+    W.write<uint8_t>(
+        InitAuxFileHdr.FlagAndTDataAlignment.getValueOr(yaml::Hex8(0x80)));
+    W.write<uint64_t>(InitAuxFileHdr.TextSize.getValueOr(yaml::Hex64(0)));
+    W.write<uint64_t>(InitAuxFileHdr.InitDataSize.getValueOr(yaml::Hex64(0)));
+    W.write<uint64_t>(InitAuxFileHdr.BssDataSize.getValueOr(yaml::Hex64(0)));
+    W.write<uint64_t>(InitAuxFileHdr.EntryPointAddr.getValueOr(yaml::Hex64(0)));
+    W.write<uint64_t>(InitAuxFileHdr.MaxStackSize.getValueOr(yaml::Hex64(0)));
+    W.write<uint64_t>(InitAuxFileHdr.MaxDataSize.getValueOr(yaml::Hex64(0)));
+  } else {
+    W.write<uint32_t>(InitAuxFileHdr.MaxStackSize.getValueOr(yaml::Hex32(0)));
+    W.write<uint32_t>(InitAuxFileHdr.MaxDataSize.getValueOr(yaml::Hex32(0)));
+    W.OS.write_zeros(4); // Reserved for debugger.
+    W.write<uint8_t>(InitAuxFileHdr.TextPageSize.getValueOr(yaml::Hex8(0)));
+    W.write<uint8_t>(InitAuxFileHdr.DataPageSize.getValueOr(yaml::Hex8(0)));
+    W.write<uint8_t>(InitAuxFileHdr.StackPageSize.getValueOr(yaml::Hex8(0)));
+    W.write<uint8_t>(
+        InitAuxFileHdr.FlagAndTDataAlignment.getValueOr(yaml::Hex8(0)));
+  }
+  W.write<uint16_t>(InitAuxFileHdr.SecNumOfTData.getValueOr(0));
+  W.write<uint16_t>(InitAuxFileHdr.SecNumOfTBSS.getValueOr(0));
+  if (Is64Bit) {
+    W.write<uint16_t>(InitAuxFileHdr.Flag.getValueOr(yaml::Hex16(XCOFF::SHR_SYMTAB)));
+    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;
if (YamlSec.SectionData.binary_size()) {
       if (PaddingSize < 0) {
         ErrHandler("redundant data was written before section data");
         return false;
       }
       W.OS.write_zeros(PaddingSize);
       YamlSec.SectionData.writeAsBinary(W.OS);
     }
   }
   return true;
 }
 
 bool XCOFFWriter::writeRelocations() {
   for (uint16_t I = 0, E = Obj.Sections.size(); I < E; ++I) {
     XCOFFYAML::Section YamlSec = Obj.Sections[I];
     if (!YamlSec.Relocations.empty()) {
       int64_t PaddingSize =
           InitSections[I].FileOffsetToRelocations - (W.OS.tell() - StartOffset);
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-defaults.yaml

+## Test that yaml2obj automatically sets fields of the auxiliary file header
+## if not set explicitly.
+
+## Case1: if text/data/bss/tdata/tbss/loader sections are set and corresponding
+##        fields in the aux header are omitted, we use the derived values of
+##        those sections to set corresponding fields.
+# RUN: yaml2obj %s --docnum=1 -o %t1
+# RUN: llvm-readobj --auxiliary-header %t1 | FileCheck %s --check-prefix=CASE1
+
+# CASE1:      AuxiliaryHeader {
+# CASE1-NEXT:   Magic: 0x10B
+# CASE1-NEXT:   Version: 0x1
+# CASE1-NEXT:   Size of .text section: 0x8
+# CASE1-NEXT:   Size of .data section: 0x8
+# CASE1-NEXT:   Size of .bss section: 0x8
+# CASE1-NEXT:   Entry point address: 0x0
+# CASE1-NEXT:   .text section start address: 0x4
+# CASE1-NEXT:   .data section start address: 0x10
+# CASE1-NEXT:   TOC anchor address: 0x0
+# CASE1-NEXT:   Section number of entryPoint: 0
+# CASE1-NEXT:   Section number of .text: 2
+# CASE1-NEXT:   Section number of .data: 4
+# CASE1-NEXT:   Section number of TOC: 0
+# CASE1-NEXT:   Section number of loader data: 12
+# CASE1-NEXT:   Section number of .bss: 6
+# CASE1-NEXT:   Maxium alignment of .text: 0x0
+# CASE1-NEXT:   Maxium alignment of .data: 0x0
+# CASE1-NEXT:   Module type: 0x0
+# CASE1-NEXT:   CPU type of objects: 0x0
+# CASE1-NEXT:   (Reserved): 0x0
+# CASE1-NEXT:   Maximum stack size: 0x0
+# CASE1-NEXT:   Maximum data size: 0x0
+# CASE1-NEXT:   Reserved for debugger: 0x0
+# CASE1-NEXT:   Text page size: 0x0
+# CASE1-NEXT:   Data page size: 0x0
+# CASE1-NEXT:   Stack page size: 0x0
+# CASE1-NEXT:   Flag: 0x0
+# CASE1-NEXT:   Alignment of thread-local storage: 0x0
+# CASE1-NEXT:   Section number for .tdata: 8
+# CASE1-NEXT:   Section number for .tbss: 10
+# CASE1-NEXT: }
+
+--- !XCOFF
+FileHeader:
+  MagicNumber: [[MAGIC=0x1DF]]
+AuxiliaryHeader:
+  Magic: 0x10B
+Sections:
+  - Flags:       [ STYP_PAD ]
+    SectionData: "1234"
+## Set two sections with different contents for a given type to
+## demonstrate that the values in the aux header depend on the first one.
+  - Flags:       [ STYP_TEXT ]
+    SectionData: "1234000000"
+  - Flags:       [ STYP_TEXT ]
+    SectionData: "1234"
+  - Flags:       [ STYP_DATA ]
+    SectionData: "1234000000"
+  - Flags:       [ STYP_DATA ]
+    SectionData: "1234"
+  - Flags:       [ STYP_BSS ]
+    SectionData: "1234000000"
+  - Flags:       [ STYP_BSS ]
+    SectionData: "1234"
+  - Flags:       [ STYP_TDATA ]
+    SectionData: "1234000000"
+  - Flags:       [ STYP_TDATA ]
+    SectionData: "1234"
+  - Flags:       [ STYP_TBSS ]
+    SectionData: "1234000000"
+  - Flags:       [ STYP_TBSS ]
+    SectionData: "1234"
+  - Flags:       [ STYP_LOADER ]
+    SectionData: "1234000000"
+  - Flags:       [ STYP_LOADER ]
+    SectionData: "1234"
+
+## Case2: same as case1, except producing 64-bit output.
+# RUN: yaml2obj %s --docnum=1 -DMAGIC=0x1F7 -o %t2
+# RUN: llvm-readobj --auxiliary-header %t2 | FileCheck %s --check-prefix=CASE2
+
+## Case2: same as case1, except it is 64-bit.
+# RUN: yaml2obj %s --docnum=1 -DMAGIC=0x1F7 -o %t2
+# RUN: llvm-readobj --auxiliary-header %t2 | FileCheck %s --check-prefix=CASE2
+
+# CASE2:      AuxiliaryHeader {
+# CASE2-NEXT:   Magic: 0x10B
+# CASE2-NEXT:   Version: 0x1
+# CASE2-NEXT:   Reserved for debugger: 0x0
+# CASE2-NEXT:   .text section start address: 0x2
+# CASE2-NEXT:   .data section start address: 0xE
+# CASE2-NEXT:   TOC anchor address: 0x0
+# CASE2-NEXT:   Section number of entryPoint: 0
+# CASE2-NEXT:   Section number of .text: 2
+# CASE2-NEXT:   Section number of .data: 4
+# CASE2-NEXT:   Section number of TOC: 0
+# CASE2-NEXT:   Section number of loader data: 12
+# CASE2-NEXT:   Section number of .bss: 6
+# CASE2-NEXT:   Maxium alignment of .text: 0x0
+# CASE2-NEXT:   Maxium alignment of .data: 0x0
+# CASE2-NEXT:   Module type: 0x0
+# CASE2-NEXT:   CPU type of objects: 0x0
+# CASE2-NEXT:   (Reserved): 0x0
+# CASE2-NEXT:   Text page size: 0x0
+# CASE2-NEXT:   Data page size: 0x0
+# CASE2-NEXT:   Stack page size: 0x0
+# CASE2-NEXT:   Flag: 0x0
+# CASE2-NEXT:   Alignment of thread-local storage: 0x0
+# CASE2-NEXT:   Size of .text section: 0x8
+# CASE2-NEXT:   Size of .data section: 0x8
+# CASE2-NEXT:   Size of .bss section: 0x8
+# CASE2-NEXT:   Entry point address: 0x0
+# CASE2-NEXT:   Maximum stack size: 0x0
+# CASE2-NEXT:   Maximum data size: 0x0
+# CASE2-NEXT:   Section number for .tdata: 8
+# CASE2-NEXT:   Section number for .tbss: 10
+# CASE2-NEXT:   Additional flags 64-bit XCOFF: 0x8000
+# CASE2-NEXT: }
+
+## Case3: if all fields in the aux header are omitted and text/data/bss/tdata/tbss/loader
+##        sections are not set, we set the fields using default values.
+# RUN: yaml2obj %s --docnum=2 -o %t3
+# RUN: llvm-readobj --auxiliary-header %t3 | FileCheck %s --check-prefix=CASE3
+
+# CASE3:      AuxiliaryHeader {
+# CASE3-NEXT:   Magic: 0x1
+# CASE3-NEXT:   Version: 0x1
+# CASE3-NEXT:   Size of .text section: 0x0
+# CASE3-NEXT:   Size of .data section: 0x0
+# CASE3-NEXT:   Size of .bss section: 0x0
+# CASE3-NEXT:   Entry point address: 0x0
+# CASE3-NEXT:   .text section start address: 0x0
+# CASE3-NEXT:   .data section start address: 0x0
+# CASE3-NEXT:   TOC anchor address: 0x0
+# CASE3-NEXT:   Section number of entryPoint: 0
+# CASE3-NEXT:   Section number of .text: 0
+# CASE3-NEXT:   Section number of .data: 0
+# CASE3-NEXT:   Section number of TOC: 0
+# CASE3-NEXT:   Section number of loader data: 0
+# CASE3-NEXT:   Section number of .bss: 0
+# CASE3-NEXT:   Maxium alignment of .text: 0x0
+# CASE3-NEXT:   Maxium alignment of .data: 0x0
+# CASE3-NEXT:   Module type: 0x0
+# CASE3-NEXT:   CPU type of objects: 0x0
+# CASE3-NEXT:   (Reserved): 0x0
+# CASE3-NEXT:   Maximum stack size: 0x0
+# CASE3-NEXT:   Maximum data size: 0x0
+# CASE3-NEXT:   Reserved for debugger: 0x0
+# CASE3-NEXT:   Text page size: 0x0
+# CASE3-NEXT:   Data page size: 0x0
+# CASE3-NEXT:   Stack page size: 0x0
+# CASE3-NEXT:   Flag: 0x0
+# CASE3-NEXT:   Alignment of thread-local storage: 0x0
+# CASE3-NEXT:   Section number for .tdata: 0
+# CASE3-NEXT:   Section number for .tbss: 0
+# CASE3-NEXT: }
+
+--- !XCOFF
+FileHeader:
+  MagicNumber: [[MAGIC=0x1DF]]
+AuxiliaryHeader:
+
+## Case4: same as case3, except producing 64-bit output.
+# RUN: yaml2obj %s --docnum=2 -DMAGIC=0x1F7 -o %t4
+# RUN: llvm-readobj --auxiliary-header %t4 | FileCheck %s --check-prefix=CASE4
+
+# CASE4:      AuxiliaryHeader {
+# CASE4-NEXT:   Magic: 0x1
+# CASE4-NEXT:   Version: 0x1
+# CASE4-NEXT:   Reserved for debugger: 0x0
+# CASE4-NEXT:   .text section start address: 0x0
+# CASE4-NEXT:   .data section start address: 0x0
+# CASE4-NEXT:   TOC anchor address: 0x0
+# CASE4-NEXT:   Section number of entryPoint: 0
+# CASE4-NEXT:   Section number of .text: 0
+# CASE4-NEXT:   Section number of .data: 0
+# CASE4-NEXT:   Section number of TOC: 0
+# CASE4-NEXT:   Section number of loader data: 0
+# CASE4-NEXT:   Section number of .bss: 0
+# CASE4-NEXT:   Maxium alignment of .text: 0x0
+# CASE4-NEXT:   Maxium alignment of .data: 0x0
+# CASE4-NEXT:   Module type: 0x0
+# CASE4-NEXT:   CPU type of objects: 0x0
+# CASE4-NEXT:   (Reserved): 0x0
+# CASE4-NEXT:   Text page size: 0x0
+# CASE4-NEXT:   Data page size: 0x0
+# CASE4-NEXT:   Stack page size: 0x0
+# CASE4-NEXT:   Flag: 0x0
+# CASE4-NEXT:   Alignment of thread-local storage: 0x0
+# CASE4-NEXT:   Size of .text section: 0x0
+# CASE4-NEXT:   Size of .data section: 0x0
+# CASE4-NEXT:   Size of .bss section: 0x0
+# CASE4-NEXT:   Entry point address: 0x0
+# CASE4-NEXT:   Maximum stack size: 0x0
+# CASE4-NEXT:   Maximum data size: 0x0
+# CASE4-NEXT:   Section number for .tdata: 0
+# CASE4-NEXT:   Section number for .tbss: 0
+# CASE4-NEXT:   Additional flags 64-bit XCOFF: 0x8000
+# CASE4-NEXT: }

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

+## Test that we can explicitly specify all fields of the auxiliary file header.
+## Notice that the values aren't derived from the sections if we explicitly set the fields.
+
+# RUN: yaml2obj %s -o %t1
+# RUN: llvm-readobj --auxiliary-header %t1 | FileCheck %s --check-prefix=CHECK32
+# RUN: yaml2obj %s -DMAGIC=0x1F7 -DFLAG64=0x2 -o %t2
+# RUN: llvm-readobj --auxiliary-header %t2 | FileCheck %s --check-prefix=CHECK64
+
+# CHECK32:      Format: aixcoff-rs6000
+# CHECK32-NEXT: Arch: powerpc
+# CHECK32-NEXT: AddressSize: 32bit
+# CHECK32-NEXT: AuxiliaryHeader {
+# CHECK32-NEXT:   Magic: 0x10B
+# CHECK32-NEXT:   Version: 0x1
+# CHECK32-NEXT:   Size of .text section: 0x8
+# CHECK32-NEXT:   Size of .data section: 0x9
+# CHECK32-NEXT:   Size of .bss section: 0x10
+# CHECK32-NEXT:   Entry point address: 0x1111
+# CHECK32-NEXT:   .text section start address: 0x2222
+# CHECK32-NEXT:   .data section start address: 0x3333
+# CHECK32-NEXT:   TOC anchor address: 0x4444
+# CHECK32-NEXT:   Section number of entryPoint: 1
+# CHECK32-NEXT:   Section number of .text: 2
+# CHECK32-NEXT:   Section number of .data: 3
+# CHECK32-NEXT:   Section number of TOC: 4
+# CHECK32-NEXT:   Section number of loader data: 5
+# CHECK32-NEXT:   Section number of .bss: 6
+# CHECK32-NEXT:   Maxium alignment of .text: 0x7
+# CHECK32-NEXT:   Maxium alignment of .data: 0x3
+# CHECK32-NEXT:   Module type: 0x0
+# CHECK32-NEXT:   CPU type of objects: 0x1
+# CHECK32-NEXT:   (Reserved): 0x0
+# CHECK32-NEXT:   Maximum stack size: 0x0
+# CHECK32-NEXT:   Maximum data size: 0x0
+# CHECK32-NEXT:   Reserved for debugger: 0x0
+# CHECK32-NEXT:   Text page size: 0x1
+# CHECK32-NEXT:   Data page size: 0x1
+# CHECK32-NEXT:   Stack page size: 0x1
+# CHECK32-NEXT:   Flag: 0x0
+# CHECK32-NEXT:   Alignment of thread-local storage: 0x1
+# CHECK32-NEXT:   Section number for .tdata: 7
+# CHECK32-NEXT:   Section number for .tbss: 8
+# CHECK32-NEXT: }
+
+# CHECK64:      Format: aix5coff64-rs6000
+# CHECK64-NEXT: Arch: powerpc64
+# CHECK64-NEXT: AddressSize: 64bit
+# CHECK64-NEXT: AuxiliaryHeader {
+# CHECK64-NEXT:   Magic: 0x10B
+# CHECK64-NEXT:   Version: 0x1
+# CHECK64-NEXT:   Reserved for debugger: 0x0
+# CHECK64-NEXT:   .text section start address: 0x2222
+# CHECK64-NEXT:   .data section start address: 0x3333
+# CHECK64-NEXT:   TOC anchor address: 0x4444
+# CHECK64-NEXT:   Section number of entryPoint: 1
+# CHECK64-NEXT:   Section number of .text: 2
+# CHECK64-NEXT:   Section number of .data: 3
+# CHECK64-NEXT:   Section number of TOC: 4
+# CHECK64-NEXT:   Section number of loader data: 5
+# CHECK64-NEXT:   Section number of .bss: 6
+# CHECK64-NEXT:   Maxium alignment of .text: 0x7
+# CHECK64-NEXT:   Maxium alignment of .data: 0x3
+# CHECK64-NEXT:   Module type: 0x0
+# CHECK64-NEXT:   CPU type of objects: 0x1
+# CHECK64-NEXT:   (Reserved): 0x0
+# CHECK64-NEXT:   Text page size: 0x1
+# CHECK64-NEXT:   Data page size: 0x1
+# CHECK64-NEXT:   Stack page size: 0x1
+# CHECK64-NEXT:   Flag: 0x0
+# CHECK64-NEXT:   Alignment of thread-local storage: 0x0
+# CHECK64-NEXT:   Size of .text section: 0x8
+# CHECK64-NEXT:   Size of .data section: 0x9
+# CHECK64-NEXT:   Size of .bss section: 0x10
+# CHECK64-NEXT:   Entry point address: 0x1111
+# CHECK64-NEXT:   Maximum stack size: 0x0
+# CHECK64-NEXT:   Maximum data size: 0x0
+# CHECK64-NEXT:   Section number for .tdata: 7
+# CHECK64-NEXT:   Section number for .tbss: 8
+# CHECK64-NEXT:   Additional flags 64-bit XCOFF: 0x2
+# CHECK64-NEXT: }
+
+--- !XCOFF
+FileHeader:
+  MagicNumber: [[MAGIC=0x1DF]]
+AuxiliaryHeader:
+  Magic:                 0x10B
+  Version:               0x1
+  TextSectionSize:       0x8
+  DataSectionSize:       0x9
+  BssSectionSize:        0x10
+  EntryPointAddr:        0x1111
+  TextStartAddr:         0x2222
+  DataStartAddr:         0x3333
+  TOCAnchorAddr:         0x4444
+  SecNumOfEntryPoint:    1
+  SecNumOfText:          2
+  SecNumOfData:          3
+  SecNumOfTOC:           4
+  SecNumOfLoader:        5
+  SecNumOfBSS:           6
+  MaxAlignOfText:        0x7
+  MaxAlignOfData:        0x3
+  ModuleType:            0x1
+  TextPageSize:          0x1
+  DataPageSize:          0x1
+  StackPageSize:         0x1
+  SecNumOfTData:         7
+  SecNumOfTBSS:          8
+  FlagAndTDataAlignment: 0x1
+  Flag:                  [[FLAG64=<none>]]
+Sections:
+  - Flags:       [ STYP_TEXT ]
+    SectionData: "1232"
+  - Flags:       [ STYP_DATA ]
+    SectionData: "5678"
+  - Flags:       [ STYP_BSS ]
+    SectionData: "9101"
+  - Flags:       [ STYP_TDATA ]
+    SectionData: "1112"
+  - Flags:       [ STYP_TBSS ]
+    SectionData: "1314"
+  - Flags:       [ STYP_LOADER ]
+    SectionData: "1516"