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

(On Diff #325388)

Need rebase after D95518?

[shchenz]

llvm/include/llvm/MC/MCSectionXCOFF.h

107 ↗

(On Diff #325388)

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/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;
   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(); }
+  XCOFFSection(const MCSectionXCOFF *MCSec)
+      : MCSec(MCSec), SymbolTableIndex(-1), Address(-1), Size(0) {}
 };
 
 // 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 CsectGroup = std::deque<XCOFFSection>;
 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;
 
   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, int32_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<XCOFFSection> DwarfSect;
+
+  DwarfSectionEntry(StringRef N, int32_t Flags, XCOFFSection *DwarfSect)
+      : SectionEntry(N, Flags | XCOFF::STYP_DWARF),
+        DwarfSect(std::unique_ptr<XCOFFSection>(DwarfSect)) {
+    assert(DwarfSect->MCSec->isDwarfSect() && "This should be a DWARF section!");
     assert(N.size() <= XCOFF::NameSize && "section name too long");
     memcpy(Name, N.data(), N.size());
   }
+
+  void reset() override {
+    SectionEntry::reset();
+    // Destory XCOFFSection 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
+  // 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 *, 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 *,
                         const MCFixup &, MCValue, uint64_t &) override;
 
   uint64_t writeObject(MCAssembler &, const MCAsmLayout &) override;
 
   static bool nameShouldBeInStringTable(const StringRef &);
   void writeSymbolName(const StringRef &);
   void writeSymbolTableEntryForCsectMemberLabel(const Symbol &,
-                                                const ControlSection &, int16_t,
+                                                const XCOFFSection &, int16_t,
                                                 uint64_t);
-  void writeSymbolTableEntryForControlSection(const ControlSection &, int16_t,
+  void writeSymbolTableEntryForControlSection(const XCOFFSection &, int16_t,
                                               XCOFF::StorageClass);
   void writeFileHeader();
   void writeSectionHeaderTable();
   void writeSections(const MCAssembler &Asm, const MCAsmLayout &Layout);
   void writeSymbolTable(const MCAsmLayout &Layout);
   void writeRelocations();
-  void writeRelocation(XCOFFRelocation Reloc, const ControlSection &CSection);
+  void writeRelocation(XCOFFRelocation Reloc, const XCOFFSection &CSection);
 
   // 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.
   // *) Assigns symbol table indices.
   // *) Builds up the section header table by adding any non-empty sections to

 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());
 
if (XSym == ContainingCsect->getQualNameSymbol())
       continue;
 
     // 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");
+    XCOFFSection *Csect = SectionMap[ContainingCsect];
     // Lookup the containing csect and add the symbol to it.
-    SectionMap[ContainingCsect]->Syms.emplace_back(XSym);
+    assert(Csect->MCSec->isCsect() && "only csect is supported now!");
+    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) {
if (nameShouldBeInStringTable(SymbolName)) {
     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 ControlSection &CSectionRef,
+    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);
   // Basic/Derived type. See the description of the n_type field for symbol
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,
+    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
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.
for (const auto *Sec : Sections) {
     // Line number counts. Not supported yet.
     W.write<uint16_t>(0);
 
     W.write<int32_t>(Sec->Flags);
   }
 }
 
 void XCOFFObjectWriter::writeRelocation(XCOFFRelocation Reloc,
-                                        const ControlSection &CSection) {
+                                        const XCOFFSection &CSection) {
   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) {
   // 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);
 
   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());
+        writeSymbolTableEntryForControlSection(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 (at index 0) is for the file name.
   uint32_t SymbolTableIndex = 1;
 
   // 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