[XCOFF] support DWARF for 32-bit XCOFF for object output

[shchenz]

Summary

This patch adds DWARF support for XCOFF when clang generates object output. For now, it only works for 32-bit XCOFF.

D95518 adds DWARF support for XCOFF when clang generates assembly output.

[shchenz]

rebase and some formatting change

[shchenz]

gentle ping

[shchenz]

rebase due to change in D97049

[jasonliu]

FYI, I decide to review this patch before D97049 because I wouldn't know if the NFC make sense without the context of this patch.

llvm/lib/MC/XCOFFObjectWriter.cpp

231–232

Would SmallVector work here? I think SmallVector is generally more preferable then std::vector in llvm source.
Also, is it feasible to have pre-defined DWARF section entries as well? so that we don't need to worry about poping dwarf section when resetting. And it would be consistent with CsectSectionEntrys as well.

324

This reset for Sections is not clean. For any DwarfSectionEntrys, you only deleted what's in there. But your vector would still contain these new nullptrs.

422–424

Not a fan of raw news, it's always hard to track the ownership and where the deletion happens. I would suggest to use unique_ptr or just don't use pointer at all if possible.

593–594

Please address all the Lint comments.

681

I think we should use llvm-readobj to actually read the symbol entry for testing here.

784

1061

1063

It seems that it's possible for this address and the RawPointer to have mismatched address? As at here, we are aligning to MCSec->getAlignment(). But below when we get to dwarf sections, we would align the RawPointer to DefaultSectionAlign?
I think this is a bit confusing at least.

1087

This is more of a question:
I noticed that when doing csect calculations above, we would consider the padding as part of csect's size. But we do not consider the padding for dwarf sections to be part of the dwarf sections. Is it the behavior we derived from system assembler? Would it work if we just treat the paddings as part of dwarf sections?

llvm/test/DebugInfo/XCOFF/empty.ll

8

Could we also add a llvm-objdump test for this?
I think that test is useful to show the relationship between the dwarf raw datas and the other csects, as well as their alignments.

[shchenz]

address @jasonliu comments

[shchenz]

@jasonliu Thanks for your comments. Please see my inline reply.

llvm/lib/MC/XCOFFObjectWriter.cpp

231–232

Yeah, SmallVector should work.

For pre-defined DWARF sections, to be honest, I don't think it is a good idea. We should let the caller of the object writer tell the writer what sections we should write. In this way, we don't need to change the writer part when we add new DWARF/Csect sections later, for example when we add DWARF 5 sections. There are many of them, 20 without split sections and 30 with split sections. It would be not good to predefined all of them.

I think maybe the current DWARF section handling should make more sense? We may need to add a FIXME to the original TEXT/DATA/BSS Csect handling?

324

Good catch.

422–424

Yeah, this is a side effect due to the inconsistent DwarfSectionEntry and CsectSectionEntry handling.
Because CsectSectionEntry are now all pre-defined as XCOFFObjectWriter's class members, we can not use unique_ptr as element of XCOFFObjectWriter::Sections.
And because there are two child types of the Sections, so we must use the parent pointer as the element of XCOFFObjectWriter::Sections.

So that seems to leave us no other choice but to use raw new.
I think if we handle DwarfSectionEntry and CsectSectionEntry the same, predefining or dynamic allocating, we should get rid of this issue.

What do you think?

1063

Yeah, agree this will cause some issue. I update the RawPointer calculation logic.

1087

We can not treat the padding as part of the DWARF sections because in some DWARF sections, like .dwline/.dwinfo section, they will contain the section size info in the section content. I think we can not make the size in DWARF section and in section header table mismatch. (Please note there is 4-byte difference for 32-bit XCOFF due to the length field itself.)

llvm/test/DebugInfo/XCOFF/empty.ll

8

I add one cases containing two cases: one is for sections dump and one is for relocation table dump. I can not dump the symbol table as now all tools don't support that. Hope this is ok.

[jasonliu]

llvm/lib/MC/XCOFFObjectWriter.cpp

231–232

We choose to have current way of handling TEXT/DATA/BSS because we want to group certain csects together, and we don't want to use raw new/delete whenever possible. Therefore, we use the pre-defined sections.
For dwarf, do we need to group things together? If not, would it be better to treat dwarf sections as something special? For example, leave Sections as is. But create a new SmallVector<DwarfSectionEntry> DwarfSects. Notice that I'm not using pointers here, so no more raw new/delete as well. I don't see a huge value of putting csect sections and dwarf sections into the same Array, other than saving a few extra for loops.

328

This technically don't work as well, because you would clear the predefined csect sections.

422–424

Could we save XCOFFSection instead of a pointer to XCOFFSection inside of DwarfSectionEntry? That way, you don't need to new/delete.

[jasonliu]

llvm/lib/MC/XCOFFObjectWriter.cpp

231–232

The alternative is to change the handling of TEXT/DATA/BSS csect sections as you mentioned. But if we want to go that way, I strongly prefer to do it now instead of fixing it later. I don't think having pre-defined csects sections and pushing new dwarf sections into the same array would work well as it is.

[shchenz]

thanks for your review @jasonliu
I will post an NFC patch first to make csect be allocated dynamically.

llvm/lib/MC/XCOFFObjectWriter.cpp

231–232

I prefer to use a single vector to contain DWARF sections and csect sections. We should leverage the abstraction of class SectionEntry.

Will post a patch to refactor the predefined sections handling first to make them be dynamically allocated.

328

No, I think it will do the clean-up as expected. Here we should clear all sections including predefined csect sections.

