[XCOFF] support the overflow section (only relocation overflow is handled).

[Esme]

Summary

Handles relocation or line-number field overflows in an XCOFF32 file. (XCOFF64 files may not have overflow section headers.) If a section has more than 65,534 relocation entries or line number entries, both of these fields are set to a value of 65535. In this case, an overflow section header with the s_flags field equal to STYP_OVRFLO is used to contain the relocation and line-number count information.
Since line number is not supported, this patch only handles the relocation overflow.

[DiggerLin]

change the description to 'support the relocation overflow section."

llvm/lib/MC/XCOFFObjectWriter.cpp

931–932

the information of SectionEntry is not enough to identify the the overflow is relocation or line no overflow. I think we need to derived class from SectionEntry and have flag in the derived class to identify the overflow is relocation or line no overflow.

and if the flag is relocation overflow, the Sec->Address will be write in the s_paddr, otherwise Sec->Address will be writen in the s_vaddr

942–943

the IsOvrflo is used to identify overflow section. but for the section which has overflow relocation or line no overflow, the both field of s_nlnno and s_nlnno should be set to same (both 65535) , it looks you not implement it.

1128

why set index to 3 here?

1136

I can not find "the s_relptr must have the same values as in the corresponding primary section header." in the xcoff document.

s_relptr Recognized for the .text , .data , .tdata, and STYP_DWARF sections only.
so the field "s_relptr" in the overflow section should be set to zero?

[DiggerLin]

llvm/lib/MC/XCOFFObjectWriter.cpp

1123

nit : suggest moving the line after the SecEntry.Index=3. put assign the member of SecEntry together.

1136

sorry I found it . please ignore above comment.

1390

since you change the caculation logic of the RawPointer and EndOfAllHeadersOffset in the patch. I suggest to delete the code from line 1185~1193 and

change

uint64_t RawPointer = EndOfAllHeadersOffset;

to

uint64_t RawPointer =
     (is64Bit() ? (XCOFF::FileHeaderSize64 +
                   SectionCount * XCOFF::SectionHeaderSize64)
                : (XCOFF::FileHeaderSize32 +
                   SectionCount * XCOFF::SectionHeaderSize32)) +
     auxiliaryHeaderSize();

at the begine of function void XCOFFObjectWriter::finalizeSectionInfo()

and we can delete the variable "EndOfAllHeadersOffset" from the patch.

[DiggerLin]

llvm/lib/MC/XCOFFObjectWriter.cpp

1126

we do not need to calculate the CurrAddress if there is not Dwarf section. we can delete the CurrAddress and code of calculation of CurrAddress , and get the last element of Sections when calculating the padding before the dwarf section.

for example :

if (!DwarfSections.empty()) {
   CsectSectionEntry * LastCsectSec = Sections.back();
   uint64_t LastCsectSecAddr = LastCsectSec ->Address + LastCsectSet ->Size;
  RawPointer +=
        alignTo(LastCsectSecAddr,
                (*DwarfSections.begin()).DwarfSect->MCSec->getAlignment()) -
        LastCsectSecAddr;
}

[Esme]

In D137819#3925955, @DiggerLin wrote:

change the description to 'support the relocation overflow section."

As the doc says, the overflow section is required when either of the relocation entries or the line number entries exceeds 65,534. As long as one of the counts exceeds 65,534, the other one will also be set to 65535 in the primary section header, and then the overflow section will record actual counts for both relocation entries and line number entries, where the s_paddr for relocation entries and s_vaddr for line number entries.
Therefore I reckon there's no need to identify whether it's a relocation overflow section or line number overflow section.

llvm/lib/MC/XCOFFObjectWriter.cpp

931–932

As my previous comments, there's no need to identify whether it's a relocation overflow section or line number overflow section.
Since the line number is not supported, set the Virtual Address, which specifies the number of line-number entries actually required, to 0.

942–943

Oh I see, I should check (IsOvrflo || Sec->RelocationCount == XCOFF::RelocOverflow).

1126

We skip over some sections in the loop:

if (Sec->Index == SectionEntry::UninitializedIndex || Sec->IsVirtual)
  continue;

So LastCsectSecAddr may not equal to CurrAddress if the last section satisfies (Sec->Index == SectionEntry::UninitializedIndex || Sec->IsVirtual).

1128

I set it as 3 it during debug, but forgot to delete it. Thank you for finding it.

[jhenderson]

The functionality of this patch is best left for @DiggerLin to review, so I've kept my comments to stylistic ones.

llvm/lib/MC/XCOFFObjectWriter.cpp

286

Not sure why you're abbreviating here. Just use OverflowSections.

413

Again, OverflowSec would be preferable.

931–932

932–936

Either "for the overflow section" or "for overflow sections".

934

945

1117

General consensus is that lambdas should be named like variables, because they are function objects, not functions. I.e. CountRelocations, not countRelocations.

That being said, this lambda is to long. Pull it out into a helper function instead.

1120

Nit: prefer static_cast to C-style cast.

1126

Prefer static_cast.

1127

Again, this lambda is too long - pull it into a helper function.

1129

Prefer static_cast.

1132

https://llvm.org/docs/CodingStandards.html#prefer-preincrement

You should probably also do it as part of the assignment, i.e. SecEntry.Index = ++SectionCount;

1134

