dwarfgen: Add support for generating the debug_str_offsets section

[labath]

Summary

The motivation for this is D49493, where we'd like to test details of
debug_str_offsets behavior which is difficult to trigger from a
traditional test.

This adds the plubming necessary for dwarfgen to generate this section.
The more interesting changes are:

• I've moved emitStringOffsetsTableHeader function from DwarfFile to DwarfStringPool, so I can generate the section header more easily from the unit test.
• added a new addAttribute overload taking an MCExpr*. This is used to generate the DW_AT_str_offsets_base, which links a compile unit to the offset table.

I've also added a basic test for reading and writing DW_form_strx forms.

[probinson]

+ @clayborg who IIRC did the original generator

[clayborg]

unittests/DebugInfo/DWARF/DwarfGenerator.h

253

Does this need to be initialized to nullptr somewhere?

[dblaikie]

lib/CodeGen/AsmPrinter/DwarfStringPool.h

41

Is a forward decl of MCSymbol required up with MCSection/AsmPrinter then?

unittests/DebugInfo/DWARF/DwarfGenerator.cpp

473–476

Why split this into two functions rather than having emit do the table header itself/internally?

[labath]

lib/CodeGen/AsmPrinter/DwarfStringPool.h

41

It wasn't necessary in my build, but it's a good idea nonetheless.

unittests/DebugInfo/DWARF/DwarfGenerator.cpp

473–476

The functions were already split, I did not split them. I looked at how things would work if this was done by a single function, but things started to get a bit messy. The thing is we don't always need to emit the header -- we only do it (in the main generator) if DwarfDebug::useSegmentedStringOffsetsTable() is true. So I would have to pass that flag into emit in addition to the StringOffsetsStartSym symbol. That wouldn't look good as the emit function already has two arguments with default values. It might be possible to clean this up, but this would need a larger refactor.

unittests/DebugInfo/DWARF/DwarfGenerator.h

253

It's initialized in Generator::init. The only way we can get a valid Generator object is if that functions succeeds, so this variable will always be initialized (and not null).

[labath]

Add MCSymbol forward decl

[JDevlieghere]

Looks good to me but I'll defer to Greg and Dave who had actual feedback.

[clayborg]

lib/CodeGen/AsmPrinter/DwarfStringPool.cpp

17

Do we even need this include? We just pass the pointer on into another call so this is probably not needed.

[labath]

lib/CodeGen/AsmPrinter/DwarfStringPool.cpp

17

Good point. I've gotten a bit over-zealous with IWYU here. I'll remove it.

[labath]

Remove the extra #include

[clayborg]

DwarfGenerator stuff looks good. I'll let someone else the final go ahead.

[dblaikie]

