[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

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.

362

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.

473–475

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.

687–695

Please address all the Lint comments.

778

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

881

1137

1139

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.

1168

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

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?

362

Good catch.

473–475

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?

1139

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

1168

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

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.

366

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

473–475

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

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

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.

366

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

117

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

587

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

1154

Do we need this? Or an assert?

1194

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;
   return XCOFF::XTY_CM == CsectProp->Type;
 }

llvm/lib/MC/XCOFFObjectWriter.cpp

class XCOFFObjectWriter : public MCObjectWriter {
   // wrapper. Needed for finding the XCOFFSection to insert an MCSymbol into
   // from its containing MCSectionXCOFF.
   DenseMap<const MCSectionXCOFF *, XCOFFSection *> SectionMap;
 
   // Maps the MCSymbol representation to its corrresponding symbol table index.
   // Needed for relocation.
   DenseMap<const MCSymbol *, uint32_t> SymbolIndexMap;
 
   std::unique_ptr<CsectGroup> UndefinedCsects;
 
   // All the XCOFF sections.
   SmallVector<std::unique_ptr<SectionEntry>, 4> Sections;
 
   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() {
   SectionMap.clear();
 
   UndefinedCsects->clear();
   // Reset any sections we have written to, and empty the section header table.
   for (auto &Sec : Sections)
     Sec->reset();
 
   Sections.clear();
 
   // Reset states in XCOFFObjectWriter.
   SymbolTableEntryCount = 0;
   SymbolTableOffset = 0;
   SectionCount = 0;
   RelocationEntryOffset = 0;
   Strings.clear();
 
   MCObjectWriter::reset();
 }
 