Noting here and in other places that this should really return an Error rather than report_fatal_error. That's another piece of work though.

1141

Simply "some padding" or "some padding bytes", but not "some paddings".

Also I'd change the last bit to "and to use this padding in FileOffsetToData calculation."

[DiggerLin]

In D137819#3939790, @Esme wrote:

In D137819#3925955, @DiggerLin wrote:

change the description to 'support the relocation overflow section."

As the doc says, the overflow section is required when either of the relocation entries or the line number entries exceeds 65,534. As long as one of the counts exceeds 65,534, the other one will also be set to 65535 in the primary section header, and then the overflow section will record actual counts for both relocation entries and line number entries, where the s_paddr for relocation entries and s_vaddr for line number entries.
Therefore I reckon there's no need to identify whether it's a relocation overflow section or line number overflow section.

if one day, you want to add the functionality patch of overflow section for line number , what title  you want to use for that new patch?

[DiggerLin]

llvm/lib/MC/XCOFFObjectWriter.cpp

931–932

assume you need to implement line number overflow in next patch, where you want to put the actually line number in SectionEntry of overflow section?(you put the relocation number in the Sec->Address in current patch.)

1117

the "countRelocations " can not self-explain the functionality of the lambda. the Relcount is already calculate outside the countRelocations, the lambda function just check whether need to generate a overflow section and set the relocation count to section header.

1125–1126

move the codes line 935 ~940 to here( uint64_t CurrAddress = 0;), and you can delete the code line 960~961

// Add the overflow section header size to RawPointer.
      RawPointer += XCOFF::SectionHeaderSize32;

1143

since you have a !DwarfSections.empty() here, I suggest to put the codes from line 1010 ~1020 into the same curly braces.

[pscoro]

llvm/lib/MC/XCOFFObjectWriter.cpp

286

Seems likely because of how XCOFF documentation has abbreviated their flags: STYP_OVRFLO is the XCOFF flag. I agree with using full word for variable name because the full name of the section is still "Overflow section"

1335

Concerned about whether my exception section fintegrated-as support commit might conflict with how this logic was rearranged. My commit added code after this line that I assume this review wants moved elsewhere. Can we rebase against a more recent commit that includes https://reviews.llvm.org/D134195 and test?

[Esme]

Addressed comments.

[Esme]

llvm/lib/MC/XCOFFObjectWriter.cpp

931–932

struct SectionEntry {
  char Name[XCOFF::NameSize];
  // The physical/virtual address of the section. For an object file
  // these values are equivalent.
  uint64_t Address;
  uint64_t Size;
  uint64_t FileOffsetToData;
  uint64_t FileOffsetToRelocations;
  uint32_t RelocationCount;
  int32_t Flags;

  int16_t Index;
...
}

To implement the line number, we have to add some members to SectionEntry, like FileOffsetToLineNum and LineNumCount, and I think we can distinguish the Address here into PhysicalAddress and VirtualAddress, which will be used to record the actual line number when the section is an overflow section.

1125–1126

Oh yes, thanks.

1134

Thanks, I'll post another patch for this work after this patch is committed.

1335

Thanks for reminding.
It seems that D134195 wasn't committed after format-clean, so I format them and then rebase, which brings formatting changes to this patch. If necessary, we can submit a separate NFC patch for formatting.

[Esme]

In D137819#3953495, @DiggerLin wrote:

In D137819#3939790, @Esme wrote:

In D137819#3925955, @DiggerLin wrote:

change the description to 'support the relocation overflow section."

As the doc says, the overflow section is required when either of the relocation entries or the line number entries exceeds 65,534. As long as one of the counts exceeds 65,534, the other one will also be set to 65535 in the primary section header, and then the overflow section will record actual counts for both relocation entries and line number entries, where the s_paddr for relocation entries and s_vaddr for line number entries.
Therefore I reckon there's no need to identify whether it's a relocation overflow section or line number overflow section.

if one day, you want to add the functionality patch of overflow section for line number , what title  you want to use for that new patch?

Updated the title and description. Thanks!

[Esme]

Rebase on latest commit.

[jhenderson]

I'm okay with an NFC reformatting patch if it's needed, rather than trying to bundle together the changes in with functional changes.

llvm/lib/MC/XCOFFObjectWriter.cpp

945

Ping?

1086

Noting another incident of OvrflowSec, which should be OverflowSec.

[Esme]

Addressed comments.

[Esme]

In D137819#3970056, @jhenderson wrote:

I'm okay with an NFC reformatting patch if it's needed, rather than trying to bundle together the changes in with functional changes.

Agree, rG664cbfaf07e0 is the NFC reformatting patch.

[DiggerLin]

llvm/lib/MC/XCOFFObjectWriter.cpp

931–932

I think we can distinguish the Address here into PhysicalAddress and VirtualAddress, which will be used to record the actual line number when the section is an overflow section.

you want to add a new flag to distinguish the Address here into PhysicalAddress and VirtualAddress later when you implement the line number overflow patch? that is what I ask for. please add the flag now or add some comment on it.

llvm/test/CodeGen/PowerPC/aix-xcoff-huge-relocs.ll

8

since 64bit do not have overflow section. I think we also need 64bits test case.

[Esme]

llvm/test/CodeGen/PowerPC/aix-xcoff-huge-relocs.ll