[shchenz]

avoid to use raw new/delete

[shchenz]

1: update due to change in D99257

[shchenz]

gentle ping

[hubert.reinterpretcast]

llvm/lib/MC/MCSectionXCOFF.cpp

126

Retain the assert after returning for the DWARF section case.

[shchenz]

1: keep csect predefined
2: dynamic allocating dwarf sections

[shchenz]

gentle ping

[shchenz]

gentle ping

[jsji]

llvm/lib/MC/XCOFFObjectWriter.cpp

494

This is now a complicated expression, maybe using plain if else will make it clear without comment.

1043

Do we need this? Or an assert?

1101

Assert?

[shchenz]

address @jsji comments

[shchenz]

Thanks for your review @jsji . Updated accordingly.

[shchenz]

gentle ping

[shchenz]

gentle ping.

[shchenz]

gentle ping

[jsji]

LGTM as the first prototype, let us get this in first, we can always refactor later if needed.

[thakis]

Looks like this breaks tests on windows: http://45.33.8.238/win/46579/step_11.txt

Please take a look and revert for now if it takes a while to fix.

[shchenz]

In D97184#3049968, @thakis wrote:

Looks like this breaks tests on windows: http://45.33.8.238/win/46579/step_11.txt

Please take a look and revert for now if it takes a while to fix.

Thanks. 7c1171a0f36ac244d687cd9d3d456f8e5de58b5c is committed

llvm/lib/MC/MCSectionXCOFF.cpp

void MCSectionXCOFF::PrintSwitchToSection(const MCAsmInfo &MAI, const Triple &T,
   }
 
   report_fatal_error("Printing for this SectionKind is unimplemented.");
 }
 
 bool MCSectionXCOFF::UseCodeAlign() const { return getKind().isText(); }
 
 bool MCSectionXCOFF::isVirtualSection() const {
-  assert(isCsect() && "Only csect section can be virtual!");
+  // DWARF sections are always not virtual.
+  if (isDwarfSect())
+    return false;
+  assert(isCsect() &&
+         "Handling for isVirtualSection not implemented for this section!");
   return XCOFF::XTY_CM == CsectProp->Type;
 }

llvm/lib/MC/XCOFFObjectWriter.cpp

void reset() override {
     // Clear any csects we have stored.
     for (auto *Group : Groups)
       Group->clear();
   }
 
   virtual ~CsectSectionEntry() {}
 };
 
