[NFCI][XCOFF][AIX] Skip empty Section during object file generation

[jasonliu]

Summary

This is a fix to D69112 where we common up the logic of writing CsectGroup.
However, we forget to skip the Sections that are empty in that patch.

[daltenty]

llvm/lib/MC/XCOFFObjectWriter.cpp

151

Should this be uint16_t?

[jasonliu]

Change SectionCount type to unsigned.

[jasonliu]

llvm/lib/MC/XCOFFObjectWriter.cpp

151

Originally choose the signed type at the mind set of "don't use unsigned to represent integer that could not be negative." And also, want this to be the same type as the Maximum section index could be.
But just find out that we are actually writing this SectionCount as unsigned in the object file. So I figure I will just avoid the controversy and use unsigned instead.
Thanks.

[daltenty]

LGTM

[xingxue]

LGTM.

llvm/lib/MC/XCOFFObjectWriter.cpp

Section(const char *N, XCOFF::SectionTypeFlags Flags, bool IsVirtual,
     strncpy(Name, N, XCOFF::NameSize);
   }
 };
 
 class XCOFFObjectWriter : public MCObjectWriter {
 
   uint32_t SymbolTableEntryCount = 0;
   uint32_t SymbolTableOffset = 0;
+  uint16_t SectionCount = 0;
 
   support::endian::Writer W;
   std::unique_ptr<MCXCOFFObjectTargetWriter> TargetObjectWriter;
   StringTableBuilder Strings;
 
   // CsectGroups. These store the csects which make up different parts of
   // the sections. Should have one for each set of csects that get mapped into
   // the same section and get handled in a 'similar' way.

 void XCOFFObjectWriter::reset() {
   // Reset any sections we have written to, and empty the section header table.
   for (auto *Sec : Sections)
     Sec->reset();
 
   // Reset the symbol table and string table.
   SymbolTableEntryCount = 0;
   SymbolTableOffset = 0;
+  SectionCount = 0;
   Strings.clear();
 
   MCObjectWriter::reset();
 }
 
 CsectGroup &XCOFFObjectWriter::getCsectGroup(const MCSectionXCOFF *MCSec) {
   switch (MCSec->getMappingClass()) {
   case XCOFF::XMC_PR:
void XCOFFObjectWriter::writeSymbolTableEntryForControlSection(
   // Reserved (x_snstab).
   W.write<uint16_t>(0);
 }
 
 void XCOFFObjectWriter::writeFileHeader() {
   // Magic.
   W.write<uint16_t>(0x01df);
   // Number of sections.
-  W.write<uint16_t>(Sections.size());
+  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);
 }
 
 void XCOFFObjectWriter::writeSectionHeaderTable() {
   for (const auto *Sec : Sections) {
+    // Nothing to write for this Section.
+    if (Sec->Index == Section::UninitializedIndex)
+      continue;
+
     // 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.
     W.write<uint32_t>(Sec->Address);
     W.write<uint32_t>(Sec->Address);
for (const auto *Sec : Sections) {
     W.write<uint16_t>(0);
 
     W.write<int32_t>(Sec->Flags);
   }
 }
 
 void XCOFFObjectWriter::writeSymbolTable(const MCAsmLayout &Layout) {
   for (const auto *Section : Sections) {
+    // Nothing to write for this Section.
+    if (Section->Index == Section::UninitializedIndex)
+      continue;
+
     for (const auto *Group : Section->Groups) {
       if (Group->Csects.empty())
         continue;
 
       const bool SupportLabelDef = Group->SupportLabelDef;
       const int16_t SectionIndex = Section->Index;
       for (const auto &Csect : Group->Csects) {
         // Write out the control section first and then each symbol in it.
const bool IsEmpty =
           return Group->Csects.empty();
         });
     if (IsEmpty)
       continue;
 
     if (SectionIndex > MaxSectionIndex)
       report_fatal_error("Section index overflow!");
     Section->Index = SectionIndex++;
+    SectionCount++;
 
     bool SectionAddressSet = false;
     for (auto *Group : Section->Groups) {
       if (Group->Csects.empty())
         continue;
 
       const bool SupportLabelDef = Group->SupportLabelDef;
       for (auto &Csect : Group->Csects) {
for (auto *Section : Sections) {
     Address = alignTo(Address, DefaultSectionAlign);
     Section->Size = Address - Section->Address;
   }
 
   SymbolTableEntryCount = SymbolTableIndex;
 
   // Calculate the RawPointer value for each section.
   uint64_t RawPointer = sizeof(XCOFF::FileHeader32) + auxiliaryHeaderSize() +
-                        Sections.size() * sizeof(XCOFF::SectionHeader32);
+                        SectionCount * sizeof(XCOFF::SectionHeader32);
   for (auto *Sec : Sections) {
-    if (!Sec->IsVirtual) {
-      Sec->FileOffsetToData = RawPointer;
-      RawPointer += Sec->Size;
-    }
-  }
+    if (Sec->Index == Section::UninitializedIndex || Sec->IsVirtual)
+      continue;
+
 
   // TODO Add in Relocation storage to the RawPointer Calculation.
   // TODO What to align the SymbolTable to?
   // TODO Error check that the number of symbol table entries fits in 32-bits
   // signed ...
   if (SymbolTableEntryCount)
     SymbolTableOffset = RawPointer;
 }