8

We've already test XCOFF64. (See line 20~23)

[jhenderson]

llvm/lib/MC/XCOFFObjectWriter.cpp

111

113

115

947

No need for "for" here. Also duplicate "the".

This comment seems to basically be saying the same thing as the new one in the header. I don't think we need both as it's just repeating information. @DiggerLin, what do you think?

[DiggerLin]

llvm/lib/MC/XCOFFObjectWriter.cpp

947

agree with James.

[Esme]

Update the comments.

[jhenderson]

No more comments from me, thanks!

[DiggerLin]

llvm/lib/MC/XCOFFObjectWriter.cpp

1082

we do not need introduce a new variable RelocationSizeInSec

We can update

RawPointer += OverflowSec.Address * XCOFF::RelocationSerializationSize32;

and

RawPointer += Sec->RelocationCount *
                          (is64Bit() ? XCOFF::RelocationSerializationSize64: XCOFF::RelocationSerializationSize32);

directly.

[Esme]

llvm/lib/MC/XCOFFObjectWriter.cpp

1082

Nice point, but this variable is also used to check whether the primary section has a corresponding overflow section, so I think it is useful to introduce this variable.
assert(RelocationSizeInSec && "Overflow section header doesn't exist.");

[shchenz]

Looks great! I also did some functionality test related to -g/-ffunction-sections, all look good.

llvm/lib/MC/XCOFFObjectWriter.cpp

1066

Can we use push_back(std::move(SecEntry))?

1087

Can we add a field in SectionEntry struct to indicate the related overflow section index, so that we don't need the loop here? For example a new field about index to vector OverflowSec?

1157

We don't need the CurrAddress here, we can just use the Sections.back()->Address + Sections.back()->Size.

[DiggerLin]

llvm/lib/MC/XCOFFObjectWriter.cpp

1087

all the data in the SectionEntry should be common to all Section.

maybe we can delete the loop by setting the

Sec->RelocationCount as real relocation number.

we do not need to do

// The field in the primary section header is always 65535
 // (XCOFF::RelocOverflow).
 Sec->RelocationCount = XCOFF::RelocOverflow;

in function
XCOFFObjectWriter::finalizeRelocationInfo

and in function XCOFFObjectWriter::writeSectionHeader
when found the
Sec->RelocationCount >= XCOFF::RelocOverflow
we write as XCOFF::RelocOverflow ?

[Esme]

Addressed comments.
Didn't find a better way instead of looping through to find the corresponding overflow section.

llvm/lib/MC/XCOFFObjectWriter.cpp

1087

Thanks @DiggerLin
With the approach you mentioned, we will miss to set value to FileOffsetToRelocations for overflow section. It's necessary to find out the corresponding overflow section.

// This field must have the same values as in the corresponding
// primary section header.
OverflowSec.FileOffsetToRelocations = Sec->FileOffsetToRelocations;

1087

Thanks @shchenz
Most sections will not have a corresponding overflow section, so I also think that adding such a member is not common.

1157

Digger also had such comment before (see comments below line 1124), we can't do that because we skip over some sections in the loop:

if (Sec->Index == SectionEntry::UninitializedIndex || Sec->IsVirtual)
      continue;

[shchenz]

llvm/lib/MC/XCOFFObjectWriter.cpp

1087

OK.

1157

Have you checked the replacement of {RawPointer(at line 1150) - RawPointer(at line 1130)} for CurrAddress?

[Esme]

llvm/lib/MC/XCOFFObjectWriter.cpp

1157

Yes, I've checked that and they're not equal.

[shchenz]

LGTM. Thanks for working on this.