+struct DwarfSectionEntry : public SectionEntry {
+  // For DWARF section entry.
+  std::unique_ptr<XCOFFSection> DwarfSect;
+
+  DwarfSectionEntry(StringRef N, int32_t Flags,
+                    std::unique_ptr<XCOFFSection> Sect)
+      : SectionEntry(N, Flags | XCOFF::STYP_DWARF), DwarfSect(std::move(Sect)) {
+    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());
+  }
+
+  DwarfSectionEntry(DwarfSectionEntry &&s) = default;
+
+  virtual ~DwarfSectionEntry() {}
+};
+
 class XCOFFObjectWriter : public MCObjectWriter {
 
   uint32_t SymbolTableEntryCount = 0;
   uint32_t SymbolTableOffset = 0;
   uint16_t SectionCount = 0;
   uint32_t RelocationEntryOffset = 0;
 
   support::endian::Writer W;
class XCOFFObjectWriter : public MCObjectWriter {
   CsectSectionEntry Text;
   CsectSectionEntry Data;
   CsectSectionEntry BSS;
   CsectSectionEntry TData;
   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;
+
   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 XCOFFSection &, int16_t,
                                                 uint64_t);
   void writeSymbolTableEntryForControlSection(const XCOFFSection &, int16_t,
                                               XCOFF::StorageClass);
+  void writeSymbolTableEntryForDwarfSection(const XCOFFSection &, int16_t);
   void writeFileHeader();
   void writeSectionHeaderTable();
   void writeSections(const MCAssembler &Asm, const MCAsmLayout &Layout);
+  void writeSectionForControlSectionEntry(const MCAssembler &Asm,
+                                          const MCAsmLayout &Layout,
+                                          const CsectSectionEntry &CsectEntry,
+                                          uint32_t &CurrentAddressLocation);
+  void writeSectionForDwarfSectionEntry(const MCAssembler &Asm,
+                                        const MCAsmLayout &Layout,
+                                        const DwarfSectionEntry &DwarfEntry,
+                                        uint32_t &CurrentAddressLocation);
   void writeSymbolTable(const MCAsmLayout &Layout);
   void writeRelocations();
-  void writeRelocation(XCOFFRelocation Reloc, const XCOFFSection &CSection);
+  void writeRelocation(XCOFFRelocation Reloc, const XCOFFSection &Section);
 
   // Called after all the csects and symbols have been processed by
   // `executePostLayoutBinding`, this function handles building up the majority
   // of the structures in the object file representation. Namely:
   // *) Calculates physical/virtual addresses, raw-pointer offsets, and section
   //    sizes.
   // *) Assigns symbol table indices.
   // *) Builds up the section header table by adding any non-empty sections to
void XCOFFObjectWriter::reset() {
   // Clear the mappings we created.
   SymbolIndexMap.clear();
   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();
 
   // 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()) {
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 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 (MCSec->isCsect()) {
+      // A new control section. Its CsectSectionEntry should already be staticly
+      // generated as Text/Data/BSS/TDATA/TBSS. Add this section to the group of
+      // the CsectSectionEntry.
+      assert(XCOFF::XTY_ER != MCSec->getCSectType() &&
+             "An undefined csect should not get registered.");
       CsectGroup &Group = getCsectGroup(MCSec);
       Group.emplace_back(MCSec);
       SectionMap[MCSec] = &Group.back();
+    } else if (MCSec->isDwarfSect()) {
+      // A new DwarfSectionEntry.
+      std::unique_ptr<XCOFFSection> DwarfSec =
+          std::make_unique<XCOFFSection>(MCSec);
+      SectionMap[MCSec] = DwarfSec.get();
+
+      DwarfSectionEntry SecEntry(MCSec->getName(),
+                                 MCSec->getDwarfSubtypeFlags().getValue(),
+                                 std::move(DwarfSec));
+      DwarfSections.push_back(std::move(SecEntry));
+    } else
+      llvm_unreachable("unsupport section type!");
   }
 
   for (const MCSymbol &S : Asm.symbols()) {
     // Nothing to do for temporary symbols.
     if (S.isTemporary())
       continue;
 
     const MCSymbolXCOFF *XSym = cast<MCSymbolXCOFF>(&S);
auto getIndex = [this](const MCSymbol *Sym,
     // If we could not find the symbol directly in SymbolIndexMap, this symbol
     // could either be a temporary symbol or an undefined symbol. In this case,
     // we would need to have the relocation reference its csect instead.
     return SymbolIndexMap.find(Sym) != SymbolIndexMap.end()
                ? SymbolIndexMap[Sym]
                : SymbolIndexMap[ContainingCsect->getQualNameSymbol()];
   };
 
-  auto getVirtualAddress = [this,
-                            &Layout](const MCSymbol *Sym,
-                                     const MCSectionXCOFF *ContainingCsect) {
-    // If Sym is a csect, return csect's address.
-    // If Sym is a label, return csect's address + label's offset from the csect.
-    return SectionMap[ContainingCsect]->Address +
-           (Sym->isDefined() ? Layout.getSymbolOffset(*Sym) : 0);
+  auto getVirtualAddress =
+      [this, &Layout](const MCSymbol *Sym,
+                      const MCSectionXCOFF *ContainingSect) -> uint64_t {
+    // A DWARF section.
+    if (ContainingSect->isDwarfSect())
+      return Layout.getSymbolOffset(*Sym);
+
+    // A csect.
+    if (!Sym->isDefined())
+      return SectionMap[ContainingSect]->Address;
+
+    // A label.
+    assert(Sym->isDefined() && "not a valid object that has address!");
+    return SectionMap[ContainingSect]->Address + Layout.getSymbolOffset(*Sym);
   };
 
   const MCSymbol *const SymA = &Target.getSymA()->getSymbol();
 
   MCAsmBackend &Backend = Asm.getBackend();
   bool IsPCRel = Backend.getFixupKindInfo(Fixup.getKind()).Flags &
                  MCFixupKindInfo::FKF_IsPCRel;
 
void XCOFFObjectWriter::recordRelocation(MCAssembler &Asm,
   SectionMap[RelocationSec]->Relocations.push_back(RelocB);
   // We already folded "SymbolA + imm64" above when Type is R_POS for SymbolA,
   // 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) {
-    // Nothing to write for this Section.
-    if (Section->Index == SectionEntry::UninitializedIndex ||
-        Section->IsVirtual)
-      continue;
-
-    // There could be a gap (without corresponding zero padding) between
-    // sections.
-    assert(((CurrentAddressLocation <= Section->Address) ||
-            (Section->Flags == XCOFF::STYP_TDATA) ||
-            (Section->Flags == XCOFF::STYP_TBSS)) &&
-           "CurrentAddressLocation should be less than or equal to section "
-           "address if the section is not TData or TBSS.");
-
-    CurrentAddressLocation = Section->Address;
-
-    for (const auto *Group : Section->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.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) {
-      W.OS.write_zeros(PaddingSize);
-      CurrentAddressLocation += PaddingSize;
-    }
-  }
+  for (const auto *Section : Sections)
+    writeSectionForControlSectionEntry(Asm, Layout, *Section,
+                                       CurrentAddressLocation);
+  for (const auto &DwarfSection : DwarfSections)
+    writeSectionForDwarfSectionEntry(Asm, Layout, DwarfSection,
+                                     CurrentAddressLocation);
 }
 
 uint64_t XCOFFObjectWriter::writeObject(MCAssembler &Asm,
                                         const MCAsmLayout &Layout) {
   // We always emit a timestamp of 0 for reproducibility, so ensure incremental
   // linking is not enabled, in case, like with Windows COFF, such a timestamp
   // is incompatible with incremental linking of XCOFF.
   if (Asm.isIncrementalLinkerCompatible())
void XCOFFObjectWriter::writeSymbolTableEntryForCsectMemberLabel(
   // Storage mapping class.
   W.write<uint8_t>(CSectionRef.MCSec->getMappingClass());
   // Reserved (x_stab).
   W.write<uint32_t>(0);
   // Reserved (x_snstab).
   W.write<uint16_t>(0);
 }
 
+void XCOFFObjectWriter::writeSymbolTableEntryForDwarfSection(
+    const XCOFFSection &DwarfSectionRef, int16_t SectionIndex) {
+  assert(DwarfSectionRef.MCSec->isDwarfSect() && "Not a DWARF section!");
+
+  // n_name, n_zeros, n_offset
+  writeSymbolName(DwarfSectionRef.getSymbolTableName());
+  // n_value
+  W.write<uint32_t>(0);
+  // n_scnum
+  W.write<int16_t>(SectionIndex);
+  // n_type
+  W.write<uint16_t>(0);
+  // n_sclass
+  W.write<uint8_t>(XCOFF::C_DWARF);
+  // Always 1 aux entry for now.
+  W.write<uint8_t>(1);
+
+  // Now output the auxiliary entry.
+  // x_scnlen
+  W.write<uint32_t>(DwarfSectionRef.Size);
+  // Reserved
+  W.write<uint32_t>(0);
+  // x_nreloc. Set to 0 for now.
+  W.write<uint32_t>(0);
+  // Reserved
+  W.write<uint32_t>(0);
+  // Reserved
+  W.write<uint16_t>(0);
+}
+
 void XCOFFObjectWriter::writeSymbolTableEntryForControlSection(
     const XCOFFSection &CSectionRef, int16_t SectionIndex,
     XCOFF::StorageClass StorageClass) {
   // n_name, n_zeros, n_offset
   writeSymbolName(CSectionRef.getSymbolTableName());
   // n_value
   W.write<uint32_t>(CSectionRef.Address);
   // n_scnum
void XCOFFObjectWriter::writeFileHeader() {
   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) {
+  auto writeSectionHeader = [&](const SectionEntry *Sec, bool IsDwarf) {
     // Nothing to write for this Section.
     if (Sec->Index == SectionEntry::UninitializedIndex)
-      continue;
+      return false;
 
     // Write Name.
     ArrayRef<char> NameRef(Sec->Name, XCOFF::NameSize);
     W.write(NameRef);
 
     // Write the Physical Address and Virtual Address. In an object file these
     // are the same.
+    // We use 0 for DWARF sections' Physical and Virtual Addresses.
+    if (!IsDwarf) {
       W.write<uint32_t>(Sec->Address);
       W.write<uint32_t>(Sec->Address);
+    } else {
+      W.write<uint32_t>(0);
+      W.write<uint32_t>(0);
+    }
 
     W.write<uint32_t>(Sec->Size);
     W.write<uint32_t>(Sec->FileOffsetToData);
     W.write<uint32_t>(Sec->FileOffsetToRelocations);
 
     // Line number pointer. Not supported yet.
     W.write<uint32_t>(0);
 
     W.write<uint16_t>(Sec->RelocationCount);
 
     // Line number counts. Not supported yet.
     W.write<uint16_t>(0);
 
     W.write<int32_t>(Sec->Flags);
-  }
+
+    return true;
+  };
+
+  for (const auto *CsectSec : Sections)
+    writeSectionHeader(CsectSec, /* IsDwarf */ false);
+  for (const auto &DwarfSec : DwarfSections)
+    writeSectionHeader(&DwarfSec, /* IsDwarf */ true);
 }
 
 void XCOFFObjectWriter::writeRelocation(XCOFFRelocation Reloc,
-                                        const XCOFFSection &CSection) {
-  W.write<uint32_t>(CSection.Address + Reloc.FixupOffsetInCsect);
+                                        const XCOFFSection &Section) {
+  if (Section.MCSec->isCsect())
+    W.write<uint32_t>(Section.Address + Reloc.FixupOffsetInCsect);
+  else {
+    // DWARF sections' address is set to 0.
+    assert(Section.MCSec->isDwarfSect() && "unsupport section type!");
+    W.write<uint32_t>(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 == SectionEntry::UninitializedIndex)
       // Nothing to write for this Section.
       continue;
 
     for (const auto *Group : Section->Groups) {
       if (Group->empty())
         continue;
 
       for (const auto &Csect : *Group) {
         for (const auto Reloc : Csect.Relocations)
           writeRelocation(Reloc, Csect);
       }
     }
   }
+
+  for (const auto &DwarfSection : DwarfSections)
+    for (const auto &Reloc : DwarfSection.DwarfSect->Relocations)
+      writeRelocation(Reloc, *DwarfSection.DwarfSect);
 }
 
 void XCOFFObjectWriter::writeSymbolTable(const MCAsmLayout &Layout) {
   // Write symbol 0 as C_FILE.
   // FIXME: support 64-bit C_FILE symbol.
   //
   // n_name. The n_name of a C_FILE symbol is the source filename when no
   // auxiliary entries are present. The source filename is alternatively
for (const auto *Group : Section->Groups) {
                                                Csect.MCSec->getStorageClass());
 
         for (const auto &Sym : Csect.Syms)
           writeSymbolTableEntryForCsectMemberLabel(
               Sym, Csect, SectionIndex, Layout.getSymbolOffset(*(Sym.MCSym)));
       }
     }
   }
+
+  for (const auto &DwarfSection : DwarfSections)
+    writeSymbolTableEntryForDwarfSection(*DwarfSection.DwarfSect,
+                                         DwarfSection.Index);
 }
 
 void XCOFFObjectWriter::finalizeSectionInfo() {
   for (auto *Section : Sections) {
     if (Section->Index == SectionEntry::UninitializedIndex)
       // Nothing to record for this Section.
       continue;
 
for (const auto *Group : Section->Groups) {
               "relocation entries overflowed; overflow section is "
               "not implemented yet");
 
         Section->RelocationCount += CsectRelocCount;
       }
     }
   }
 