 // Currently we support
 // ProgramCodeCsects/ReadOnlyCsects/BSSCsects/DataCsects/FuncDSCsects/TOCCsects.
auto CreateNewSectionEntry =
     return std::make_unique<CsectSectionEntry>(".bss", XCOFF::STYP_BSS,
                                                /* IsVirtual */ true);
   };
 
   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()) {
+      assert(XCOFF::XTY_ER != MCSec->getCSectType() &&
+             "An undefined csect should not get registered.");
+
       // Check if the CsectGroup is already generated before.
       bool IsGroupFound = true;
       std::unique_ptr<CsectGroup> *Group = getCsectGroup(MCSec);
       std::unique_ptr<CsectGroup> G;
       // Create the new CsectGroup.
       if (!Group) {
-      // If the Group is not found in the Sections, it needs to be added later.
+        // If the Group is not found in the Sections, it needs to be added
+        // later.
         IsGroupFound = false;
         G = std::make_unique<CsectGroup>();
         Group = &G;
       }
 
       // Add the MCSec to the Group.
       (*Group)->emplace_back(MCSec);
       SectionMap[MCSec] = &((*Group)->back());
 
       // Check if the SectionEntry is alredy generated before.
       std::unique_ptr<SectionEntry> *CsectEntry =
           getCsectSectionEntry(Group->get());
 
       bool IsSectionEntryFound = true;
       std::unique_ptr<SectionEntry> SE;
       // Create the new CsectSetionEntry.
       if (!CsectEntry) {
         SE = CreateNewSectionEntry(Group->get());
         CsectEntry = &SE;
         IsSectionEntryFound = false;
       }
       assert(!(IsGroupFound && !IsSectionEntryFound) &&
              "Group exists in non-exist Csect section entry!");
 
       // If the Group is not in the section entry, now add it.
       if (!IsGroupFound)
         (dyn_cast<CsectSectionEntry>((*CsectEntry).get()))
             ->Groups.emplace_back(std::move(*Group));
 
       // If the Seciton entry is not in the Sections of the object, now add it.
       if (!IsSectionEntryFound)
         Sections.push_back(std::move(*CsectEntry));
+    } else if (MCSec->isDwarfSect()) {
+      // A new DwarfSectionEntry.
+      std::unique_ptr<XCOFFSection> DwarfSec =
+          std::make_unique<XCOFFSection>(MCSec);
+      SectionMap[MCSec] = DwarfSec.get();
+
+      std::unique_ptr<SectionEntry> SecEntry =
+          std::make_unique<DwarfSectionEntry>(
+              MCSec->getName(), MCSec->getDwarfSubtypeFlags().getValue(),
+              std::move(DwarfSec));
+      Sections.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,
     // 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) {
+                                     const MCSectionXCOFF *ContainingSect) {
     // 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 +
+    // If Sym is a label, return csect's address + label's offset from the
+    // csect.
+    // If Sym is a DWARF section, return label's offset from the DWARF section.
+    return (ContainingSect->isDwarfSect()
+                ? 0
+                : SectionMap[ContainingSect]->Address) +
            (Sym->isDefined() ? Layout.getSymbolOffset(*Sym) : 0);
   };
 
   auto GetTOCSectionGroup = [&]() -> std::unique_ptr<CsectGroup> & {
     for (auto &Section : Sections) {
       if (Section->Flags == XCOFF::STYP_DATA) {
         for (auto &Group :
              (dyn_cast<CsectSectionEntry>(Section.get()))->Groups) {
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.get()) &&
-           "Only csect entry is supported!");
-    const auto *CsectEntry = dyn_cast<CsectSectionEntry>(Section.get());
-    // Nothing to write for this Section.
-    if (CsectEntry->Index == SectionEntry::UninitializedIndex ||
-        CsectEntry->IsVirtual)
-      continue;
-
-    // There could be a gap (without corresponding zero padding) between
-    // sections.
-    assert(CurrentAddressLocation <= CsectEntry->Address &&
-           "CurrentAddressLocation should be less than or equal to section "
-           "address.");
-
-    CurrentAddressLocation = CsectEntry->Address;
-
-    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;
-    }
+    if (const auto *CsectEntry = dyn_cast<CsectSectionEntry>(Section.get()))
+      writeSectionForControlSectionEntry(Asm, Layout, *CsectEntry,
+                                         CurrentAddressLocation);
+    else if (const auto *DwarfEntry =
+                 dyn_cast<DwarfSectionEntry>(Section.get()))
+      writeSectionForDwarfSectionEntry(Asm, Layout, *DwarfEntry,
+                                       CurrentAddressLocation);
+    else
+      llvm_unreachable("unsupport section type!");
   }
 }
 
 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.
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
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.
+    // We use 0 for DWARF sections' Physical and Virtual Addresses.
+    if (isa<DwarfSectionEntry>(Sec)) {
+      W.write<uint32_t>(0);
+      W.write<uint32_t>(0);
+    } else {
+      assert(isa<CsectSectionEntry>(Sec) && "Unsupported section type!");
       W.write<uint32_t>(Sec->Address);
       W.write<uint32_t>(Sec->Address);
+    }
 
     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);
   }
 }
 
 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;
 
-    assert(isa<CsectSectionEntry>(Section.get()) &&
-           "Only csect entry is supported!");
-    const auto *CsectEntry = dyn_cast<CsectSectionEntry>(Section.get());
-
+    if (const auto *CsectEntry = dyn_cast<CsectSectionEntry>(Section.get())) {
       for (const auto &Group : CsectEntry->Groups) {
         if (Group->empty())
           continue;
 
         for (const auto &Csect : *Group) {
           for (const auto Reloc : Csect.Relocations)
             writeRelocation(Reloc, Csect);
         }
       }
+    } else if (const auto *DwarfEntry =
+                   dyn_cast<DwarfSectionEntry>(Section.get())) {
+      for (const auto Reloc : DwarfEntry->DwarfSect->Relocations)
+        writeRelocation(Reloc, *DwarfEntry->DwarfSect);
+    } else
+      llvm_unreachable("unsupport section type!");
   }
 }
 
 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