Looks good

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

 void DwarfDebug::emitAbbreviations() {
   DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
 
   Holder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
 }
 
 void DwarfDebug::emitStringOffsetsTableHeader() {
   DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
-  Holder.emitStringOffsetsTableHeader(
-      Asm->getObjFileLowering().getDwarfStrOffSection());
+  Holder.getStringPool().emitStringOffsetsTableHeader(
+      *Asm, Asm->getObjFileLowering().getDwarfStrOffSection(),
+      Holder.getStringOffsetsStartSym());
 }
 
 template <typename AccelTableT>
 void DwarfDebug::emitAccel(AccelTableT &Accel, MCSection *Section,
                            StringRef TableName) {
   Asm->OutStreamer->SwitchSection(Section);
 
   // Emit the full data.
void DwarfDebug::emitDebugLineDWO() {
   assert(useSplitDwarf() && "No split dwarf?");
   SplitTypeUnitFileTable.Emit(
       *Asm->OutStreamer, MCDwarfLineTableParams(),
       Asm->getObjFileLowering().getDwarfLineDWOSection());
 }
 
 void DwarfDebug::emitStringOffsetsTableHeaderDWO() {
   assert(useSplitDwarf() && "No split dwarf?");
-  InfoHolder.emitStringOffsetsTableHeader(
-      Asm->getObjFileLowering().getDwarfStrOffDWOSection());
+  InfoHolder.getStringPool().emitStringOffsetsTableHeader(
+      *Asm, Asm->getObjFileLowering().getDwarfStrOffDWOSection(),
+      InfoHolder.getStringOffsetsStartSym());
 }
 
 // Emit the .debug_str.dwo section for separated dwarf. This contains the
 // string section and is identical in format to traditional .debug_str
 // sections.
 void DwarfDebug::emitDebugStrDWO() {
   if (useSegmentedStringOffsetsTable())
     emitStringOffsetsTableHeaderDWO();

lib/CodeGen/AsmPrinter/DwarfFile.h

public:
 
   /// Compute the size and offset of all the DIEs in the given unit.
   /// \returns The size of the root DIE.
   unsigned computeSizeAndOffsetsForUnit(DwarfUnit *TheU);
 
   /// Add a unit to the list of CUs.
   void addUnit(std::unique_ptr<DwarfCompileUnit> U);
 
-  /// Emit the string table offsets header.
-  void emitStringOffsetsTableHeader(MCSection *Section);
-
   /// Emit all of the units to the section listed with the given
   /// abbreviation section.
   void emitUnits(bool UseOffsets);
 
   /// Emit the given unit to its section.
   void emitUnit(DwarfUnit *U, bool UseOffsets);
 
   /// Emit a set of abbreviations to the specific section.

lib/CodeGen/AsmPrinter/DwarfFile.cpp

 
 DwarfFile::DwarfFile(AsmPrinter *AP, StringRef Pref, BumpPtrAllocator &DA)
     : Asm(AP), Abbrevs(AbbrevAllocator), StrPool(DA, *Asm, Pref) {}
 
 void DwarfFile::addUnit(std::unique_ptr<DwarfCompileUnit> U) {
   CUs.push_back(std::move(U));
 }
 
-void DwarfFile::emitStringOffsetsTableHeader(MCSection *Section) {
-  if (StrPool.empty())
-    return;
-  Asm->OutStreamer->SwitchSection(Section);
-  unsigned EntrySize = 4;
-  // FIXME: DWARF64
-  // We are emitting the header for a contribution to the string offsets
-  // table. The header consists of an entry with the contribution's
-  // size (not including the size of the length field), the DWARF version and
-  // 2 bytes of padding.
-  Asm->emitInt32(StrPool.size() * EntrySize + 4);
-  Asm->emitInt16(Asm->getDwarfVersion());
-  Asm->emitInt16(0);
-  // Define the symbol that marks the start of the contribution. It is
-  // referenced by most unit headers via DW_AT_str_offsets_base.
-  // Split units do not use the attribute.
-  if (StringOffsetsStartSym)
-    Asm->OutStreamer->EmitLabel(StringOffsetsStartSym);
-}
-
 // Emit the various dwarf units to the unit section USection with
 // the abbreviations going into ASection.
 void DwarfFile::emitUnits(bool UseOffsets) {
   for (const auto &TheU : CUs)
     emitUnit(TheU.get(), UseOffsets);
 }
 
 void DwarfFile::emitUnit(DwarfUnit *TheU, bool UseOffsets) {

lib/CodeGen/AsmPrinter/DwarfStringPool.h

 #include "llvm/ADT/StringRef.h"
 #include "llvm/CodeGen/DwarfStringPoolEntry.h"
 #include "llvm/Support/Allocator.h"
 
 namespace llvm {
 
 class AsmPrinter;
 class MCSection;
+class MCSymbol;
 
 // Collection of strings for this unit and assorted symbols.
 // A String->Symbol mapping of strings used by indirect
 // references.
 class DwarfStringPool {
   using EntryTy = DwarfStringPoolEntry;
 
   StringMap<EntryTy, BumpPtrAllocator &> Pool;
   StringRef Prefix;
   unsigned NumBytes = 0;
   bool ShouldCreateSymbols;
 
 public:
   using EntryRef = DwarfStringPoolEntryRef;
 
   DwarfStringPool(BumpPtrAllocator &A, AsmPrinter &Asm, StringRef Prefix);
 
+  void emitStringOffsetsTableHeader(AsmPrinter &Asm, MCSection *OffsetSection,
+                                    MCSymbol *StartSym);
+
   void emit(AsmPrinter &Asm, MCSection *StrSection,
             MCSection *OffsetSection = nullptr,
             bool UseRelativeOffsets = false);
 
   bool empty() const { return Pool.empty(); }
 
   unsigned size() const { return Pool.size(); }
 
   /// Get a reference to an entry in the string pool.
   EntryRef getEntry(AsmPrinter &Asm, StringRef Str);
 };
 
 } // end namespace llvm
 
 #endif // LLVM_LIB_CODEGEN_ASMPRINTER_DWARFSTRINGPOOL_H

lib/CodeGen/AsmPrinter/DwarfStringPool.cpp

 //===- llvm/CodeGen/DwarfStringPool.cpp - Dwarf Debug Framework -----------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "DwarfStringPool.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/CodeGen/AsmPrinter.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCStreamer.h"
 #include <cassert>
 #include <utility>
 
 using namespace llvm;
 
 DwarfStringPool::DwarfStringPool(BumpPtrAllocator &A, AsmPrinter &Asm,
                                  StringRef Prefix)
     : Pool(A), Prefix(Prefix),
       ShouldCreateSymbols(Asm.MAI->doesDwarfUseRelocationsAcrossSections()) {}
 
 DwarfStringPool::EntryRef DwarfStringPool::getEntry(AsmPrinter &Asm,
                                                     StringRef Str) {
   auto I = Pool.insert(std::make_pair(Str, EntryTy()));
   if (I.second) {
     auto &Entry = I.first->second;
     Entry.Index = Pool.size() - 1;
     Entry.Offset = NumBytes;
     Entry.Symbol = ShouldCreateSymbols ? Asm.createTempSymbol(Prefix) : nullptr;
 
     NumBytes += Str.size() + 1;
     assert(NumBytes > Entry.Offset && "Unexpected overflow");
   }
   return EntryRef(*I.first);
 }
 
+void DwarfStringPool::emitStringOffsetsTableHeader(AsmPrinter &Asm,
+                                                   MCSection *Section,
+                                                   MCSymbol *StartSym) {
+  if (empty())
+    return;
+  Asm.OutStreamer->SwitchSection(Section);
+  unsigned EntrySize = 4;
+  // FIXME: DWARF64
+  // We are emitting the header for a contribution to the string offsets
+  // table. The header consists of an entry with the contribution's
+  // size (not including the size of the length field), the DWARF version and
+  // 2 bytes of padding.
+  Asm.emitInt32(size() * EntrySize + 4);
+  Asm.emitInt16(Asm.getDwarfVersion());
+  Asm.emitInt16(0);
+  // Define the symbol that marks the start of the contribution. It is
+  // referenced by most unit headers via DW_AT_str_offsets_base.
+  // Split units do not use the attribute.
+  if (StartSym)
+    Asm.OutStreamer->EmitLabel(StartSym);
+}
+
 void DwarfStringPool::emit(AsmPrinter &Asm, MCSection *StrSection,
                            MCSection *OffsetSection, bool UseRelativeOffsets) {
   if (Pool.empty())
     return;
 
   // Start the dwarf str section.
   Asm.OutStreamer->SwitchSection(StrSection);
 

unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp

void TestAllForms() {
   const int64_t ICSData = INT64_MAX; // DW_FORM_implicit_const SData
   const uint64_t UData[] = {UINT64_MAX - 1, UINT64_MAX - 2, UINT64_MAX - 3,
                             UINT64_MAX - 4, UINT64_MAX - 5, UINT64_MAX - 6,
                             UINT64_MAX - 7, UINT64_MAX - 8, UINT64_MAX - 9};
 #define UDATA_1 18446744073709551614ULL
   const uint32_t Dwarf32Values[] = {1, 2, 3, 4, 5, 6, 7, 8};
   const char *StringValue = "Hello";
   const char *StrpValue = "World";
+  const char *StrxValue = "Indexed";
+  const char *Strx1Value = "Indexed1";
+  const char *Strx2Value = "Indexed2";
+  const char *Strx3Value = "Indexed3";
+  const char *Strx4Value = "Indexed4";
 
   auto ExpectedDG = dwarfgen::Generator::create(Triple, Version);
   ASSERT_THAT_EXPECTED(ExpectedDG, Succeeded());
   dwarfgen::Generator *DG = ExpectedDG.get().get();
   dwarfgen::CompileUnit &CU = DG->addCompileUnit();
   dwarfgen::DIE CUDie = CU.getUnitDIE();
+
+  if (Version >= 5)
+    CUDie.addAttribute(dwarf::DW_AT_str_offsets_base, dwarf::DW_FORM_sec_offset,
+                       MCSymbolRefExpr::create(DG->getStringOffsetsStartSym(),
+                                               *DG->getMCContext()));
+
   uint16_t Attr = DW_AT_lo_user;
 
   //----------------------------------------------------------------------
   // Test address forms
   //----------------------------------------------------------------------
   const auto Attr_DW_FORM_addr = static_cast<dwarf::Attribute>(Attr++);
   CUDie.addAttribute(Attr_DW_FORM_addr, DW_FORM_addr, AddrValue);
 
#define UDATA_1 18446744073709551614ULL
   CUDie.addAttribute(Attr_DW_FORM_data8, DW_FORM_data8, Data8);
 
   //----------------------------------------------------------------------
   // Test string forms
   //----------------------------------------------------------------------
   const auto Attr_DW_FORM_string = static_cast<dwarf::Attribute>(Attr++);
   CUDie.addAttribute(Attr_DW_FORM_string, DW_FORM_string, StringValue);
 
+  const auto Attr_DW_FORM_strx = static_cast<dwarf::Attribute>(Attr++);
+  const auto Attr_DW_FORM_strx1 = static_cast<dwarf::Attribute>(Attr++);
+  const auto Attr_DW_FORM_strx2 = static_cast<dwarf::Attribute>(Attr++);
+  const auto Attr_DW_FORM_strx3 = static_cast<dwarf::Attribute>(Attr++);
+  const auto Attr_DW_FORM_strx4 = static_cast<dwarf::Attribute>(Attr++);
+  if (Version >= 5) {
+    CUDie.addAttribute(Attr_DW_FORM_strx, DW_FORM_strx, StrxValue);
+    CUDie.addAttribute(Attr_DW_FORM_strx1, DW_FORM_strx1, Strx1Value);
+    CUDie.addAttribute(Attr_DW_FORM_strx2, DW_FORM_strx2, Strx2Value);
+    CUDie.addAttribute(Attr_DW_FORM_strx3, DW_FORM_strx3, Strx3Value);
+    CUDie.addAttribute(Attr_DW_FORM_strx4, DW_FORM_strx4, Strx4Value);
+  }
+
   const auto Attr_DW_FORM_strp = static_cast<dwarf::Attribute>(Attr++);
   CUDie.addAttribute(Attr_DW_FORM_strp, DW_FORM_strp, StrpValue);
 
   //----------------------------------------------------------------------
   // Test reference forms
   //----------------------------------------------------------------------
   const auto Attr_DW_FORM_ref_addr = static_cast<dwarf::Attribute>(Attr++);
   CUDie.addAttribute(Attr_DW_FORM_ref_addr, DW_FORM_ref_addr, RefAddr);
#define UDATA_1 18446744073709551614ULL
   EXPECT_EQ(Data4, toUnsigned(DieDG.find(Attr_DW_FORM_data4), 0));
   EXPECT_EQ(Data8, toUnsigned(DieDG.find(Attr_DW_FORM_data8), 0));
 
   //----------------------------------------------------------------------
   // Test string forms
   //----------------------------------------------------------------------
   auto ExtractedStringValue = toString(DieDG.find(Attr_DW_FORM_string));
   EXPECT_TRUE((bool)ExtractedStringValue);
-  EXPECT_TRUE(strcmp(StringValue, *ExtractedStringValue) == 0);
+  EXPECT_STREQ(StringValue, *ExtractedStringValue);
+
+  if (Version >= 5) {
+    auto ExtractedStrxValue = toString(DieDG.find(Attr_DW_FORM_strx));
+    EXPECT_TRUE((bool)ExtractedStrxValue);
+    EXPECT_STREQ(StrxValue, *ExtractedStrxValue);
+
+    auto ExtractedStrx1Value = toString(DieDG.find(Attr_DW_FORM_strx1));
+    EXPECT_TRUE((bool)ExtractedStrx1Value);
+    EXPECT_STREQ(Strx1Value, *ExtractedStrx1Value);
+
+    auto ExtractedStrx2Value = toString(DieDG.find(Attr_DW_FORM_strx2));
+    EXPECT_TRUE((bool)ExtractedStrx2Value);
+    EXPECT_STREQ(Strx2Value, *ExtractedStrx2Value);
+
+    auto ExtractedStrx3Value = toString(DieDG.find(Attr_DW_FORM_strx3));
+    EXPECT_TRUE((bool)ExtractedStrx3Value);
+    EXPECT_STREQ(Strx3Value, *ExtractedStrx3Value);
+
+    auto ExtractedStrx4Value = toString(DieDG.find(Attr_DW_FORM_strx4));
+    EXPECT_TRUE((bool)ExtractedStrx4Value);
+    EXPECT_STREQ(Strx4Value, *ExtractedStrx4Value);
+  }
 
   auto ExtractedStrpValue = toString(DieDG.find(Attr_DW_FORM_strp));
   EXPECT_TRUE((bool)ExtractedStrpValue);
-  EXPECT_TRUE(strcmp(StrpValue, *ExtractedStrpValue) == 0);
+  EXPECT_STREQ(StrpValue, *ExtractedStrpValue);
 
   //----------------------------------------------------------------------
   // Test reference forms
   //----------------------------------------------------------------------
   EXPECT_EQ(RefAddr, toReference(DieDG.find(Attr_DW_FORM_ref_addr), 0));
   EXPECT_EQ(Data1, toReference(DieDG.find(Attr_DW_FORM_ref1), 0));
   EXPECT_EQ(Data2, toReference(DieDG.find(Attr_DW_FORM_ref2), 0));
   EXPECT_EQ(Data4, toReference(DieDG.find(Attr_DW_FORM_ref4), 0));

unittests/DebugInfo/DWARF/DwarfGenerator.h

public:
   /// Add an attribute value to be encoded as a DIEInteger
   ///
   /// \param Attr a dwarf::Attribute enumeration value or any uint16_t that
   /// represents a user defined DWARF attribute.
   /// \param Form the dwarf::Form to use when encoding the attribute.
   /// \param U the unsigned integer to encode.
   void addAttribute(uint16_t Attr, dwarf::Form Form, uint64_t U);
 
+  /// Add an attribute value to be encoded as a DIEExpr
+  ///
+  /// \param Attr a dwarf::Attribute enumeration value or any uint16_t that
+  /// represents a user defined DWARF attribute.
+  /// \param Form the dwarf::Form to use when encoding the attribute.
+  /// \param Expr the MC expression used to compute the value
+  void addAttribute(uint16_t Attr, dwarf::Form Form, const MCExpr *Expr);
+
   /// Add an attribute value to be encoded as a DIEString or DIEInlinedString.
   ///
   /// \param Attr a dwarf::Attribute enumeration value or any uint16_t that
   /// represents a user defined DWARF attribute.
   /// \param Form the dwarf::Form to use when encoding the attribute. The form
   /// must be one of DW_FORM_strp or DW_FORM_string.
   /// \param String the string to encode.
   void addAttribute(uint16_t Attr, dwarf::Form Form, StringRef String);
class Generator {
   std::unique_ptr<TargetMachine> TM;
   std::unique_ptr<AsmPrinter> Asm;
   BumpPtrAllocator Allocator;
   std::unique_ptr<DwarfStringPool> StringPool; // Entries owned by Allocator.
   std::vector<std::unique_ptr<CompileUnit>> CompileUnits;
   std::vector<std::unique_ptr<LineTable>> LineTables;
   DIEAbbrevSet Abbreviations;
 
+  MCSymbol *StringOffsetsStartSym;
+
   SmallString<4096> FileBytes;
   /// The stream we use to generate the DWARF into as an ELF file.
   std::unique_ptr<raw_svector_ostream> Stream;
   /// The DWARF version to generate.
   uint16_t Version;
 
   /// Private constructor, call Generator::Create(...) to get a DWARF generator
   /// expected.
public:
   LineTable &
   addLineTable(dwarf::DwarfFormat DwarfFormat = dwarf::DwarfFormat::DWARF32);
 
   BumpPtrAllocator &getAllocator() { return Allocator; }
   AsmPrinter *getAsmPrinter() const { return Asm.get(); }
   MCContext *getMCContext() const { return MC.get(); }
   DIEAbbrevSet &getAbbrevSet() { return Abbreviations; }
   DwarfStringPool &getStringPool() { return *StringPool; }
+  MCSymbol *getStringOffsetsStartSym() const { return StringOffsetsStartSym; }
 
   /// Save the generated DWARF file to disk.
   ///
   /// \param Path the path to save the ELF file to.
   bool saveFile(StringRef Path);
 };
 
 } // end namespace dwarfgen
 
 } // end namespace llvm
 
 #endif // LLVM_UNITTESTS_DEBUG_INFO_DWARF_DWARFGENERATOR_H

unittests/DebugInfo/DWARF/DwarfGenerator.cpp

 
 void dwarfgen::DIE::addAttribute(uint16_t A, dwarf::Form Form, uint64_t U) {
   auto &DG = CU->getGenerator();
   Die->addValue(DG.getAllocator(), static_cast<dwarf::Attribute>(A), Form,
                 DIEInteger(U));
 }
 
 void dwarfgen::DIE::addAttribute(uint16_t A, dwarf::Form Form,
+                                 const MCExpr *Expr) {
+  auto &DG = CU->getGenerator();
+  Die->addValue(DG.getAllocator(), static_cast<dwarf::Attribute>(A), Form,
+                DIEExpr(Expr));
+}
+
+void dwarfgen::DIE::addAttribute(uint16_t A, dwarf::Form Form,
                                  StringRef String) {
   auto &DG = CU->getGenerator();
-  if (Form == DW_FORM_string) {
+  switch (Form) {
+  case DW_FORM_string:
     Die->addValue(DG.getAllocator(), static_cast<dwarf::Attribute>(A), Form,
                   new (DG.getAllocator())
                       DIEInlineString(String, DG.getAllocator()));
-  } else {
+    break;
+
+  case DW_FORM_strp:
+  case DW_FORM_GNU_str_index:
+  case DW_FORM_strx:
+  case DW_FORM_strx1:
+  case DW_FORM_strx2:
+  case DW_FORM_strx3:
+  case DW_FORM_strx4:
     Die->addValue(
         DG.getAllocator(), static_cast<dwarf::Attribute>(A), Form,
         DIEString(DG.getStringPool().getEntry(*DG.getAsmPrinter(), String)));
+    break;
+
+  default:
+    llvm_unreachable("Unhandled form!");
   }
 }
 
 void dwarfgen::DIE::addAttribute(uint16_t A, dwarf::Form Form,
                                  dwarfgen::DIE &RefDie) {
   auto &DG = CU->getGenerator();
   Die->addValue(DG.getAllocator(), static_cast<dwarf::Attribute>(A), Form,
                 DIEEntry(*RefDie.Die));
if (!Asm)
     return make_error<StringError>("no asm printer for target " + TripleName,
                                    inconvertibleErrorCode());
 
   // Set the DWARF version correctly on all classes that we use.
   MC->setDwarfVersion(Version);
   Asm->setDwarfVersion(Version);
 
   StringPool = llvm::make_unique<DwarfStringPool>(Allocator, *Asm, StringRef());
+  StringOffsetsStartSym = Asm->createTempSymbol("str_offsets_base");
 
   return Error::success();
 }
 
 StringRef dwarfgen::Generator::generate() {
   // Offset from the first CU in the debug info section is 0 initially.
   unsigned SecOffset = 0;
 
   // Iterate over each compile unit and set the size and offsets for each
   // DIE within each compile unit. All offsets are CU relative.
   for (auto &CU : CompileUnits) {
     // Set the absolute .debug_info offset for this compile unit.
     CU->setOffset(SecOffset);
     // The DIEs contain compile unit relative offsets.
     unsigned CUOffset = 11;
     CUOffset = CU->getUnitDIE().computeSizeAndOffsets(CUOffset);
     // Update our absolute .debug_info offset.
     SecOffset += CUOffset;
     CU->setLength(CUOffset - 4);
   }
   Abbreviations.Emit(Asm.get(), MOFI->getDwarfAbbrevSection());
-  StringPool->emit(*Asm, MOFI->getDwarfStrSection());
+
+  StringPool->emitStringOffsetsTableHeader(*Asm, MOFI->getDwarfStrOffSection(),
+                                           StringOffsetsStartSym);
+  StringPool->emit(*Asm, MOFI->getDwarfStrSection(),
+                   MOFI->getDwarfStrOffSection());
+
   MS->SwitchSection(MOFI->getDwarfInfoSection());
   for (auto &CU : CompileUnits) {
     uint16_t Version = CU->getVersion();
     auto Length = CU->getLength();
     MC->setDwarfVersion(Version);
     assert(Length != -1U);
     Asm->emitInt32(Length);
     Asm->emitInt16(Version);