+  for (auto &DwarfSection : DwarfSections)
+    DwarfSection.RelocationCount = DwarfSection.DwarfSect->Relocations.size();
+
   // Calculate the file offset to the relocation entries.
   uint64_t RawPointer = RelocationEntryOffset;
-  for (auto Sec : Sections) {
-    if (Sec->Index == SectionEntry::UninitializedIndex || !Sec->RelocationCount)
-      continue;
+  auto calcOffsetToRelocations = [&](SectionEntry *Sec, bool IsDwarf) {
+    if (!IsDwarf && Sec->Index == SectionEntry::UninitializedIndex)
+      return false;
+
+    if (!Sec->RelocationCount)
+      return false;
 
     Sec->FileOffsetToRelocations = RawPointer;
     const uint32_t RelocationSizeInSec =
         Sec->RelocationCount * XCOFF::RelocationSerializationSize32;
     RawPointer += RelocationSizeInSec;
     if (RawPointer > UINT32_MAX)
       report_fatal_error("Relocation data overflowed this object file.");
-  }
+
+    return true;
+  };
+
+  for (auto *Sec : Sections)
+    calcOffsetToRelocations(Sec, /* IsDwarf */ false);
+
+  for (auto &DwarfSec : DwarfSections)
+    calcOffsetToRelocations(&DwarfSec, /* IsDwarf */ true);
 
   // 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) {