llvm/lib/MC/XCOFFObjectWriter.cpp

 // container.
 using CsectGroup = std::deque<XCOFFSection>;
 using CsectGroups = std::deque<CsectGroup *>;
 
 // The basic section entry defination. This Section represents a section entry
 // in XCOFF section header table.
 struct SectionEntry {
   char Name[XCOFF::NameSize];
-  // The physical/virtual address of the section. For an object file
-  // these values are equivalent.
+  // The physical/virtual address of the section. For an object file these
+  // values are equivalent, except for in the overflow section header, where
+  // the physical address specifies the number of relocation entries and the
+  // virtual address specifies the number of line number entries.
+  // TODO: Divide Address into PhysicalAddress and VirtualAddress when line
+  // number entries are supported.
   uint64_t Address;
   uint64_t Size;
   uint64_t FileOffsetToData;
   uint64_t FileOffsetToRelocations;
   uint32_t RelocationCount;
   int32_t Flags;
 
   int16_t Index;
struct ExceptionSectionEntry : public SectionEntry {
   virtual ~ExceptionSectionEntry() = default;
 };
 
 class XCOFFObjectWriter : public MCObjectWriter {
 
   uint32_t SymbolTableEntryCount = 0;
   uint64_t SymbolTableOffset = 0;
   uint16_t SectionCount = 0;
-  uint64_t RelocationEntryOffset = 0;
   std::vector<std::pair<std::string, size_t>> FileNames;
   bool HasVisibility = false;
 
   support::endian::Writer W;
   std::unique_ptr<MCXCOFFObjectTargetWriter> TargetObjectWriter;
   StringTableBuilder Strings;
 
   const uint64_t MaxRawDataSize =
class XCOFFObjectWriter : public MCObjectWriter {
   CsectSectionEntry TBSS;
 
   // All the XCOFF sections, in the order they will appear in the section header
   // table.
   std::array<CsectSectionEntry *const, 5> Sections{
       {&Text, &Data, &BSS, &TData, &TBSS}};
 
   std::vector<DwarfSectionEntry> DwarfSections;
+  std::vector<SectionEntry> OverflowSections;
 
   ExceptionSectionEntry ExceptionSection;
 
   CsectGroup &getCsectGroup(const MCSectionXCOFF *MCSec);
 
   void reset() override;
 
   void executePostLayoutBinding(MCAssembler &, const MCAsmLayout &) override;
void writeSymbolEntryForCsectMemberLabel(const Symbol &SymbolRef,
                                            uint64_t SymbolOffset);
   void writeSymbolEntryForControlSection(const XCOFFSection &CSectionRef,
                                          int16_t SectionIndex,
                                          XCOFF::StorageClass StorageClass);
   void writeSymbolEntryForDwarfSection(const XCOFFSection &DwarfSectionRef,
                                        int16_t SectionIndex);
   void writeFileHeader();
   void writeAuxFileHeader();
+  void writeSectionHeader(const SectionEntry *Sec);
   void writeSectionHeaderTable();
   void writeSections(const MCAssembler &Asm, const MCAsmLayout &Layout);
   void writeSectionForControlSectionEntry(const MCAssembler &Asm,
                                           const MCAsmLayout &Layout,
                                           const CsectSectionEntry &CsectEntry,
                                           uint64_t &CurrentAddressLocation);
   void writeSectionForDwarfSectionEntry(const MCAssembler &Asm,
                                         const MCAsmLayout &Layout,
class XCOFFObjectWriter : public MCObjectWriter {
   // `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.
   // *) Assigns symbol table indices.
   // *) Builds up the section header table by adding any non-empty sections to
   //    `Sections`.
   void assignAddressesAndIndices(const MCAsmLayout &);
+  // Called after relocations are recorded.
   void finalizeSectionInfo();
+  void finalizeRelocationInfo(SectionEntry *Sec, uint64_t RelCount);
+  void calcOffsetToRelocations(SectionEntry *Sec, uint64_t &RawPointer);
+
   void addExceptionEntry(const MCSymbol *Symbol, const MCSymbol *Trap,
                          unsigned LanguageCode, unsigned ReasonCode,
                          unsigned FunctionSize, bool hasDebug) override;
   bool hasExceptionSection() {
     return !ExceptionSection.ExceptionTable.empty();
   }
   unsigned getExceptionSectionSize();
   unsigned getExceptionOffset(const MCSymbol *Symbol);
void XCOFFObjectWriter::reset() {
   SectionMap.clear();
 
   UndefinedCsects.clear();
   // Reset any sections we have written to, and empty the section header table.
   for (auto *Sec : Sections)
     Sec->reset();
   for (auto &DwarfSec : DwarfSections)
     DwarfSec.reset();
+  for (auto &OverflowSec : OverflowSections)
+    OverflowSec.reset();
   ExceptionSection.reset();
 
   // Reset states in XCOFFObjectWriter.
   SymbolTableEntryCount = 0;
   SymbolTableOffset = 0;
   SectionCount = 0;
-  RelocationEntryOffset = 0;
   Strings.clear();
 
   MCObjectWriter::reset();
 }
 
 CsectGroup &XCOFFObjectWriter::getCsectGroup(const MCSectionXCOFF *MCSec) {
   switch (MCSec->getMappingClass()) {
   case XCOFF::XMC_PR:
void XCOFFObjectWriter::writeAuxFileHeader() {
   W.write<uint32_t>(Sections[0]->Size);    // TextSize
   W.write<uint32_t>(Sections[1]->Size);    // InitDataSize
   W.write<uint32_t>(Sections[2]->Size);    // BssDataSize
   W.write<uint32_t>(0);                    // EntryPointAddr
   W.write<uint32_t>(Sections[0]->Address); // TextStartAddr
   W.write<uint32_t>(Sections[1]->Address); // DataStartAddr
 }
 
-void XCOFFObjectWriter::writeSectionHeaderTable() {
-  auto writeSectionHeader = [&](const SectionEntry *Sec, bool IsDwarf) {
-    // Nothing to write for this Section.
-    if (Sec->Index == SectionEntry::UninitializedIndex)
-      return false;
+void XCOFFObjectWriter::writeSectionHeader(const SectionEntry *Sec) {
+  bool IsDwarf = (Sec->Flags & XCOFF::STYP_DWARF) != 0;
+  bool IsOvrflo = (Sec->Flags & XCOFF::STYP_OVRFLO) != 0;
+    return;
 
-    // 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.
-    writeWord(IsDwarf ? 0 : Sec->Address);
-    writeWord(IsDwarf ? 0 : Sec->Address);
+  // Write the Physical Address and Virtual Address.
+  // Since line number is not supported, we set it to 0 for overflow sections.
+  writeWord((IsDwarf || IsOvrflo) ? 0 : Sec->Address);
 
-    writeWord(Sec->Size);
-    writeWord(Sec->FileOffsetToData);
-    writeWord(Sec->FileOffsetToRelocations);
-    writeWord(0); // FileOffsetToLineNumberInfo. Not supported yet.
 
-    if (is64Bit()) {
-      W.write<uint32_t>(Sec->RelocationCount);
-      W.write<uint32_t>(0); // NumberOfLineNumbers. Not supported yet.
-      W.write<int32_t>(Sec->Flags);
-      W.OS.write_zeros(4);
-    } else {
-      W.write<uint16_t>(Sec->RelocationCount);
-      W.write<uint16_t>(0); // NumberOfLineNumbers. Not supported yet.
-      W.write<int32_t>(Sec->Flags);
-    }
+    // For the overflow section header, s_nreloc provides a reference to the
+    // primary section header and s_nlnno must have the same value.
+    // For common section headers, if either of s_nreloc or s_nlnno are set to
+    // 65535, the other one must also be set to 65535.
+    W.write<uint16_t>((IsOvrflo || Sec->RelocationCount == XCOFF::RelocOverflow)
+                          ? Sec->RelocationCount
+                          : 0); // NumberOfLineNumbers. Not supported yet.
+}
 
-    return true;
-  };
-
+void XCOFFObjectWriter::writeSectionHeaderTable() {
   for (const auto *CsectSec : Sections)
-    writeSectionHeader(CsectSec, /* IsDwarf */ false);
+    writeSectionHeader(CsectSec);
   for (const auto &DwarfSec : DwarfSections)
-    writeSectionHeader(&DwarfSec, /* IsDwarf */ true);
+    writeSectionHeader(&DwarfSec);
+  for (const auto &OverflowSec : OverflowSections)
+    writeSectionHeader(&OverflowSec);
   if (hasExceptionSection())
-    writeSectionHeader(&ExceptionSection, false);
+    writeSectionHeader(&ExceptionSection);
 }
 
 void XCOFFObjectWriter::writeRelocation(XCOFFRelocation Reloc,
                                         const XCOFFSection &Section) {
   if (Section.MCSec->isCsect())
     writeWord(Section.Address + Reloc.FixupOffsetInCsect);
   else {
     // DWARF sections' address is set to 0.
for (const auto *Section : Sections) {
     }
   }
 
   for (const auto &DwarfSection : DwarfSections)
     writeSymbolEntryForDwarfSection(*DwarfSection.DwarfSect,
                                     DwarfSection.Index);
 }
 
+void XCOFFObjectWriter::finalizeRelocationInfo(SectionEntry *Sec,
+                                               uint64_t RelCount) {
+  // Handles relocation field overflows in an XCOFF32 file. An XCOFF64 file
+  // may not contain an overflow section header.
+  if (!is64Bit() && (RelCount >= static_cast<uint32_t>(XCOFF::RelocOverflow))) {
+    // Generate an overflow section header.
+    SectionEntry SecEntry(".ovrflo", XCOFF::STYP_OVRFLO);
+
+    // This field specifies the file section number of the section header that
+    // overflowed.
+    SecEntry.RelocationCount = Sec->Index;
+
+    // This field specifies the number of relocation entries actually
+    // required.
+    SecEntry.Address = RelCount;
+    SecEntry.Index = ++SectionCount;
+    OverflowSections.push_back(std::move(SecEntry));
+
+    // The field in the primary section header is always 65535
+    // (XCOFF::RelocOverflow).
+    Sec->RelocationCount = XCOFF::RelocOverflow;
+  } else {
+    Sec->RelocationCount = RelCount;
+  }
+}
+
+void XCOFFObjectWriter::calcOffsetToRelocations(SectionEntry *Sec,
+                                                uint64_t &RawPointer) {
+  if (!Sec->RelocationCount)
+    return;
+
+  Sec->FileOffsetToRelocations = RawPointer;
+  uint64_t RelocationSizeInSec = 0;
+  if (!is64Bit() &&
+      Sec->RelocationCount == static_cast<uint32_t>(XCOFF::RelocOverflow)) {
+    // Find its corresponding overflow section.
+    for (auto &OverflowSec : OverflowSections) {
+      if (OverflowSec.RelocationCount == static_cast<uint32_t>(Sec->Index)) {
+        RelocationSizeInSec =
+            OverflowSec.Address * XCOFF::RelocationSerializationSize32;
+
+        // This field must have the same values as in the corresponding
+        // primary section header.
+        OverflowSec.FileOffsetToRelocations = Sec->FileOffsetToRelocations;
+      }
+    }
+    assert(RelocationSizeInSec && "Overflow section header doesn't exist.");
+  } else {
+    RelocationSizeInSec = Sec->RelocationCount *
+                          (is64Bit() ? XCOFF::RelocationSerializationSize64
+                                     : XCOFF::RelocationSerializationSize32);
+  }
+
+  RawPointer += RelocationSizeInSec;
+  if (RawPointer > MaxRawDataSize)
+    report_fatal_error("Relocation data overflowed this object file.");
+}
+
 void XCOFFObjectWriter::finalizeSectionInfo() {
   for (auto *Section : Sections) {
     if (Section->Index == SectionEntry::UninitializedIndex)
       // Nothing to record for this Section.
       continue;
 
+    uint64_t RelCount = 0;
     for (const auto *Group : Section->Groups) {
       if (Group->empty())
         continue;
 
-      for (auto &Csect : *Group) {
-        const size_t CsectRelocCount = Csect.Relocations.size();
-        // An XCOFF64 file may not contain an overflow section header.
-        if (!is64Bit() && (CsectRelocCount >= XCOFF::RelocOverflow ||
-                           Section->RelocationCount >=
-                               XCOFF::RelocOverflow - CsectRelocCount))
-          report_fatal_error(
-              "relocation entries overflowed; overflow section is "
-              "not implemented yet");
-
-        Section->RelocationCount += CsectRelocCount;
-      }
+      for (auto &Csect : *Group)
+        RelCount += Csect.Relocations.size();
     }
+    finalizeRelocationInfo(Section, RelCount);
   }
 
   for (auto &DwarfSection : DwarfSections)
-    DwarfSection.RelocationCount = DwarfSection.DwarfSect->Relocations.size();
+    finalizeRelocationInfo(&DwarfSection,
+                           DwarfSection.DwarfSect->Relocations.size());
 
-  // Calculate the file offset to the relocation entries.
-  uint64_t RawPointer = RelocationEntryOffset;
-  auto calcOffsetToRelocations = [&](SectionEntry *Sec, bool IsDwarf) {
-    if (!IsDwarf && Sec->Index == SectionEntry::UninitializedIndex)
-      return false;
+  // Calculate the RawPointer value for all headers.
+  uint64_t RawPointer =
+      (is64Bit() ? (XCOFF::FileHeaderSize64 +
+                    SectionCount * XCOFF::SectionHeaderSize64)
+                 : (XCOFF::FileHeaderSize32 +
+                    SectionCount * XCOFF::SectionHeaderSize32)) +
+      auxiliaryHeaderSize();
 
-    if (!Sec->RelocationCount)
-      return false;
+  // Calculate the file offset to the section data.
+  uint64_t CurrAddress = 0;
+  for (auto *Sec : Sections) {
+    if (Sec->Index == SectionEntry::UninitializedIndex || Sec->IsVirtual)
+      continue;
 
-    Sec->FileOffsetToRelocations = RawPointer;
-    const uint64_t RelocationSizeInSec =
-        Sec->RelocationCount * (is64Bit()
-                                    ? XCOFF::RelocationSerializationSize64
-                                    : XCOFF::RelocationSerializationSize32);
-    RawPointer += RelocationSizeInSec;
+    Sec->FileOffsetToData = RawPointer;
+    RawPointer += Sec->Size;
     if (RawPointer > MaxRawDataSize)
-      report_fatal_error("Relocation data overflowed this object file.");
+      report_fatal_error("Section raw data overflowed this object file.");
 
-    return true;
-  };
+    CurrAddress = Sec->Address + Sec->Size;
+  }
 
-  for (auto *Sec : Sections)
-    calcOffsetToRelocations(Sec, /* IsDwarf */ false);
+  // Sections other than DWARF section use DefaultSectionAlign as the default
+  // alignment, while DWARF sections have their own alignments. If these two
+  // alignments are not the same, we need some padding here and to use this
+  // padding in FileOffsetToData calculation.
+  if (!DwarfSections.empty()) {
+    RawPointer +=
+        alignTo(CurrAddress,
+                (*DwarfSections.begin()).DwarfSect->MCSec->getAlign()) -
+        CurrAddress;
+    for (auto &DwarfSection : DwarfSections) {
+      DwarfSection.FileOffsetToData = RawPointer;
+      RawPointer += DwarfSection.MemorySize;
+      if (RawPointer > MaxRawDataSize)
+        report_fatal_error("Section raw data overflowed this object file.");
+    }
+  }
+
+  if (hasExceptionSection()) {
+    ExceptionSection.FileOffsetToData = RawPointer;
+    RawPointer += ExceptionSection.Size;
+
+    assert(RawPointer <= MaxRawDataSize &&
+           "Section raw data overflowed this object file.");
+  }
+
+  for (auto *Sec : Sections) {
+    if (Sec->Index != SectionEntry::UninitializedIndex)
+      calcOffsetToRelocations(Sec, RawPointer);
+  }
 
   for (auto &DwarfSec : DwarfSections)
-    calcOffsetToRelocations(&DwarfSec, /* IsDwarf */ true);
+    calcOffsetToRelocations(&DwarfSec, RawPointer);
 
   // TODO Error check that the number of symbol table entries fits in 32-bits
   // signed ...
   if (SymbolTableEntryCount)
     SymbolTableOffset = RawPointer;
 }
 
 void XCOFFObjectWriter::addExceptionEntry(const MCSymbol *Symbol,
void XCOFFObjectWriter::assignAddressesAndIndices(const MCAsmLayout &Layout) {
 
   // The address corrresponds to the address of sections and symbols in the
   // object file. We place the shared address 0 immediately after the
   // section header table.
   uint64_t Address = 0;
   // Section indices are 1-based in XCOFF.
   int32_t SectionIndex = 1;
   bool HasTDataSection = false;
-  uint32_t PaddingsBeforeDwarf = 0;
 
   for (auto *Section : Sections) {
     const bool IsEmpty =
         llvm::all_of(Section->Groups,
                      [](const CsectGroup *Group) { return Group->empty(); });
     if (IsEmpty)
       continue;
 
for (auto *Section : Sections) {
     }
 
     // Make sure the address of the next section aligned to
     // DefaultSectionAlign.
     Address = alignTo(Address, DefaultSectionAlign);
     Section->Size = Address - Section->Address;
   }
 
-  // Start to generate DWARF sections. Sections other than DWARF section use
-  // DefaultSectionAlign as the default alignment, while DWARF sections have
-  // their own alignments. If these two alignments are not the same, we need
-  // some paddings here and record the paddings bytes for FileOffsetToData
-  // calculation.
-  if (!DwarfSections.empty())
-    PaddingsBeforeDwarf =
-        alignTo(Address,
-                (*DwarfSections.begin()).DwarfSect->MCSec->getAlign()) -
-        Address;
-
+  // Start to generate DWARF sections.
   DwarfSectionEntry *LastDwarfSection = nullptr;
-
   for (auto &DwarfSection : DwarfSections) {
     assert((SectionIndex <= MaxSectionIndex) && "Section index overflow!");
 
     XCOFFSection &DwarfSect = *DwarfSection.DwarfSect;
     const MCSectionXCOFF *MCSec = DwarfSect.MCSec;
 
     // Section index.
     DwarfSection.Index = SectionIndex++;
void XCOFFObjectWriter::assignAddressesAndIndices(const MCAsmLayout &Layout) {
   if (hasExceptionSection()) {
     ExceptionSection.Index = SectionIndex++;
     SectionCount++;
     ExceptionSection.Address = 0;
     ExceptionSection.Size = getExceptionSectionSize();
     Address += ExceptionSection.Size;
     Address = alignTo(Address, DefaultSectionAlign);
   }
-  SymbolTableEntryCount = SymbolTableIndex;
-
-  // Calculate the RawPointer value for each section.
-  uint64_t RawPointer =
-      (is64Bit() ? (XCOFF::FileHeaderSize64 +
-                    SectionCount * XCOFF::SectionHeaderSize64)
-                 : (XCOFF::FileHeaderSize32 +
-                    SectionCount * XCOFF::SectionHeaderSize32)) +
-      auxiliaryHeaderSize();
 
-  for (auto *Sec : Sections) {
-    if (Sec->Index == SectionEntry::UninitializedIndex || Sec->IsVirtual)
-      continue;
-
-    Sec->FileOffsetToData = RawPointer;
-    RawPointer += Sec->Size;
-    if (RawPointer > MaxRawDataSize)
-      report_fatal_error("Section raw data overflowed this object file.");
-  }
-
-  // Increase the raw pointer for the padding bytes between csect sections and
-  // DWARF sections.
-  if (!DwarfSections.empty())
-    RawPointer += PaddingsBeforeDwarf;
-
-  for (auto &DwarfSection : DwarfSections) {
-    DwarfSection.FileOffsetToData = RawPointer;
-
-    RawPointer += DwarfSection.MemorySize;
-
-    assert(RawPointer <= MaxRawDataSize &&
-           "Section raw data overflowed this object file.");
-  }
-
-  if (hasExceptionSection()) {
-    ExceptionSection.FileOffsetToData = RawPointer;
-    RawPointer += ExceptionSection.Size;
-
-    assert(RawPointer <= MaxRawDataSize &&
-           "Section raw data overflowed this object file.");
-  }
-
-  RelocationEntryOffset = RawPointer;
+  SymbolTableEntryCount = SymbolTableIndex;
 }
 
 void XCOFFObjectWriter::writeSectionForControlSectionEntry(
     const MCAssembler &Asm, const MCAsmLayout &Layout,
     const CsectSectionEntry &CsectEntry, uint64_t &CurrentAddressLocation) {
   // Nothing to write for this Section.
   if (CsectEntry.Index == SectionEntry::UninitializedIndex)
     return;

llvm/test/CodeGen/PowerPC/aix-xcoff-huge-relocs.ll

 ;; This test takes a very long time
 ; REQUIRES: expensive_checks
 
 ;; This test generates 65535 relocation entries in a single section,
 ;; which would trigger an overflow section to be generated in 32-bit mode.
-;; Since overflow section is not supported yet, we will emit an error instead of
-;; generating an invalid binary for now.
 ; RUN: grep -v RUN: %s | \
-; RUN:   sed >%t.overflow.ll 's/SIZE/65535/;s/MACRO/#/;s/#/################/g;s/#/################/g;s/#/################/g;s/#/################/g;s/#/#_/g;s/_#_\([^#]\)/\1/;s/_/, /g;s/#/ptr @c/g;'
-; RUN: not --crash llc -verify-machineinstrs -mtriple powerpc-ibm-aix-xcoff \
-; RUN:                 -mcpu=pwr4 -mattr=-altivec -filetype=obj -o %t.o %t.overflow.ll 2>&1 | \
-; RUN:   FileCheck --check-prefix=OVERFLOW %s
-; OVERFLOW: LLVM ERROR: relocation entries overflowed; overflow section is not implemented yet
+; RUN:   sed > %t.overflow.ll 's/SIZE/65535/;s/MACRO/#/;s/#/################/g;s/#/################/g;s/#/################/g;s/#/################/g;s/#/#_/g;s/_#_\([^#]\)/\1/;s/_/, /g;s/#/ptr @c/g;'
+; RUN: llc -verify-machineinstrs -mtriple powerpc-ibm-aix-xcoff \
+; RUN:     -mcpu=pwr4 -mattr=-altivec -filetype=obj -o %t.overflow.o %t.overflow.ll
+; RUN: llvm-readobj --section-headers %t.overflow.o | FileCheck --check-prefix=OVERFLOW %s
 
 ;; This test generates 65534 relocation entries, an overflow section should
 ;; not be generated.
 ; RUN: grep -v RUN: %s | \
 ; RUN:   sed >%t.ll 's/SIZE/65534/;s/MACRO/#/;s/#/################/g;s/#/################/g;s/#/################/g;s/#/################/g;s/#/#_/g;s/_#_#_\([^#]\)/\1/;s/_/, /g;s/#/ptr @c/g;'
 ; RUN: llc -verify-machineinstrs -mtriple powerpc-ibm-aix-xcoff \
 ; RUN:     -mcpu=pwr4 -mattr=-altivec -filetype=obj -o %t.o %t.ll
 ; RUN: llvm-readobj --section-headers %t.o | FileCheck --check-prefix=XCOFF32 %s
 
 ;; An XCOFF64 file may not contain an overflow section header.
 ; RUN: llc -verify-machineinstrs -mtriple powerpc64-ibm-aix-xcoff \
 ; RUN:     -mcpu=pwr4 -mattr=-altivec -filetype=obj -o %t64.o %t.overflow.ll
 ; RUN: llvm-readobj --section-headers %t64.o | FileCheck --check-prefix=XCOFF64 %s
 
 @c = external global i8, align 1
 @arr = global [SIZE x ptr] [MACRO], align 8
 
-; XCOFF32-NOT:     Name: .ovrflo
-; XCOFF32-NOT:     Type: STYP_OVRFLO
+; OVERFLOW:         Section {
+; OVERFLOW-NEXT:      Index: 2
+; OVERFLOW-NEXT:      Name: .data
+; OVERFLOW-NEXT:      PhysicalAddress: 0x0
+; OVERFLOW-NEXT:      VirtualAddress: 0x0
+; OVERFLOW-NEXT:      Size: 0x3FFFC
+; OVERFLOW-NEXT:      RawDataOffset: 0x8C
+; OVERFLOW-NEXT:      RelocationPointer: 0x40088
+; OVERFLOW-NEXT:      LineNumberPointer: 0x0
+; OVERFLOW-NEXT:      NumberOfRelocations: 65535
+; OVERFLOW-NEXT:      NumberOfLineNumbers: 65535
+; OVERFLOW-NEXT:      Type: STYP_DATA (0x40)
+; OVERFLOW-NEXT:    }
+; OVERFLOW-NEXT:    Section {
+; OVERFLOW-NEXT:      Index: 3
+; OVERFLOW-NEXT:      Name: .ovrflo
+; OVERFLOW-NEXT:      NumberOfRelocations: 65535
+; OVERFLOW-NEXT:      NumberOfLineNumbers: 0
+; OVERFLOW-NEXT:      Size: 0x0
+; OVERFLOW-NEXT:      RawDataOffset: 0x0
+; OVERFLOW-NEXT:      RelocationPointer: 0x40088
+; OVERFLOW-NEXT:      LineNumberPointer: 0x0
+; OVERFLOW-NEXT:      IndexOfSectionOverflowed: 2
+; OVERFLOW-NEXT:      IndexOfSectionOverflowed: 2
+; OVERFLOW-NEXT:      Type: STYP_OVRFLO (0x8000)
+; OVERFLOW-NEXT:    }
+
 ; XCOFF32:       Section {
 ; XCOFF32:         Name: .data
 ; XCOFF32-NEXT:    PhysicalAddress: 0x0
 ; XCOFF32-NEXT:    VirtualAddress: 0x0
 ; XCOFF32-NEXT:    Size: 0x3FFF8
 ; XCOFF32-NEXT:    RawDataOffset: 0x64
 ; XCOFF32-NEXT:    RelocationPointer: 0x4005C
 ; XCOFF32-NEXT:    LineNumberPointer: 0x0
 ; XCOFF32-NEXT:    NumberOfRelocations: 65534
 ; XCOFF32-NEXT:    NumberOfLineNumbers: 0
 ; XCOFF32-NEXT:    Type: STYP_DATA (0x40)
 ; XCOFF32-NEXT:  }
-; XCOFF32-NOT:     Name: .ovrflo
-; XCOFF32-NOT:     Type: STYP_OVRFLO
 
 ; XCOFF64:      Section {
 ; XCOFF64:        Name: .data
 ; XCOFF64-NEXT:   PhysicalAddress: 0x0
 ; XCOFF64-NEXT:   VirtualAddress: 0x0
 ; XCOFF64-NEXT:   Size: 0x7FFF8
 ; XCOFF64-NEXT:   RawDataOffset: 0xA8
 ; XCOFF64-NEXT:   RelocationPointer: 0x800A0
 ; XCOFF64-NEXT:   LineNumberPointer: 0x0
 ; XCOFF64-NEXT:   NumberOfRelocations: 65535
 ; XCOFF64-NEXT:   NumberOfLineNumbers: 0
 ; XCOFF64-NEXT:   Type: STYP_DATA (0x40)
 ; XCOFF64-NEXT: }