[XCOFF][NFC] add DWARF section support in XCOFF object writer

[shchenz]

Summary

We are going to support DWARF for XCOFF. D95518 is for XCOFF DWARF support of assembly output.

This patch is the NFC part of the patches that are going to support XCOFF DWARF support of object output.

Changes in this patch:
1: Create one base struct XCOFFSection to represent the wrapper of MCSectionXCOFF . The legacy ControlSection now derives from XCOFFSection and the newly created DWARFSection also derives from this struct.
2: Create another base struct SectionEntry to represent the section entry in the section table. The legacy Section now derives from SectionEntry and it is renamed to CsectSectionEntry and the newly created DWARFSectionEntry struct also derives from SectionEntry which will be used to represent DWARF sections.

Usage of the new structs DWARFSection and DWARFSectionEntry will be added later when the NFC patch makes sense to reviewers.

[shchenz]

1: minor update

[shchenz]

1: minor update

[jsji]

llvm/include/llvm/MC/MCSectionXCOFF.h

107

Need rebase after D95518?

[shchenz]

llvm/include/llvm/MC/MCSectionXCOFF.h

107

yep, working on it. Will post the rebased on soon.

[shchenz]

rebase

[shchenz]

gentle ping

[shchenz]

format fix

[shchenz]

fix lint warnings

[shchenz]

update for dynamic allocating for the section entries.

[shchenz]

gentle ping

[shchenz]

1: use different way for csect sections and dwarf sections

[shchenz]

gentle ping

[shchenz]

gentle ping

[jsji]

LGTM.

llvm/include/llvm/MC/MCSectionXCOFF.h

public:
 
   void PrintSwitchToSection(const MCAsmInfo &MAI, const Triple &T,
                             raw_ostream &OS,
                             const MCExpr *Subsection) const override;
   bool UseCodeAlign() const override;
   bool isVirtualSection() const override;
   StringRef getSymbolTableName() const { return SymbolTableName; }
   bool isMultiSymbolsAllowed() const { return MultiSymbolsAllowed; }
+  bool isDWARFSection() const {
+    return getSecFlags() & (unsigned)XCOFF::STYP_DWARF;
+  }
   bool isCsect() const { return CsectProp.hasValue(); }
   unsigned getSecFlags() const { return SecFlags; }
 };
 
 } // end namespace llvm
 
 #endif

llvm/lib/MC/XCOFFObjectWriter.cpp

struct Symbol {
   XCOFF::StorageClass getStorageClass() const {
     return MCSym->getStorageClass();
   }
   StringRef getSymbolTableName() const { return MCSym->getSymbolTableName(); }
   Symbol(const MCSymbolXCOFF *MCSym) : MCSym(MCSym), SymbolTableIndex(-1) {}
 };
 
 // Wrapper for an MCSectionXCOFF.