for (auto *Section : Sections) {
     }
 
     // Make sure the address of the next section aligned to
     // DefaultSectionAlign.
     Address = alignTo(Address, DefaultSectionAlign);
     Section->Size = Address - Section->Address;
   }
 
+  for (auto &DwarfSection : DwarfSections) {
+    assert((SectionIndex <= MaxSectionIndex) && "Section index overflow!");
+
+    XCOFFSection &DwarfSect = *DwarfSection.DwarfSect;
+    const MCSectionXCOFF *MCSec = DwarfSect.MCSec;
+
+    // Section index.
+    DwarfSection.Index = SectionIndex++;
+    SectionCount++;
+
+    // Symbol index.
+    DwarfSect.SymbolTableIndex = SymbolTableIndex;
+    SymbolIndexMap[MCSec->getQualNameSymbol()] = DwarfSect.SymbolTableIndex;
+    // 1 main and 1 auxiliary symbol table entry for the csect.
+    SymbolTableIndex += 2;
+
+    // Section address. Make it align to section alignment.
+    // We use address 0 for DWARF sections' Physical and Virtual Addresses.
+    // This address is used to tell where is the section in the final object.
+    // See writeSectionForDwarfSectionEntry().
+    DwarfSection.Address = DwarfSect.Address =
+        alignTo(Address, MCSec->getAlignment());
+
+    // Section size.
+    // For DWARF section, we must use the real size which may be not aligned.
+    DwarfSection.Size = DwarfSect.Size = Layout.getSectionAddressSize(MCSec);
+
+    // Make the Address align to default alignment for follow section.
+    Address = alignTo(DwarfSect.Address + DwarfSect.Size, DefaultSectionAlign);
+  }
+
   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 == SectionEntry::UninitializedIndex || Sec->IsVirtual)
       continue;
 
     Sec->FileOffsetToData = RawPointer;
     RawPointer += Sec->Size;
     if (RawPointer > UINT32_MAX)
       report_fatal_error("Section raw data overflowed this object file.");
   }
 
+  for (auto &DwarfSection : DwarfSections) {
+    // Address of csect sections are always aligned to DefaultSectionAlign, but
+    // address of DWARF section are aligned to Section alignment which may be
+    // bigger than DefaultSectionAlign, need to execlude the padding bits.
+    RawPointer =
+          alignTo(RawPointer, DwarfSection.DwarfSect->MCSec->getAlignment());
+
+    DwarfSection.FileOffsetToData = RawPointer;
+    // Some section entries, like DWARF section size is not aligned, so
+    // RawPointer may be not aligned.
+    RawPointer += DwarfSection.Size;
+    // Make sure RawPointer is aligned.
+    RawPointer = alignTo(RawPointer, DefaultSectionAlign);
+
+    assert(RawPointer <= UINT32_MAX &&
+           "Section raw data overflowed this object file.");
+  }
+
   RelocationEntryOffset = RawPointer;
 }
 