writeSymbolTableEntryForControlSection(Csect,
                                            Csect.MCSec->getStorageClass());
   }
 
   for (const auto &Section : Sections) {
     if (Section->Index == SectionEntry::UninitializedIndex)
       // Nothing to write for this Section.
       continue;
 
-    assert(isa<CsectSectionEntry>(Section.get()) &&
-           "Only csect entry is supported!");
-    const auto *CsectEntry = dyn_cast<CsectSectionEntry>(Section.get());
-
+    if (const auto *CsectEntry = dyn_cast<CsectSectionEntry>(Section.get())) {
       for (const auto &Group : CsectEntry->Groups) {
         if (Group->empty())
           continue;
 
         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.MCSec->getStorageClass());
+          writeSymbolTableEntryForControlSection(
+              Csect, SectionIndex, Csect.MCSec->getStorageClass());
 
           for (const auto &Sym : Csect.Syms)
             writeSymbolTableEntryForCsectMemberLabel(
                 Sym, Csect, SectionIndex, Layout.getSymbolOffset(*(Sym.MCSym)));
         }
       }
+    } else if (const auto *DwarfEntry =
+                   dyn_cast<DwarfSectionEntry>(Section.get()))
+      writeSymbolTableEntryForDwarfSection(*DwarfEntry->DwarfSect,
+                                           DwarfEntry->Index);
+    else
+      llvm_unreachable("unsupport section type!");
   }
 }
 
 void XCOFFObjectWriter::finalizeSectionInfo() {
   for (auto &Section : Sections) {
     if (Section->Index == SectionEntry::UninitializedIndex)
       // Nothing to record for this Section.
       continue;
 
-    assert(isa<CsectSectionEntry>(Section.get()) &&
-           "Only csect entry is supported!");
-    auto *CsectEntry = dyn_cast<CsectSectionEntry>(Section.get());
-
+    if (auto *CsectEntry = dyn_cast<CsectSectionEntry>(Section.get())) {
       for (const auto &Group : CsectEntry->Groups) {
         if (Group->empty())
           continue;
 
-      for (auto &Csect : *Group) {
+        for (const auto &Csect : *Group) {
           const size_t CsectRelocCount = Csect.Relocations.size();
           if (CsectRelocCount >= XCOFF::RelocOverflow ||
-            Section->RelocationCount >= XCOFF::RelocOverflow - CsectRelocCount)
+              Section->RelocationCount >=
+                  XCOFF::RelocOverflow - CsectRelocCount)
             report_fatal_error(
                 "relocation entries overflowed; overflow section is "
                 "not implemented yet");
 
           CsectEntry->RelocationCount += CsectRelocCount;
         }
       }
+    } else if (auto *DwarfEntry = dyn_cast<DwarfSectionEntry>(Section.get()))
+      DwarfEntry->RelocationCount = DwarfEntry->DwarfSect->Relocations.size();
+    else
+      llvm_unreachable("unsupport section type!");
   }
 
   // Calculate the file offset to the relocation entries.
   uint64_t RawPointer = RelocationEntryOffset;
   for (auto &Sec : Sections) {
-    assert(isa<CsectSectionEntry>(Sec.get()) &&
-           "Only csect entry is supported!");
-    auto *CsectEntry = dyn_cast<CsectSectionEntry>(Sec.get());
-
-    if (CsectEntry->Index == SectionEntry::UninitializedIndex ||
-        !CsectEntry->RelocationCount)
+    if (Sec->Index == SectionEntry::UninitializedIndex || !Sec->RelocationCount)
       continue;
 
-    CsectEntry->FileOffsetToRelocations = RawPointer;
+    Sec->FileOffsetToRelocations = RawPointer;
     const uint32_t RelocationSizeInSec =
-        CsectEntry->RelocationCount * XCOFF::RelocationSerializationSize32;
+        Sec->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)
void XCOFFObjectWriter::assignAddressesAndIndices(const MCAsmLayout &Layout) {
   // The address corrresponds to the address of sections and symbols in the
   // object file. We place the shared address 0 immediately after the
   // section header table.
   uint32_t Address = 0;
   // Section indices are 1-based in XCOFF.
   int32_t SectionIndex = 1;
 
   for (auto &Section : Sections) {
-    assert(isa<CsectSectionEntry>(Section.get()) &&
-           "Only csect entry is supported!");
-    auto *CsectEntry = dyn_cast<CsectSectionEntry>(Section.get());
+    if (auto *CsectEntry = dyn_cast<CsectSectionEntry>(Section.get())) {
     const bool IsEmpty = llvm::all_of(
         CsectEntry->Groups,
         [](std::unique_ptr<CsectGroup> &Group) { return Group->empty(); });
       if (IsEmpty)
         continue;
 
       if (SectionIndex > MaxSectionIndex)
         report_fatal_error("Section index overflow!");
       CsectEntry->Index = SectionIndex++;
       SectionCount++;
 
       bool SectionAddressSet = false;
       for (auto &Group : CsectEntry->Groups) {
         if (Group->empty())
           continue;
 
         for (auto &Csect : *Group) {
           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) {
           CsectEntry->Address = Group->front().Address;
           SectionAddressSet = true;
         }
       }
 
       // Make sure the address of the next section aligned to
       // DefaultSectionAlign.
       Address = alignTo(Address, DefaultSectionAlign);
       CsectEntry->Size = Address - CsectEntry->Address;
+    } else if (auto *DwarfEntry = dyn_cast<DwarfSectionEntry>(Section.get())) {
+      if (SectionIndex > MaxSectionIndex)
+        report_fatal_error("Section index overflow!");
+      XCOFFSection &DwarfSect = *DwarfEntry->DwarfSect;
+      const MCSectionXCOFF *MCSec = DwarfSect.MCSec;
+
+      // Section index.
+      DwarfEntry->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().
+      DwarfEntry->Address = DwarfSect.Address =
+          alignTo(Address, MCSec->getAlignment());
+
+      // Section size.
+      // For DWARF section, we must use the real size which may be not aligned.
+      DwarfEntry->Size = DwarfSect.Size = Layout.getSectionAddressSize(MCSec);
+
+      // Make the Address align to default alignment for follow section.
+      Address =
+          alignTo(DwarfSect.Address + DwarfSect.Size, DefaultSectionAlign);
+    } else
+      llvm_unreachable("unsupport section type!");
   }
 
   SymbolTableEntryCount = SymbolTableIndex;
 
   // Calculate the RawPointer value for each section.
   uint64_t RawPointer = sizeof(XCOFF::FileHeader32) + auxiliaryHeaderSize() +
                         SectionCount * sizeof(XCOFF::SectionHeader32);
   for (auto &Sec : Sections) {
-    assert(isa<CsectSectionEntry>(Sec.get()) &&
-           "Only csect entry is supported!");
-    auto *CsectEntry = dyn_cast<CsectSectionEntry>(Sec.get());
-    if (CsectEntry->Index == SectionEntry::UninitializedIndex ||
-        CsectEntry->IsVirtual)
+    if (Sec->Index == SectionEntry::UninitializedIndex ||
+        (isa<CsectSectionEntry>(Sec.get()) &&
+         dyn_cast<CsectSectionEntry>(Sec.get())->IsVirtual))
       continue;
-
-    CsectEntry->FileOffsetToData = RawPointer;
-    RawPointer += CsectEntry->Size;
+    // Address of csect sections are always aligned to DefaultSectionAlign,
+    // nothing to do. But address of DWARF section are aligned to Section
+    // alignment which may be bigger than DefaultSectionAlign, need to execlude
+    // the padding bits.
+    if (const auto *DwarfEntry = dyn_cast<DwarfSectionEntry>(Sec.get()))
+      RawPointer =
+          alignTo(RawPointer, DwarfEntry->DwarfSect->MCSec->getAlignment());
+
+    Sec->FileOffsetToData = RawPointer;
+    // Some section entries, like DWARF section size is not aligned, so
+    // RawPointer may be not aligned.
+    RawPointer += Sec->Size;
+    // Make sure RawPointer is aligned.
+    RawPointer = alignTo(RawPointer, DefaultSectionAlign);
     if (RawPointer > UINT32_MAX)
       report_fatal_error("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.
+  assert(CurrentAddressLocation <= CsectEntry.Address &&
+         "CurrentAddressLocation should be less than or equal to section "
+         "address.");
+
+  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: 0x104
+; 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: 0x12C
+; SEC-NEXT:      RelocationPointer: 0x214
+; 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: 0x138
+; 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: 0x43
+; SEC-NEXT:      RawDataOffset: 0x170
+; SEC-NEXT:      RelocationPointer: 0x228
+; SEC-NEXT:      LineNumberPointer: 0x0
+; SEC-NEXT:      NumberOfRelocations: 9
+; SEC-NEXT:      NumberOfLineNumbers: 0
+; SEC-NEXT:      Type: STYP_DWARF (0x10)
+; SEC-NEXT:    }
+; SEC-NEXT:    Section {
+; SEC-NEXT:      Index: 5
+; SEC-NEXT:      Name: .dwstr
+; SEC-NEXT:      PhysicalAddress: 0x0
+; SEC-NEXT:      VirtualAddress: 0x0
+; SEC-NEXT:      Size: 0x28
+; SEC-NEXT:      RawDataOffset: 0x1B4
+; 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: 6
+; SEC-NEXT:      Name: .dwline
+; SEC-NEXT:      PhysicalAddress: 0x0
+; SEC-NEXT:      VirtualAddress: 0x0
+; SEC-NEXT:      Size: 0x36
+; SEC-NEXT:      RawDataOffset: 0x1DC
+; SEC-NEXT:      RelocationPointer: 0x282
+; 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:  0000000c R_POS                    .dwstr
+; RELO-NEXT:  00000012 R_POS                    .dwstr
+; RELO-NEXT:  00000016 R_POS                    .dwline
+; RELO-NEXT:  0000001a R_POS                    .dwstr
+; RELO-NEXT:  0000001e R_POS                    .text
+; RELO-NEXT:  00000027 R_POS                    .text
+; RELO-NEXT:  00000009 R_POS                    .dwstr
+; RELO-NEXT:  0000003c R_POS                    .dwstr
+; RELO:       RELOCATION RECORDS FOR [.dwline]:
+; RELO-NEXT:  OFFSET   TYPE                     VALUE
+; RELO-NEXT:  00000000 R_POS                    .text

llvm/test/DebugInfo/XCOFF/empty.ll

 
 ; RUN: llc -mtriple powerpc-ibm-aix-xcoff < %s | \
 ; RUN:   FileCheck %s --check-prefix=ASM32
 ; RUN: llc -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_strp
+; DWARF32-NEXT:          DW_AT_language  DW_FORM_data2
+; DWARF32-NEXT:          DW_AT_name      DW_FORM_strp
+; DWARF32-NEXT:          DW_AT_stmt_list DW_FORM_sec_offset
+; DWARF32-NEXT:          DW_AT_comp_dir  DW_FORM_strp
+; 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_strp
+; 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_strp
+; 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 = 0x0000003f, format = DWARF32, version = 0x0004, abbr_offset = 0x0000, addr_size = 0x04 (next unit at 0x00000043)
+; 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:       0x00000026:   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      (0x0000003b "int")
+; DWARF32-NEXT:                  DW_AT_external  (true)
+; DWARF32:       0x0000003b:   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:       0x00000042:   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
+; DWARF32:       .debug_str contents:
+; DWARF32-NEXT:  0x00000000: "clang version 12.0.0"
+; DWARF32-NEXT:  0x00000015: "1.c"
+; DWARF32-NEXT:  0x00000019: "debug"
+; DWARF32-NEXT:  0x0000001f: "main"
+; DWARF32-NEXT:  0x00000024: "int"
+