-struct ControlSection {
-  const MCSectionXCOFF *const MCCsect;
+// It can be a Csect or debug section or DWARF section and so on.
+struct XCOFFSection {
+  const MCSectionXCOFF *const MCSec;
   uint32_t SymbolTableIndex;
   uint32_t Address;
   uint32_t Size;
 
-  SmallVector<Symbol, 1> Syms;
+  XCOFFSection(const MCSectionXCOFF *MCSec)
+      : MCSec(MCSec), SymbolTableIndex(-1), Address(-1), Size(0) {}
+
   SmallVector<XCOFFRelocation, 1> Relocations;
-  StringRef getSymbolTableName() const { return MCCsect->getSymbolTableName(); }
-  ControlSection(const MCSectionXCOFF *MCSec)
-      : MCCsect(MCSec), SymbolTableIndex(-1), Address(-1), Size(0) {}
+  StringRef getSymbolTableName() const { return MCSec->getSymbolTableName(); }
+  // The kind of the XCOFF Section.
+  // FIXME: add more section types, like debug, comment and so on.
+  enum SectionKind { SectionUnknown, SectionDWARF, SectionCsect };
+  virtual uint32_t getSectionKind() const { return SectionUnknown; };
+};
+
+struct ControlSection : public XCOFFSection {
+  // Symbols defined in this Csect
+  SmallVector<Symbol, 1> Syms;
+  ControlSection(const MCSectionXCOFF *MCSec) : XCOFFSection(MCSec) {
+    assert(MCSec->isCsect() && "Not a Csect!");
+  }
+  uint32_t getSectionKind() const override { return SectionCsect; };
+  static bool classof(const XCOFFSection *Sec) {
+    return Sec->getSectionKind() == SectionCsect;
+  }
+};
+
+struct DWARFSection : public XCOFFSection {
+  DWARFSection(const MCSectionXCOFF *MCSec) : XCOFFSection(MCSec) {
+    assert(MCSec->isDWARFSection() && "Not a DWARF section!");
+  }
+  uint32_t getSectionKind() const override { return SectionDWARF; };
+  static bool classof(const XCOFFSection *Sec) {
+    return Sec->getSectionKind() == SectionDWARF;
+  }
 };
 
 // Type to be used for a container representing a set of csects with
 // (approximately) the same storage mapping class. For example all the csects
 // with a storage mapping class of `xmc_pr` will get placed into the same
 // container.
 using CsectGroup = std::deque<ControlSection>;
 using CsectGroups = std::deque<CsectGroup *>;
 
-// Represents the data related to a section excluding the csects that make up
-// the raw data of the section. The csects are stored separately as not all
-// sections contain csects, and some sections contain csects which are better
-// stored separately, e.g. the .data section containing read-write, descriptor,
-// TOCBase and TOC-entry csects.
-struct Section {
+// 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.
   uint32_t Address;
   uint32_t Size;
   uint32_t FileOffsetToData;
   uint32_t FileOffsetToRelocations;
   uint32_t RelocationCount;
-  int32_t Flags;
+  uint32_t Flags;
 
   int16_t Index;
 
-  // Virtual sections do not need storage allocated in the object file.
-  const bool IsVirtual;
-
   // XCOFF has special section numbers for symbols:
   // -2 Specifies N_DEBUG, a special symbolic debugging symbol.
   // -1 Specifies N_ABS, an absolute symbol. The symbol has a value but is not
   // relocatable.
   //  0 Specifies N_UNDEF, an undefined external symbol.
   // Therefore, we choose -3 (N_DEBUG - 1) to represent a section index that
   // hasn't been initialized.
   static constexpr int16_t UninitializedIndex =
       XCOFF::ReservedSectionNum::N_DEBUG - 1;
 
-  CsectGroups Groups;
+  SectionEntry(StringRef N, uint32_t Flags)
+      : Name(), Address(0), Size(0), FileOffsetToData(0),
+        FileOffsetToRelocations(0), RelocationCount(0), Flags(Flags),
+        Index(UninitializedIndex) {
+    assert(N.size() <= XCOFF::NameSize && "section name too long");
+    memcpy(Name, N.data(), N.size());
+  }
 
-  void reset() {
+  virtual void reset() {
     Address = 0;
     Size = 0;
     FileOffsetToData = 0;
     FileOffsetToRelocations = 0;
     RelocationCount = 0;
     Index = UninitializedIndex;
+  }
+
+  // The kind of the XCOFF Section entry.
+  // FIXME: add more section entry types, like debug, comment and so on.
+  enum SectionEntryKind {
+    SectionEntryUnknown,
+    SectionEntryDWARF,
+    SectionEntryCsect
+  };
+  virtual uint32_t getSectionEntryKind() const { return SectionEntryUnknown; };
+};
+
+// Represents the data related to a section excluding the csects that make up
+// the raw data of the section. The csects are stored separately as not all
+// sections contain csects, and some sections contain csects which are better
+// stored separately, e.g. the .data section containing read-write, descriptor,
+// TOCBase and TOC-entry csects.
+struct CsectSectionEntry : public SectionEntry {
+  // Virtual sections do not need storage allocated in the object file.
+  const bool IsVirtual;
+
+  // This is a section containing csect groups.
+  CsectGroups Groups;
+
+  CsectSectionEntry(StringRef N, XCOFF::SectionTypeFlags Flags, bool IsVirtual,
+                    CsectGroups Groups)
+      : SectionEntry(N, Flags), IsVirtual(IsVirtual), Groups(Groups) {
+    assert(N.size() <= XCOFF::NameSize && "section name too long");
+    memcpy(Name, N.data(), N.size());
+  }
+
+  void reset() override {
+    SectionEntry::reset();
     // Clear any csects we have stored.
     for (auto *Group : Groups)
       Group->clear();
   }
 
-  Section(StringRef N, XCOFF::SectionTypeFlags Flags, bool IsVirtual,
-          CsectGroups Groups)
-      : Name(), Address(0), Size(0), FileOffsetToData(0),
-        FileOffsetToRelocations(0), RelocationCount(0), Flags(Flags),
-        Index(UninitializedIndex), IsVirtual(IsVirtual), Groups(Groups) {
+  uint32_t getSectionEntryKind() const override { return SectionEntryCsect; };
+  static bool classof(const SectionEntry *Sec) {
+    return Sec->getSectionEntryKind() == SectionEntryCsect;
+  }
+};
+
+struct DWARFSectionEntry : public SectionEntry {
+  // For DWARF section entry.
+  std::unique_ptr<DWARFSection> DWARFSect;
+
+  DWARFSectionEntry(StringRef N, uint32_t Flags, DWARFSection *DWARFSect)
+      : SectionEntry(N, Flags), DWARFSect(std::move(DWARFSect)) {
     assert(N.size() <= XCOFF::NameSize && "section name too long");
     memcpy(Name, N.data(), N.size());
   }
+
+  void reset() override {
+    SectionEntry::reset();
+    // Destory DWARFSection we own.
+    DWARFSect.reset();
+  }
+
+  uint32_t getSectionEntryKind() const override { return SectionEntryDWARF; };
+  static bool classof(const SectionEntry *Sec) {
+    return Sec->getSectionEntryKind() == SectionEntryDWARF;
+  }
 };
 
 class XCOFFObjectWriter : public MCObjectWriter {
 
   uint32_t SymbolTableEntryCount = 0;
   uint32_t SymbolTableOffset = 0;
   uint16_t SectionCount = 0;
   uint32_t RelocationEntryOffset = 0;
 
   support::endian::Writer W;
   std::unique_ptr<MCXCOFFObjectTargetWriter> TargetObjectWriter;
   StringTableBuilder Strings;
 
   // Maps the MCSection representation to its corresponding ControlSection
   // wrapper. Needed for finding the ControlSection to insert an MCSymbol into
   // from its containing MCSectionXCOFF.
-  DenseMap<const MCSectionXCOFF *, ControlSection *> SectionMap;
+  DenseMap<const MCSectionXCOFF *, XCOFFSection*> SectionMap;
 
   // Maps the MCSymbol representation to its corrresponding symbol table index.
   // Needed for relocation.
   DenseMap<const MCSymbol *, uint32_t> SymbolIndexMap;
 
   // 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.
   CsectGroup UndefinedCsects;
   CsectGroup ProgramCodeCsects;
   CsectGroup ReadOnlyCsects;
   CsectGroup DataCsects;
   CsectGroup FuncDSCsects;
   CsectGroup TOCCsects;
   CsectGroup BSSCsects;
 
   // The Predefined sections.
-  Section Text;
-  Section Data;
-  Section BSS;
+  CsectSectionEntry Text;
+  CsectSectionEntry Data;
+  CsectSectionEntry BSS;
 
   // All the XCOFF sections, in the order they will appear in the section header
   // table.
-  std::array<Section *const, 3> Sections{{&Text, &Data, &BSS}};
+  std::array<SectionEntry *const , 3> Sections{{&Text, &Data, &BSS}};
 
   CsectGroup &getCsectGroup(const MCSectionXCOFF *MCSec);
 
   virtual void reset() override;
 
   void executePostLayoutBinding(MCAssembler &, const MCAsmLayout &) override;
 
   void recordRelocation(MCAssembler &, const MCAsmLayout &, const MCFragment *,

 void XCOFFObjectWriter::executePostLayoutBinding(MCAssembler &Asm,
                                                  const MCAsmLayout &Layout) {
   if (TargetObjectWriter->is64Bit())
     report_fatal_error("64-bit XCOFF object files are not supported yet.");
 
   for (const auto &S : Asm) {
     const auto *MCSec = cast<const MCSectionXCOFF>(&S);
     assert(SectionMap.find(MCSec) == SectionMap.end() &&
-           "Cannot add a csect twice.");
+           "Cannot add a section twice.");
     assert(XCOFF::XTY_ER != MCSec->getCSectType() &&
            "An undefined csect should not get registered.");
 
     // If the name does not fit in the storage provided in the symbol table
     // entry, add it to the string table.
     if (nameShouldBeInStringTable(MCSec->getSymbolTableName()))
       Strings.add(MCSec->getSymbolTableName());
 
for (const MCSymbol &S : Asm.symbols()) {
 
     // Only put a label into the symbol table when it is an external label.
     if (!XSym->isExternal())
       continue;
 
     assert(SectionMap.find(ContainingCsect) != SectionMap.end() &&
            "Expected containing csect to exist in map");
     // Lookup the containing csect and add the symbol to it.
-    SectionMap[ContainingCsect]->Syms.emplace_back(XSym);
+    assert(isa<ControlSection>(SectionMap[ContainingCsect]) &&
+           "only csect is supported now!");
+    ControlSection *Csect =
+        dyn_cast<ControlSection>(SectionMap[ContainingCsect]);
+    Csect->Syms.emplace_back(XSym);
 
     // If the name does not fit in the storage provided in the symbol table
     // entry, add it to the string table.
     if (nameShouldBeInStringTable(XSym->getSymbolTableName()))
       Strings.add(XSym->getSymbolTableName());
   }
 
   Strings.finalize();
void XCOFFObjectWriter::recordRelocation(MCAssembler &Asm,
   // now we just need to fold "- SymbolB" here.
   FixedValue -= getVirtualAddress(SymB, SymBSec);
 }
 
 void XCOFFObjectWriter::writeSections(const MCAssembler &Asm,
                                       const MCAsmLayout &Layout) {
   uint32_t CurrentAddressLocation = 0;
   for (const auto *Section : Sections) {
+    assert(isa<CsectSectionEntry>(Section) && "Only csect entry is supported!");
+    auto CsectEntry = dyn_cast<CsectSectionEntry>(Section);
     // Nothing to write for this Section.
-    if (Section->Index == Section::UninitializedIndex || Section->IsVirtual)
+    if (CsectEntry->Index == SectionEntry::UninitializedIndex ||
+        CsectEntry->IsVirtual)
       continue;
 
     // There could be a gap (without corresponding zero padding) between
     // sections.
-    assert(CurrentAddressLocation <= Section->Address &&
+    assert(CurrentAddressLocation <= CsectEntry->Address &&
            "CurrentAddressLocation should be less than or equal to section "
            "address.");
 
-    CurrentAddressLocation = Section->Address;
+    CurrentAddressLocation = CsectEntry->Address;
 
-    for (const auto *Group : Section->Groups) {
+    for (const auto *Group : CsectEntry->Groups) {
       for (const auto &Csect : *Group) {
         if (uint32_t PaddingSize = Csect.Address - CurrentAddressLocation)
           W.OS.write_zeros(PaddingSize);
         if (Csect.Size)
-          Asm.writeSectionData(W.OS, Csect.MCCsect, Layout);
+          Asm.writeSectionData(W.OS, Csect.MCSec, Layout);
         CurrentAddressLocation = Csect.Address + Csect.Size;
       }
     }
 
     // The size of the tail padding in a section is the end virtual address of
     // the current section minus the the end virtual address of the last csect
     // in that section.
     if (uint32_t PaddingSize =
-            Section->Address + Section->Size - CurrentAddressLocation) {
+            CsectEntry->Address + CsectEntry->Size - CurrentAddressLocation) {
       W.OS.write_zeros(PaddingSize);
       CurrentAddressLocation += PaddingSize;
     }
   }
 }
 
 uint64_t XCOFFObjectWriter::writeObject(MCAssembler &Asm,
                                         const MCAsmLayout &Layout) {
void XCOFFObjectWriter::writeSymbolTableEntryForCsectMemberLabel(
   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.MCCsect->getMappingClass());
+  W.write<uint8_t>(CSectionRef.MCSec->getMappingClass());
   // Reserved (x_stab).
   W.write<uint32_t>(0);
   // Reserved (x_snstab).
   W.write<uint16_t>(0);
 }
 
 void XCOFFObjectWriter::writeSymbolTableEntryForControlSection(
     const ControlSection &CSectionRef, int16_t SectionIndex,
void XCOFFObjectWriter::writeSymbolTableEntryForControlSection(
 
   // 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.MCCsect));
+  W.write<uint8_t>(getEncodedType(CSectionRef.MCSec));
   // Storage mapping class.
-  W.write<uint8_t>(CSectionRef.MCCsect->getMappingClass());
+  W.write<uint8_t>(CSectionRef.MCSec->getMappingClass());
   // Reserved (x_stab).
   W.write<uint32_t>(0);
   // Reserved (x_snstab).
   W.write<uint16_t>(0);
 }
 
 void XCOFFObjectWriter::writeFileHeader() {
   // Magic.
void XCOFFObjectWriter::writeFileHeader() {
   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)
+    if (Sec->Index == SectionEntry::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.
void XCOFFObjectWriter::writeRelocation(XCOFFRelocation Reloc,
   W.write<uint32_t>(CSection.Address + Reloc.FixupOffsetInCsect);
   W.write<uint32_t>(Reloc.SymbolTableIndex);
   W.write<uint8_t>(Reloc.SignAndSize);
   W.write<uint8_t>(Reloc.Type);
 }
 
 void XCOFFObjectWriter::writeRelocations() {
   for (const auto *Section : Sections) {
-    if (Section->Index == Section::UninitializedIndex)
+    if (Section->Index == SectionEntry::UninitializedIndex)
       // Nothing to write for this Section.
       continue;
 
-    for (const auto *Group : Section->Groups) {
+    assert(isa<CsectSectionEntry>(Section) && "Only csect entry is supported!");
+    auto CsectEntry = dyn_cast<CsectSectionEntry>(Section);
+
+    for (const auto *Group : CsectEntry->Groups) {
       if (Group->empty())
         continue;
 
       for (const auto &Csect : *Group) {
         for (const auto Reloc : Csect.Relocations)
           writeRelocation(Reloc, Csect);
       }
     }
   }
 }
 
 void XCOFFObjectWriter::writeSymbolTable(const MCAsmLayout &Layout) {
   for (const auto &Csect : UndefinedCsects) {
-    writeSymbolTableEntryForControlSection(
-        Csect, XCOFF::ReservedSectionNum::N_UNDEF, Csect.MCCsect->getStorageClass());
+    writeSymbolTableEntryForControlSection(Csect,
+                                           XCOFF::ReservedSectionNum::N_UNDEF,
+                                           Csect.MCSec->getStorageClass());
   }
 
   for (const auto *Section : Sections) {
-    if (Section->Index == Section::UninitializedIndex)
+    if (Section->Index == SectionEntry::UninitializedIndex)
       // Nothing to write for this Section.
       continue;
 
-    for (const auto *Group : Section->Groups) {
+    assert(isa<CsectSectionEntry>(Section) && "Only csect entry is supported!");
+    auto CsectEntry = dyn_cast<CsectSectionEntry>(Section);
+
+    for (const auto *Group : CsectEntry->Groups) {
       if (Group->empty())
         continue;
 
-      const int16_t SectionIndex = Section->Index;
+      const int16_t SectionIndex = CsectEntry->Index;
       for (const auto &Csect : *Group) {
         // Write out the control section first and then each symbol in it.
         writeSymbolTableEntryForControlSection(
-            Csect, SectionIndex, Csect.MCCsect->getStorageClass());
+            Csect, SectionIndex, Csect.MCSec->getStorageClass());
 
         for (const auto &Sym : Csect.Syms)
           writeSymbolTableEntryForCsectMemberLabel(
               Sym, Csect, SectionIndex, Layout.getSymbolOffset(*(Sym.MCSym)));
       }
     }
   }
 }
 
 void XCOFFObjectWriter::finalizeSectionInfo() {
   for (auto *Section : Sections) {
-    if (Section->Index == Section::UninitializedIndex)
+    if (Section->Index == SectionEntry::UninitializedIndex)
       // Nothing to record for this Section.
       continue;
 
-    for (const auto *Group : Section->Groups) {
+    assert(isa<CsectSectionEntry>(Section) && "Only csect entry is supported!");
+    auto CsectEntry = dyn_cast<CsectSectionEntry>(Section);
+
+    for (const auto *Group : CsectEntry->Groups) {
       if (Group->empty())
         continue;
 
       for (auto &Csect : *Group) {
         const size_t CsectRelocCount = Csect.Relocations.size();
         if (CsectRelocCount >= XCOFF::RelocOverflow ||
             Section->RelocationCount >= XCOFF::RelocOverflow - CsectRelocCount)
           report_fatal_error(
               "relocation entries overflowed; overflow section is "
               "not implemented yet");
 
-        Section->RelocationCount += CsectRelocCount;
+        CsectEntry->RelocationCount += CsectRelocCount;
       }
     }
   }
 
   // Calculate the file offset to the relocation entries.
   uint64_t RawPointer = RelocationEntryOffset;
   for (auto Sec : Sections) {
-    if (Sec->Index == Section::UninitializedIndex || !Sec->RelocationCount)
+    assert(isa<CsectSectionEntry>(Sec) && "Only csect entry is supported!");
+    auto CsectEntry = dyn_cast<CsectSectionEntry>(Sec);
+
+    if (CsectEntry->Index == SectionEntry::UninitializedIndex ||
+        !CsectEntry->RelocationCount)
       continue;
 
-    Sec->FileOffsetToRelocations = RawPointer;
+    CsectEntry->FileOffsetToRelocations = RawPointer;
     const uint32_t RelocationSizeInSec =
-        Sec->RelocationCount * XCOFF::RelocationSerializationSize32;
+        CsectEntry->RelocationCount * XCOFF::RelocationSerializationSize32;
     RawPointer += RelocationSizeInSec;
     if (RawPointer > UINT32_MAX)
       report_fatal_error("Relocation data overflowed this object file.");
   }
 
   // TODO Error check that the number of symbol table entries fits in 32-bits
   // signed ...
   if (SymbolTableEntryCount)
     SymbolTableOffset = RawPointer;
 }
 
 void XCOFFObjectWriter::assignAddressesAndIndices(const MCAsmLayout &Layout) {
   // The first symbol table entry is for the file name. We are not emitting it
   // yet, so start at index 0.
   uint32_t SymbolTableIndex = 0;
 
   // Calculate indices for undefined symbols.
   for (auto &Csect : UndefinedCsects) {
     Csect.Size = 0;
     Csect.Address = 0;
     Csect.SymbolTableIndex = SymbolTableIndex;
-    SymbolIndexMap[Csect.MCCsect->getQualNameSymbol()] = Csect.SymbolTableIndex;
+    SymbolIndexMap[Csect.MCSec->getQualNameSymbol()] = Csect.SymbolTableIndex;
     // 1 main and 1 auxiliary symbol table entry for each contained symbol.
     SymbolTableIndex += 2;
   }
 
   // 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.
   uint32_t Address = 0;
   // Section indices are 1-based in XCOFF.
   int32_t SectionIndex = 1;
 
   for (auto *Section : Sections) {
+    assert(isa<CsectSectionEntry>(Section) && "Only csect entry is supported!");
+    auto CsectEntry = dyn_cast<CsectSectionEntry>(Section);
     const bool IsEmpty =
-        llvm::all_of(Section->Groups,
+        llvm::all_of(CsectEntry->Groups,
                      [](const CsectGroup *Group) { return Group->empty(); });
     if (IsEmpty)
       continue;
 
     if (SectionIndex > MaxSectionIndex)
       report_fatal_error("Section index overflow!");
-    Section->Index = SectionIndex++;
+    CsectEntry->Index = SectionIndex++;
     SectionCount++;
 
     bool SectionAddressSet = false;
-    for (auto *Group : Section->Groups) {
+    for (auto *Group : CsectEntry->Groups) {
       if (Group->empty())
         continue;
 
       for (auto &Csect : *Group) {
-        const MCSectionXCOFF *MCSec = Csect.MCCsect;
+        const MCSectionXCOFF *MCSec = Csect.MCSec;
         Csect.Address = alignTo(Address, MCSec->getAlignment());
         Csect.Size = Layout.getSectionAddressSize(MCSec);
         Address = Csect.Address + Csect.Size;
         Csect.SymbolTableIndex = SymbolTableIndex;
         SymbolIndexMap[MCSec->getQualNameSymbol()] = Csect.SymbolTableIndex;
         // 1 main and 1 auxiliary symbol table entry for the csect.
         SymbolTableIndex += 2;
 
         for (auto &Sym : Csect.Syms) {
           Sym.SymbolTableIndex = SymbolTableIndex;
           SymbolIndexMap[Sym.MCSym] = Sym.SymbolTableIndex;
           // 1 main and 1 auxiliary symbol table entry for each contained
           // symbol.
           SymbolTableIndex += 2;
         }
       }
 
       if (!SectionAddressSet) {
-        Section->Address = Group->front().Address;
+        CsectEntry->Address = Group->front().Address;
         SectionAddressSet = true;
       }
     }
 
     // Make sure the address of the next section aligned to
     // DefaultSectionAlign.
     Address = alignTo(Address, DefaultSectionAlign);
-    Section->Size = Address - Section->Address;
+    CsectEntry->Size = Address - CsectEntry->Address;
   }
 
   SymbolTableEntryCount = SymbolTableIndex;
 
   // Calculate the RawPointer value for each section.
   uint64_t RawPointer = sizeof(XCOFF::FileHeader32) + auxiliaryHeaderSize() +
                         SectionCount * sizeof(XCOFF::SectionHeader32);
   for (auto *Sec : Sections) {
-    if (Sec->Index == Section::UninitializedIndex || Sec->IsVirtual)
+    assert(isa<CsectSectionEntry>(Sec) && "Only csect entry is supported!");
+    auto CsectEntry = dyn_cast<CsectSectionEntry>(Sec);
+    if (CsectEntry->Index == SectionEntry::UninitializedIndex ||
+        CsectEntry->IsVirtual)
       continue;
 
-    Sec->FileOffsetToData = RawPointer;
-    RawPointer += Sec->Size;
+    CsectEntry->FileOffsetToData = RawPointer;
+    RawPointer += CsectEntry->Size;
     if (RawPointer > UINT32_MAX)
       report_fatal_error("Section raw data overflowed this object file.");
   }
 
   RelocationEntryOffset = RawPointer;
 }
 
 // Takes the log base 2 of the alignment and shifts the result into the 5 most