+void XCOFFObjectWriter::writeSectionForControlSectionEntry(
+    const MCAssembler &Asm, const MCAsmLayout &Layout,
+    const CsectSectionEntry &CsectEntry, uint32_t &CurrentAddressLocation) {
+  // Nothing to write for this Section.
+  if (CsectEntry.Index == SectionEntry::UninitializedIndex)
+    return;
+
+  // There could be a gap (without corresponding zero padding) between
+  // sections.
+  // There could be a gap (without corresponding zero padding) between
+  // sections.
+  assert(((CurrentAddressLocation <= CsectEntry.Address) ||
+          (CsectEntry.Flags == XCOFF::STYP_TDATA) ||
+          (CsectEntry.Flags == XCOFF::STYP_TBSS)) &&
+         "CurrentAddressLocation should be less than or equal to section "
+         "address if the section is not TData or TBSS.");
+
+  CurrentAddressLocation = CsectEntry.Address;
+
+  // For virtual sections, nothing to write. But need to increase
+  // CurrentAddressLocation for later sections like DWARF section has a correct
+  // writing location.
+  if (CsectEntry.IsVirtual) {
+    CurrentAddressLocation += CsectEntry.Size;
+    return;
+  }
+
+  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.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 =
+          CsectEntry.Address + CsectEntry.Size - CurrentAddressLocation) {
+    W.OS.write_zeros(PaddingSize);
+    CurrentAddressLocation += PaddingSize;
+  }
+}
+
+void XCOFFObjectWriter::writeSectionForDwarfSectionEntry(
+    const MCAssembler &Asm, const MCAsmLayout &Layout,
+    const DwarfSectionEntry &DwarfEntry, uint32_t &CurrentAddressLocation) {
+  // There could be a gap (without corresponding zero padding) between
+  // sections. For example DWARF section alignment is bigger than
+  // DefaultSectionAlign.
+  assert(CurrentAddressLocation <= DwarfEntry.Address &&
+         "CurrentAddressLocation should be less than or equal to section "
+         "address.");
+
+  if (uint32_t PaddingSize = DwarfEntry.Address - CurrentAddressLocation)
+    W.OS.write_zeros(PaddingSize);
+
+  if (DwarfEntry.Size)
+    Asm.writeSectionData(W.OS, DwarfEntry.DwarfSect->MCSec, Layout);
+
+  CurrentAddressLocation = DwarfEntry.Address + DwarfEntry.Size;
+
+  // DWARF section size is not aligned to DefaultSectionAlign.
+  // Make sure CurrentAddressLocation is aligned to DefaultSectionAlign.
+  uint32_t Mod = CurrentAddressLocation % DefaultSectionAlign;
+  uint32_t TailPaddingSize = Mod ? DefaultSectionAlign - Mod : 0;
+  if (TailPaddingSize)
+    W.OS.write_zeros(TailPaddingSize);
+
+  CurrentAddressLocation += TailPaddingSize;
+}
+
 // Takes the log base 2 of the alignment and shifts the result into the 5 most
 // significant bits of a byte, then or's in the csect type into the least
 // significant 3 bits.
 uint8_t getEncodedType(const MCSectionXCOFF *Sec) {
   unsigned Align = Sec->getAlignment();
   assert(isPowerOf2_32(Align) && "Alignment must be a power of 2.");
   unsigned Log2Align = Log2_32(Align);
   // Result is a number in the range [0, 31] which fits in the 5 least

llvm/test/CodeGen/PowerPC/aix-dwarf.ll

+
+; RUN: llc -mtriple powerpc-ibm-aix-xcoff -filetype=obj -o %t.o < %s
+; RUN: llvm-readobj --section-headers %t.o | FileCheck %s --check-prefix=SEC
+; RUN: llc -mtriple powerpc-ibm-aix-xcoff -filetype=obj -o %t.o < %s
+; RUN: llvm-objdump -r %t.o | FileCheck %s --check-prefix=RELO
+
+; This file is copied from test/DebugInfo/XCOFF/empty.ll.
+; In this test, we focus on XCOFF related formats, like section headers,
+; relocation entries.
+
+source_filename = "1.c"
+target datalayout = "E-m:a-p:32:32-i64:64-n32"
+
+; Function Attrs: noinline nounwind optnone
+define i32 @main() #0 !dbg !8 {
+entry:
+  %retval = alloca i32, align 4
+  store i32 0, i32* %retval, align 4
+  ret i32 0, !dbg !12
+}
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!3, !4, !5, !6}
+!llvm.ident = !{!7}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 12.0.0", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, nameTableKind: None)
+!1 = !DIFile(filename: "1.c", directory: "debug")
+!2 = !{}
+!3 = !{i32 7, !"Dwarf Version", i32 4}
+!4 = !{i32 2, !"Debug Info Version", i32 3}
+!5 = !{i32 1, !"wchar_size", i32 2}
+!6 = !{i32 7, !"PIC Level", i32 2}
+!7 = !{!"clang version 12.0.0"}
+!8 = distinct !DISubprogram(name: "main", scope: !1, file: !1, line: 1, type: !9, scopeLine: 2, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !2)
+!9 = !DISubroutineType(types: !10)
+!10 = !{!11}
+!11 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!12 = !DILocation(line: 3, column: 3, scope: !8)
+
+; SEC:       AddressSize: 32bit
+; SEC-NEXT:  Sections [
+; SEC-NEXT:    Section {
+; SEC-NEXT:      Index: 1
+; SEC-NEXT:      Name: .text
+; SEC-NEXT:      PhysicalAddress: 0x0
+; SEC-NEXT:      VirtualAddress: 0x0
+; SEC-NEXT:      Size: 0x28
+; SEC-NEXT:      RawDataOffset: 0xDC
+; SEC-NEXT:      RelocationPointer: 0x0
+; SEC-NEXT:      LineNumberPointer: 0x0
+; SEC-NEXT:      NumberOfRelocations: 0
+; SEC-NEXT:      NumberOfLineNumbers: 0
+; SEC-NEXT:      Type: STYP_TEXT (0x20)
+; SEC-NEXT:    }
+; SEC-NEXT:    Section {
+; SEC-NEXT:      Index: 2
+; SEC-NEXT:      Name: .data
+; SEC-NEXT:      PhysicalAddress: 0x28
+; SEC-NEXT:      VirtualAddress: 0x28
+; SEC-NEXT:      Size: 0xC
+; SEC-NEXT:      RawDataOffset: 0x104
+; SEC-NEXT:      RelocationPointer: 0x1D8
+; SEC-NEXT:      LineNumberPointer: 0x0
+; SEC-NEXT:      NumberOfRelocations: 2
+; SEC-NEXT:      NumberOfLineNumbers: 0
+; SEC-NEXT:      Type: STYP_DATA (0x40)
+; SEC-NEXT:    }
+; SEC-NEXT:    Section {
+; SEC-NEXT:      Index: 3
+; SEC-NEXT:      Name: .dwabrev
+; SEC-NEXT:      PhysicalAddress: 0x0
+; SEC-NEXT:      VirtualAddress: 0x0
+; SEC-NEXT:      Size: 0x36
+; SEC-NEXT:      RawDataOffset: 0x110
+; SEC-NEXT:      RelocationPointer: 0x0
+; SEC-NEXT:      LineNumberPointer: 0x0
+; SEC-NEXT:      NumberOfRelocations: 0
+; SEC-NEXT:      NumberOfLineNumbers: 0
+; SEC-NEXT:      Type: STYP_DWARF (0x10)
+; SEC-NEXT:    }
+; SEC-NEXT:    Section {
+; SEC-NEXT:      Index: 4
+; SEC-NEXT:      Name: .dwinfo
+; SEC-NEXT:      PhysicalAddress: 0x0
+; SEC-NEXT:      VirtualAddress: 0x0
+; SEC-NEXT:      Size: 0x57
+; SEC-NEXT:      RawDataOffset: 0x148
+; SEC-NEXT:      RelocationPointer: 0x1EC
+; SEC-NEXT:      LineNumberPointer: 0x0
+; SEC-NEXT:      NumberOfRelocations: 4
+; SEC-NEXT:      NumberOfLineNumbers: 0
+; SEC-NEXT:      Type: STYP_DWARF (0x10)
+; SEC-NEXT:    }
+; SEC-NEXT:    Section {
+; SEC-NEXT:      Index: 5
+; SEC-NEXT:      Name: .dwline
+; SEC-NEXT:      PhysicalAddress: 0x0
+; SEC-NEXT:      VirtualAddress: 0x0
+; SEC-NEXT:      Size: 0x36
+; SEC-NEXT:      RawDataOffset: 0x1A0
+; SEC-NEXT:      RelocationPointer: 0x214
+; SEC-NEXT:      LineNumberPointer: 0x0
+; SEC-NEXT:      NumberOfRelocations: 1
+; SEC-NEXT:      NumberOfLineNumbers: 0
+; SEC-NEXT:      Type: STYP_DWARF (0x10)
+; SEC-NEXT:    }
+; SEC-NEXT:  ]
+
+; RELO:      RELOCATION RECORDS FOR [.dwinfo]:
+; RELO-NEXT:  OFFSET   TYPE                     VALUE
+; RELO-NEXT:  00000006 R_POS                    .dwabrev
+; RELO-NEXT:  00000027 R_POS                    .dwline
+; RELO-NEXT:  00000009 R_POS                    .text
+; RELO-NEXT:  0000003a R_POS                    .text
+; RELO:       RELOCATION RECORDS FOR [.dwline]:
+; RELO-NEXT:  OFFSET   TYPE                     VALUE
+; RELO-NEXT:  00000000 R_POS                    .text

