[NFC][XCOFF] Refactor and format XCOFFObjectWriter.cpp.

[DiggerLin]

llvm/lib/MC/XCOFFObjectWriter.cpp

558–559

do we still need is64Bit() ?

559–561

" in 32-bit mode" will be deleted ?

652–658

change writeSymbolBody to writeSymbolEntry ?

654

do we want to set a default AuxCnt=1 ?

665–666

delete the comment.

669

change Name to writeSymbolAuxCsectEntry ?

671

I am not sure which ( "x_scnlen" or "SectionOrLength")one is better for comment ? maybe the SectionOrLength from XCOFFObjectFile.h is better.

680

function name change to writeSymbolAuxDwarfEntry ?

725–731

since the header is for 32bit.

W.write<uint32_t>(SymbolTableOffset);    // f_symptr
W.write<int32_t>(SymbolTableEntryCount); // f_nsyms

we should modify the code
as
assert(!is64Bit() && "not support 64 bit for writing file header.");
W.write<uint16_t>(XCOFF::XCOFF32);

756–758

I do not think we need the s_size here , Sec->Size can self-explain.
ditto for the following.

[DiggerLin]

llvm/lib/MC/XCOFFObjectWriter.cpp

816–817

we can use ".file" directly instead of StringRef(".file")

[Esme]

Addressed @DiggerLin 's comments. Thanks

llvm/lib/MC/XCOFFObjectWriter.cpp

671

I am not sure which ( "x_scnlen" or "SectionOrLength")one is better for comment ? maybe the SectionOrLength from XCOFFObjectFile.h is better.

671

I would prefer the x_scnlen one because it is easier for the developer to refer to the documentation, and this comment style references ELFObjectWriter.cpp.

725–731

Thanks!
Well, I don't think we need assertions here, because we already blocked 64-bit mode with another assertion before calling this function.

756–758

Removed // s_size and // s_flags, and kept other comments.

[DiggerLin]

llvm/lib/MC/XCOFFObjectWriter.cpp

201

change to
constexpr uint64_t MaxRawDataSize =

[DiggerLin]

llvm/lib/MC/XCOFFObjectWriter.cpp

201

sorry should be change to const uint64_t MaxRawDataSize =

[DiggerLin]

llvm/lib/MC/XCOFFObjectWriter.cpp

274

using writeSymbolAuxCsectEntry(uint64_t SecLen, uint8_t Type, uint8_t MapClass) is easy to understand the interface than writeSymbolAuxCsectEntry(uint64_t, uint8_t, uint8_t);
same as
writeSymbolAuxDwarfEntry
writeSymbolEntry

652

uint64_t Value--> uint32_t Value

655

maybe better to change the AuxCnt to NumberOfAuxEntries ?
change SecIdx to SectionNumber
etc ,
I think the parameter name should be consistent with XCOFFObject.h.

same as function
writeSymbolAuxDwarfEntry and writeSymbolAuxCsectEntry

671

the function looks only support 32bit AuxCsect now . "uint64_t SecLen" should be "uint32_t SecLen"? if we change to "uint32_t SecLen"

W.write<uint32_t>(Lo_32(SecLen)); // x_scnlen

also need to be changed.

682

"uint64_t SecLen" should be "uint32_t SecLen" ? and "uint64_t RelCnt" should be "uint32_t RelCnt"

708

change "DwarfSectionRef.getSymbolTableName(), 0, SectionIndex, 0,"
-->
DwarfSectionRef.getSymbolTableName(), /*Value=*/0, SectionIndex,/*Type=*/ 0,

adding comment will make the value "0" easy to understand.

718

add a comment for value 0, ditto in the following value zero or 1

[jhenderson]

llvm/lib/MC/XCOFFObjectWriter.cpp

272–275

Please provide the parameter names here.

683

Default arguments are usually specified in the declaration, not definition. Same elsewhere.

690

For consistency with other names.

725–731

I'd have the assertion: in the future, you may not call this function from the same place.

812

Ditto the line below.

[Esme]

Addressed @DiggerLin and @jhenderson 's comments. Thanks!

[Esme]

Updated comments for consistency with parameters' names.

[jhenderson]

llvm/lib/MC/XCOFFObjectWriter.cpp

699

Here and similar comments elsewhere, the format is as suggested inline.

[DiggerLin]

llvm/lib/MC/XCOFFObjectWriter.cpp

657

the writeSymbolName(SymbolName) can self explain .
the comment "Magic, Offset, SymbolName " description of functionality of the writeSymbolName(), if you want to put the comment, it maybe better to put before the function writeSymbolName definition.

[Esme]

Addressed comments.

[jhenderson]

LGTM, but please wait for @DiggerLin

[DiggerLin]

LGTM , but need to fix two comments.

llvm/lib/MC/XCOFFObjectWriter.cpp

641

Nit: // Magic, Offset or SymbolName.

820

writeSymbolEntry(".file", /*Type=*/0, XCOFF::ReservedSectionNum::N_DEBUG,

->
writeSymbolEntry(".file", /*Value=*/0, XCOFF::ReservedSectionNum::N_DEBUG,

llvm/lib/MC/XCOFFObjectWriter.cpp

class XCOFFObjectWriter : public MCObjectWriter {
   uint32_t SymbolTableOffset = 0;
   uint16_t SectionCount = 0;
   uint32_t RelocationEntryOffset = 0;
 
   support::endian::Writer W;
   std::unique_ptr<MCXCOFFObjectTargetWriter> TargetObjectWriter;
   StringTableBuilder Strings;
 
+  uint64_t MaxRawDataSize =
+      TargetObjectWriter->is64Bit() ? UINT64_MAX : UINT32_MAX;
+
   // Maps the MCSection representation to its corresponding XCOFFSection
   // wrapper. Needed for finding the XCOFFSection to insert an MCSymbol into
   // from its containing MCSectionXCOFF.
   DenseMap<const MCSectionXCOFF *, XCOFFSection *> SectionMap;
 
   // Maps the MCSymbol representation to its corrresponding symbol table index.
   // Needed for relocation.
   DenseMap<const MCSymbol *, uint32_t> SymbolIndexMap;
class XCOFFObjectWriter : public MCObjectWriter {
 
   void executePostLayoutBinding(MCAssembler &, const MCAsmLayout &) override;
 
   void recordRelocation(MCAssembler &, const MCAsmLayout &, const MCFragment *,
                         const MCFixup &, MCValue, uint64_t &) override;
 
   uint64_t writeObject(MCAssembler &, const MCAsmLayout &) override;
 
+  bool is64Bit() const { return TargetObjectWriter->is64Bit(); }
   static bool nameShouldBeInStringTable(const StringRef &);
   void writeSymbolName(const StringRef &);
   void writeSymbolTableEntryForCsectMemberLabel(const Symbol &,
                                                 const XCOFFSection &, int16_t,
                                                 uint64_t);
   void writeSymbolTableEntryForControlSection(const XCOFFSection &, int16_t,
                                               XCOFF::StorageClass);
   void writeSymbolTableEntryForDwarfSection(const XCOFFSection &, int16_t);
   void writeFileHeader();
   void writeSectionHeaderTable();
   void writeSections(const MCAssembler &Asm, const MCAsmLayout &Layout);
   void writeSectionForControlSectionEntry(const MCAssembler &Asm,
                                           const MCAsmLayout &Layout,
                                           const CsectSectionEntry &CsectEntry,
                                           uint32_t &CurrentAddressLocation);
   void writeSectionForDwarfSectionEntry(const MCAssembler &Asm,
                                         const MCAsmLayout &Layout,
                                         const DwarfSectionEntry &DwarfEntry,
                                         uint32_t &CurrentAddressLocation);
   void writeSymbolTable(const MCAsmLayout &Layout);
+  void writeSymbolAuxDwarfEntry(uint64_t, uint64_t);
+  void writeSymbolAuxCsectEntry(uint64_t, uint8_t, uint8_t);
+  void writeSymbolEntry(StringRef, uint64_t, int16_t, uint16_t, uint8_t,
+                        uint8_t);
   void writeRelocations();
   void writeRelocation(XCOFFRelocation Reloc, const XCOFFSection &Section);
 
   // Called after all the csects and symbols have been processed by
   // `executePostLayoutBinding`, this function handles building up the majority
   // of the structures in the object file representation. Namely:
   // *) Calculates physical/virtual addresses, raw-pointer offsets, and section
   //    sizes.
else if (Type == XCOFF::RelocationType::R_TOC ||
     const int64_t TOCEntryOffset = SectionMap[SymASec]->Address -
                                    TOCCsects.front().Address +
                                    Target.getConstant();
     if (Type == XCOFF::RelocationType::R_TOC && !isInt<16>(TOCEntryOffset))
       report_fatal_error("TOCEntryOffset overflows in small code model mode");
 
     FixedValue = TOCEntryOffset;
   }
 
-  assert(
-      (TargetObjectWriter->is64Bit() ||
-       Fixup.getOffset() <= UINT32_MAX - Layout.getFragmentOffset(Fragment)) &&
-      "Fragment offset + fixup offset is overflowed in 32-bit mode.");
+  assert((Fixup.getOffset() <=
+          MaxRawDataSize - Layout.getFragmentOffset(Fragment)) &&
+         "Fragment offset + fixup offset is overflowed.");
   uint32_t FixupOffsetInCsect =
       Layout.getFragmentOffset(Fragment) + Fixup.getOffset();
 
   XCOFFRelocation Reloc = {Index, FixupOffsetInCsect, SignAndSize, Type};
   MCSectionXCOFF *RelocationSec = cast<MCSectionXCOFF>(Fragment->getParent());
   assert(SectionMap.find(RelocationSec) != SectionMap.end() &&
          "Expected containing csect to exist in map.");
   SectionMap[RelocationSec]->Relocations.push_back(Reloc);

 uint64_t XCOFFObjectWriter::writeObject(MCAssembler &Asm,
                                         const MCAsmLayout &Layout) {
   // We always emit a timestamp of 0 for reproducibility, so ensure incremental
   // linking is not enabled, in case, like with Windows COFF, such a timestamp
   // is incompatible with incremental linking of XCOFF.
   if (Asm.isIncrementalLinkerCompatible())
     report_fatal_error("Incremental linking not supported for XCOFF.");
 
-  if (TargetObjectWriter->is64Bit())
+  if (is64Bit())
     report_fatal_error("64-bit XCOFF object files are not supported yet.");
 
   finalizeSectionInfo();
   uint64_t StartOffset = W.OS.tell();
 
   writeFileHeader();
   writeSectionHeaderTable();
   writeSections(Asm, Layout);
   writeRelocations();
 
   writeSymbolTable(Layout);
   // Write the string table.
   Strings.write(W.OS);
 
   return W.OS.tell() - StartOffset;
 }
 
 bool XCOFFObjectWriter::nameShouldBeInStringTable(const StringRef &SymbolName) {
   return SymbolName.size() > XCOFF::NameSize;
 }
 
 void XCOFFObjectWriter::writeSymbolName(const StringRef &SymbolName) {
   if (nameShouldBeInStringTable(SymbolName)) {
     W.write<int32_t>(0);
     W.write<uint32_t>(Strings.getOffset(SymbolName));
   } else {
-    char Name[XCOFF::NameSize+1];
+    char Name[XCOFF::NameSize + 1];
     std::strncpy(Name, SymbolName.data(), XCOFF::NameSize);
     ArrayRef<char> NameRef(Name, XCOFF::NameSize);
     W.write(NameRef);
   }
 }
 
-void XCOFFObjectWriter::writeSymbolTableEntryForCsectMemberLabel(
-    const Symbol &SymbolRef, const XCOFFSection &CSectionRef,
-    int16_t SectionIndex, uint64_t SymbolOffset) {
-  // Name or Zeros and string table offset
-  writeSymbolName(SymbolRef.getSymbolTableName());
-  assert(SymbolOffset <= UINT32_MAX - CSectionRef.Address &&
-         "Symbol address overflows.");
-  W.write<uint32_t>(CSectionRef.Address + SymbolOffset);
-  W.write<int16_t>(SectionIndex);
+void XCOFFObjectWriter::writeSymbolEntry(StringRef SymbolName, uint64_t Value,
+                                         int16_t SecIdx, uint16_t Type,
+                                         uint8_t StorageClass,
+                                         uint8_t AuxCnt = 1) {
+  writeSymbolName(SymbolName); // n_name, n_zeros, n_offset
+  W.write<uint32_t>(Value);    // n_value
+  W.write<int16_t>(SecIdx);    // n_scnum
   // Basic/Derived type. See the description of the n_type field for symbol
   // table entries for a detailed description. Since we don't yet support
   // visibility, and all other bits are either optionally set or reserved, this
   // is always zero.
   // TODO FIXME How to assert a symbol's visibilty is default?
   // TODO Set the function indicator (bit 10, 0x0020) for functions
   // when debugging is enabled.
-  W.write<uint16_t>(0);
-  W.write<uint8_t>(SymbolRef.getStorageClass());
-  // Always 1 aux entry for now.
-  W.write<uint8_t>(1);
-
-  // Now output the auxiliary entry.
-  W.write<uint32_t>(CSectionRef.SymbolTableIndex);
-  // Parameter typecheck hash. Not supported.
-  W.write<uint32_t>(0);
-  // Typecheck section number. Not supported.
-  W.write<uint16_t>(0);
-  // Symbol type: Label
-  W.write<uint8_t>(XCOFF::XTY_LD);
-  // Storage mapping class.
-  W.write<uint8_t>(CSectionRef.MCSec->getMappingClass());
-  // Reserved (x_stab).
-  W.write<uint32_t>(0);
-  // Reserved (x_snstab).
-  W.write<uint16_t>(0);
+  W.write<uint16_t>(Type);        // n_type
+  W.write<uint8_t>(StorageClass); // n_sclass
+  W.write<uint8_t>(AuxCnt);       // n_numaux
+}
+
+void XCOFFObjectWriter::writeSymbolAuxCsectEntry(uint64_t SecLen, uint8_t Type,
+                                                 uint8_t MapClass) {
+  W.write<uint32_t>(Lo_32(SecLen)); // x_scnlen
+  W.write<uint32_t>(0);             // x_parmhash
+  W.write<uint16_t>(0);             // x_snhash
+  W.write<uint8_t>(Type);           // x_smtyp
+  W.write<uint8_t>(MapClass);       // x_smclas
+  W.write<uint32_t>(0);             // x_stab
+  W.write<uint16_t>(0);             // x_snstab
+}
+
+void XCOFFObjectWriter::writeSymbolAuxDwarfEntry(uint64_t SecLen,
+                                                 uint64_t RelCnt = 0) {
+  W.write<uint32_t>(SecLen); // x_scnlen
+  W.OS.write_zeros(4);       // Reserved
+  W.write<uint32_t>(RelCnt); // x_nreloc
+  W.OS.write_zeros(6);       // Reserved
+}
+
+void XCOFFObjectWriter::writeSymbolTableEntryForCsectMemberLabel(
+    const Symbol &SymbolRef, const XCOFFSection &CSectionRef,
+    int16_t SectionIndex, uint64_t SymbolOffset) {
+  assert(SymbolOffset <= MaxRawDataSize - CSectionRef.Address &&
+         "Symbol address overflowed.");
+
+  writeSymbolEntry(SymbolRef.getSymbolTableName(),
+                   CSectionRef.Address + SymbolOffset, SectionIndex, 0,
+                   SymbolRef.getStorageClass());
+
+  writeSymbolAuxCsectEntry(CSectionRef.SymbolTableIndex, XCOFF::XTY_LD,
+                           CSectionRef.MCSec->getMappingClass());
 }
 
 void XCOFFObjectWriter::writeSymbolTableEntryForDwarfSection(
     const XCOFFSection &DwarfSectionRef, int16_t SectionIndex) {
   assert(DwarfSectionRef.MCSec->isDwarfSect() && "Not a DWARF section!");
 
-  // n_name, n_zeros, n_offset
-  writeSymbolName(DwarfSectionRef.getSymbolTableName());
-  // n_value
-  W.write<uint32_t>(0);
-  // n_scnum
-  W.write<int16_t>(SectionIndex);
-  // n_type
-  W.write<uint16_t>(0);
-  // n_sclass
-  W.write<uint8_t>(XCOFF::C_DWARF);
-  // Always 1 aux entry for now.
-  W.write<uint8_t>(1);
-
-  // Now output the auxiliary entry.
-  // x_scnlen
-  W.write<uint32_t>(DwarfSectionRef.Size);
-  // Reserved
-  W.write<uint32_t>(0);
-  // x_nreloc. Set to 0 for now.
-  W.write<uint32_t>(0);
-  // Reserved
-  W.write<uint32_t>(0);
-  // Reserved
-  W.write<uint16_t>(0);
+  writeSymbolEntry(DwarfSectionRef.getSymbolTableName(), 0, SectionIndex, 0,
+                   XCOFF::C_DWARF);
+
+  writeSymbolAuxDwarfEntry(DwarfSectionRef.Size);
 }
 
 void XCOFFObjectWriter::writeSymbolTableEntryForControlSection(
     const XCOFFSection &CSectionRef, int16_t SectionIndex,
     XCOFF::StorageClass StorageClass) {
-  // n_name, n_zeros, n_offset
-  writeSymbolName(CSectionRef.getSymbolTableName());
-  // n_value
-  W.write<uint32_t>(CSectionRef.Address);
-  // n_scnum
-  W.write<int16_t>(SectionIndex);
-  // Basic/Derived type. See the description of the n_type field for symbol
-  // table entries for a detailed description. Since we don't yet support
-  // visibility, and all other bits are either optionally set or reserved, this
-  // is always zero.
-  // TODO FIXME How to assert a symbol's visibilty is default?
-  // TODO Set the function indicator (bit 10, 0x0020) for functions
-  // when debugging is enabled.
-  W.write<uint16_t>(0);
-  // n_sclass
-  W.write<uint8_t>(StorageClass);
-  // Always 1 aux entry for now.
-  W.write<uint8_t>(1);
-
-  // Now output the auxiliary entry.
-  W.write<uint32_t>(CSectionRef.Size);
-  // Parameter typecheck hash. Not supported.
-  W.write<uint32_t>(0);
-  // Typecheck section number. Not supported.
-  W.write<uint16_t>(0);
-  // Symbol type.
-  W.write<uint8_t>(getEncodedType(CSectionRef.MCSec));
-  // Storage mapping class.
-  W.write<uint8_t>(CSectionRef.MCSec->getMappingClass());
-  // Reserved (x_stab).
-  W.write<uint32_t>(0);
-  // Reserved (x_snstab).
-  W.write<uint16_t>(0);
+  writeSymbolEntry(CSectionRef.getSymbolTableName(), CSectionRef.Address,
+                   SectionIndex, 0, StorageClass);
+
+  writeSymbolAuxCsectEntry(CSectionRef.Size, getEncodedType(CSectionRef.MCSec),
+                           CSectionRef.MCSec->getMappingClass());
 }
 
 void XCOFFObjectWriter::writeFileHeader() {
-  // Magic.
-  W.write<uint16_t>(0x01df);
-  // Number of sections.
-  W.write<uint16_t>(SectionCount);
-  // Timestamp field. For reproducible output we write a 0, which represents no
-  // timestamp.
-  W.write<int32_t>(0);
-  // Byte Offset to the start of the symbol table.
-  W.write<uint32_t>(SymbolTableOffset);
-  // Number of entries in the symbol table.
-  W.write<int32_t>(SymbolTableEntryCount);
-  // Size of the optional header.
-  W.write<uint16_t>(0);
-  // Flags.
-  W.write<uint16_t>(0);
+  W.write<uint16_t>(XCOFF::XCOFF32);
+  W.write<uint16_t>(SectionCount);         // f_nscns
+  W.write<int32_t>(0);                     // f_timdat
+  W.write<uint32_t>(SymbolTableOffset);    // f_symptr
+  W.write<int32_t>(SymbolTableEntryCount); // f_nsyms
+  W.write<uint16_t>(0);                    // f_opthdr
+  W.write<uint16_t>(0);                    // f_flags
 }
 
 void XCOFFObjectWriter::writeSectionHeaderTable() {
   auto writeSectionHeader = [&](const SectionEntry *Sec, bool IsDwarf) {
     // Nothing to write for this Section.
     if (Sec->Index == SectionEntry::UninitializedIndex)
       return false;
 
     // Write Name.
     ArrayRef<char> NameRef(Sec->Name, XCOFF::NameSize);
     W.write(NameRef);
 
     // Write the Physical Address and Virtual Address. In an object file these
     // are the same.
     // We use 0 for DWARF sections' Physical and Virtual Addresses.
     if (!IsDwarf) {
-      W.write<uint32_t>(Sec->Address);
+      W.write<uint32_t>(Sec->Address); // s_paddr = s_vaddr
       W.write<uint32_t>(Sec->Address);
     } else {
       W.write<uint32_t>(0);
       W.write<uint32_t>(0);
     }
 
     W.write<uint32_t>(Sec->Size);
-    W.write<uint32_t>(Sec->FileOffsetToData);
-    W.write<uint32_t>(Sec->FileOffsetToRelocations);
-
-    // Line number pointer. Not supported yet.
-    W.write<uint32_t>(0);
-
-    W.write<uint16_t>(Sec->RelocationCount);
-
-    // Line number counts. Not supported yet.
-    W.write<uint16_t>(0);
+    W.write<uint32_t>(Sec->FileOffsetToData);        // s_scnptr
+    W.write<uint32_t>(Sec->FileOffsetToRelocations); // s_relptr
+    W.write<uint32_t>(0); // s_lnnoptr. Not supported yet.
 
+    W.write<uint16_t>(Sec->RelocationCount); // s_nreloc
+    W.write<uint16_t>(0);                    // s_nlnno. Not supported yet.
     W.write<int32_t>(Sec->Flags);
 
     return true;
   };
 
   for (const auto *CsectSec : Sections)
     writeSectionHeader(CsectSec, /* IsDwarf */ false);
   for (const auto &DwarfSec : DwarfSections)
void XCOFFObjectWriter::writeRelocations() {
   for (const auto &DwarfSection : DwarfSections)
     for (const auto &Reloc : DwarfSection.DwarfSect->Relocations)
       writeRelocation(Reloc, *DwarfSection.DwarfSect);
 }
 
 void XCOFFObjectWriter::writeSymbolTable(const MCAsmLayout &Layout) {
   // Write symbol 0 as C_FILE.
   // FIXME: support 64-bit C_FILE symbol.
-  //
-  // n_name. The n_name of a C_FILE symbol is the source filename when no
-  // auxiliary entries are present. The source filename is alternatively
-  // provided by an auxiliary entry, in which case the n_name of the C_FILE
-  // symbol is `.file`.
+  // The n_name of a C_FILE symbol is the source filename when no auxiliary
+  // entries are present. The source filename is alternatively provided by an
+  // auxiliary entry, in which case the n_name of the C_FILE symbol is `.file`.
   // FIXME: add the real source filename.
-  writeSymbolName(".file");
-  // n_value. The n_value of a C_FILE symbol is its symbol table index.
-  W.write<uint32_t>(0);
-  // n_scnum. N_DEBUG is a reserved section number for indicating a special
-  // symbolic debugging symbol.
-  W.write<int16_t>(XCOFF::ReservedSectionNum::N_DEBUG);
-  // n_type. The n_type field of a C_FILE symbol encodes the source language and
-  // CPU version info; zero indicates no info.
-  W.write<uint16_t>(0);
-  // n_sclass. The C_FILE symbol provides source file-name information,
-  // source-language ID and CPU-version ID information and some other optional
-  // infos.
-  W.write<uint8_t>(XCOFF::C_FILE);
-  // n_numaux. No aux entry for now.
-  W.write<uint8_t>(0);
+  writeSymbolEntry(".file", 0, XCOFF::ReservedSectionNum::N_DEBUG, 0,
+                   XCOFF::C_FILE, 0);
 
   for (const auto &Csect : UndefinedCsects) {
     writeSymbolTableEntryForControlSection(Csect,
                                            XCOFF::ReservedSectionNum::N_UNDEF,
                                            Csect.MCSec->getStorageClass());
   }
 
   for (const auto *Section : Sections) {
     if (Section->Index == SectionEntry::UninitializedIndex)
       // Nothing to write for this Section.
       continue;
auto calcOffsetToRelocations = [&](SectionEntry *Sec, bool IsDwarf) {
 
     if (!Sec->RelocationCount)
       return false;
 
     Sec->FileOffsetToRelocations = RawPointer;
     const uint32_t RelocationSizeInSec =
         Sec->RelocationCount * XCOFF::RelocationSerializationSize32;
     RawPointer += RelocationSizeInSec;
-    if (RawPointer > UINT32_MAX)
+    if (RawPointer > MaxRawDataSize)
       report_fatal_error("Relocation data overflowed this object file.");
 
     return true;
   };
 
   for (auto *Sec : Sections)
     calcOffsetToRelocations(Sec, /* IsDwarf */ false);
 
void XCOFFObjectWriter::assignAddressesAndIndices(const MCAsmLayout &Layout) {
   uint64_t RawPointer = XCOFF::FileHeaderSize32 + auxiliaryHeaderSize() +
                         SectionCount * XCOFF::SectionHeaderSize32;
   for (auto *Sec : Sections) {
     if (Sec->Index == SectionEntry::UninitializedIndex || Sec->IsVirtual)
       continue;
 
     Sec->FileOffsetToData = RawPointer;
     RawPointer += Sec->Size;
-    if (RawPointer > UINT32_MAX)
+    if (RawPointer > MaxRawDataSize)
       report_fatal_error("Section raw data overflowed this object file.");
   }
 
   for (auto &DwarfSection : DwarfSections) {
     // Address of csect sections are always aligned to DefaultSectionAlign, but
     // address of DWARF section are aligned to Section alignment which may be
     // bigger than DefaultSectionAlign, need to execlude the padding bits.
     RawPointer =
-          alignTo(RawPointer, DwarfSection.DwarfSect->MCSec->getAlignment());
 
     DwarfSection.FileOffsetToData = RawPointer;
     // Some section entries, like DWARF section size is not aligned, so
     // RawPointer may be not aligned.
     RawPointer += DwarfSection.Size;
     // Make sure RawPointer is aligned.
     RawPointer = alignTo(RawPointer, DefaultSectionAlign);
 
-    assert(RawPointer <= UINT32_MAX &&
+    assert(RawPointer <= MaxRawDataSize &&
            "Section raw data overflowed this object file.");
   }
 
   RelocationEntryOffset = RawPointer;
 }
 
 void XCOFFObjectWriter::writeSectionForControlSectionEntry(
     const MCAssembler &Asm, const MCAsmLayout &Layout,