llvm/test/DebugInfo/XCOFF/empty.ll

 
 ; RUN: llc -debugger-tune=gdb -mtriple powerpc-ibm-aix-xcoff < %s | \
 ; RUN:   FileCheck %s --check-prefix=ASM32
 ; RUN: llc -debugger-tune=gdb -mtriple powerpc64-ibm-aix-xcoff < %s | \
 ; RUN:   FileCheck %s --check-prefix=ASM64
+; RUN: llc -mtriple powerpc-ibm-aix-xcoff -filetype=obj < %s | \
+; RUN:   llvm-dwarfdump --all - | FileCheck %s --check-prefix=DWARF32
 
 source_filename = "1.c"
 target datalayout = "E-m:a-p:32:32-i64:64-n32"
 
 ; Function Attrs: noinline nounwind optnone
 define i32 @main() #0 !dbg !8 {
 entry:
   %retval = alloca i32, align 4
   store i32 0, i32* %retval, align 4

 ; ASM64-NEXT:          .byte   0                               # Set address to L..sec_end0
 ; ASM64-NEXT:          .byte   9
 ; ASM64-NEXT:          .byte   2
 ; ASM64-NEXT:          .vbyte  8, L..sec_end0
 ; ASM64-NEXT:          .byte   0                               # End sequence
 ; ASM64-NEXT:          .byte   1
 ; ASM64-NEXT:          .byte   1
 ; ASM64-NEXT:  L..debug_line_end0:
+
+; DWARF32:       :        file format aixcoff-rs6000
+; DWARF32:       .debug_abbrev contents:
+; DWARF32-NEXT:  Abbrev table for offset: 0x00000000
+; DWARF32-NEXT:  [1] DW_TAG_compile_unit DW_CHILDREN_yes
+; DWARF32-NEXT:          DW_AT_producer  DW_FORM_string
+; DWARF32-NEXT:          DW_AT_language  DW_FORM_data2
+; DWARF32-NEXT:          DW_AT_name      DW_FORM_string
+; DWARF32-NEXT:          DW_AT_stmt_list DW_FORM_sec_offset
+; DWARF32-NEXT:          DW_AT_comp_dir  DW_FORM_string
+; DWARF32-NEXT:          DW_AT_low_pc    DW_FORM_addr
+; DWARF32-NEXT:          DW_AT_high_pc   DW_FORM_data4
+; DWARF32:       [2] DW_TAG_subprogram   DW_CHILDREN_no
+; DWARF32-NEXT:          DW_AT_low_pc    DW_FORM_addr
+; DWARF32-NEXT:          DW_AT_high_pc   DW_FORM_data4
+; DWARF32-NEXT:          DW_AT_frame_base        DW_FORM_exprloc
+; DWARF32-NEXT:          DW_AT_name      DW_FORM_string
+; DWARF32-NEXT:          DW_AT_decl_file DW_FORM_data1
+; DWARF32-NEXT:          DW_AT_decl_line DW_FORM_data1
+; DWARF32-NEXT:          DW_AT_prototyped        DW_FORM_flag_present
+; DWARF32-NEXT:          DW_AT_type      DW_FORM_ref4
+; DWARF32-NEXT:          DW_AT_external  DW_FORM_flag_present
+; DWARF32:       [3] DW_TAG_base_type    DW_CHILDREN_no
+; DWARF32-NEXT:          DW_AT_name      DW_FORM_string
+; DWARF32-NEXT:          DW_AT_encoding  DW_FORM_data1
+; DWARF32-NEXT:          DW_AT_byte_size DW_FORM_data1
+; DWARF32:       .debug_info contents:
+; DWARF32-NEXT:  0x00000000: Compile Unit: length = 0x00000053, format = DWARF32, version = 0x0004, abbr_offset = 0x0000, addr_size = 0x04 (next unit at 0x00000057)
+; DWARF32:       0x0000000b: DW_TAG_compile_unit
+; DWARF32-NEXT:                DW_AT_producer    ("clang version 12.0.0")
+; DWARF32-NEXT:                DW_AT_language    (DW_LANG_C99)
+; DWARF32-NEXT:                DW_AT_name        ("1.c")
+; DWARF32-NEXT:                DW_AT_stmt_list   (0x00000000)
+; DWARF32-NEXT:                DW_AT_comp_dir    ("debug")
+; DWARF32-NEXT:                DW_AT_low_pc      (0x00000000)
+; DWARF32-NEXT:                DW_AT_high_pc     (0x00000026)
+; DWARF32:       0x00000039:   DW_TAG_subprogram
+; DWARF32-NEXT:                  DW_AT_low_pc    (0x00000000)
+; DWARF32-NEXT:                  DW_AT_high_pc   (0x00000026)
+; DWARF32-NEXT:                  DW_AT_frame_base        (DW_OP_reg1 R1)
+; DWARF32-NEXT:                  DW_AT_name      ("main")
+; DWARF32-NEXT:                  DW_AT_decl_file ("debug/1.c")
+; DWARF32-NEXT:                  DW_AT_decl_line (1)
+; DWARF32-NEXT:                  DW_AT_prototyped        (true)
+; DWARF32-NEXT:                  DW_AT_type      (0x0000004f "int")
+; DWARF32-NEXT:                  DW_AT_external  (true)
+; DWARF32:       0x0000004f:   DW_TAG_base_type
+; DWARF32-NEXT:                  DW_AT_name      ("int")
+; DWARF32-NEXT:                  DW_AT_encoding  (DW_ATE_signed)
+; DWARF32-NEXT:                  DW_AT_byte_size (0x04)
+; DWARF32:       0x00000056:   NULL
+; DWARF32:       .debug_line contents:
+; DWARF32-NEXT:  debug_line[0x00000000]
+; DWARF32-NEXT:  Line table prologue:
+; DWARF32-NEXT:      total_length: 0x00000032
+; DWARF32-NEXT:            format: DWARF32
+; DWARF32-NEXT:           version: 4
+; DWARF32-NEXT:   prologue_length: 0x0000001b
+; DWARF32-NEXT:   min_inst_length: 4
+; DWARF32-NEXT:  max_ops_per_inst: 1
+; DWARF32-NEXT:   default_is_stmt: 1
+; DWARF32-NEXT:         line_base: -5
+; DWARF32-NEXT:        line_range: 14
+; DWARF32-NEXT:       opcode_base: 13
+; DWARF32-NEXT:  standard_opcode_lengths[DW_LNS_copy] = 0
+; DWARF32-NEXT:  standard_opcode_lengths[DW_LNS_advance_pc] = 1
+; DWARF32-NEXT:  standard_opcode_lengths[DW_LNS_advance_line] = 1
+; DWARF32-NEXT:  standard_opcode_lengths[DW_LNS_set_file] = 1
+; DWARF32-NEXT:  standard_opcode_lengths[DW_LNS_set_column] = 1
+; DWARF32-NEXT:  standard_opcode_lengths[DW_LNS_negate_stmt] = 0
+; DWARF32-NEXT:  standard_opcode_lengths[DW_LNS_set_basic_block] = 0
+; DWARF32-NEXT:  standard_opcode_lengths[DW_LNS_const_add_pc] = 0
+; DWARF32-NEXT:  standard_opcode_lengths[DW_LNS_fixed_advance_pc] = 1
+; DWARF32-NEXT:  standard_opcode_lengths[DW_LNS_set_prologue_end] = 0
+; DWARF32-NEXT:  standard_opcode_lengths[DW_LNS_set_epilogue_begin] = 0
+; DWARF32-NEXT:  standard_opcode_lengths[DW_LNS_set_isa] = 1
+; DWARF32-NEXT:  file_names[  1]:
+; DWARF32-NEXT:             name: "1.c"
+; DWARF32-NEXT:        dir_index: 0
+; DWARF32-NEXT:         mod_time: 0x00000000
+; DWARF32-NEXT:           length: 0x00000000
+; DWARF32:       Address            Line   Column File   ISA Discriminator Flags
+; DWARF32-NEXT:  ------------------ ------ ------ ------ --- ------------- -------------
+; DWARF32-NEXT:  0x0000000000000000      2      0      1   0             0  is_stmt
+; DWARF32-NEXT:  0x0000000000000004      3      3      1   0             0  is_stmt prologue_end
+; DWARF32-NEXT:  0x0000000000000024      3      3      1   0             0  is_stmt end_sequence