[DWARFv5] Emit .debug_line_str (in a non-DWO file)

[probinson]

Summary

This should enable the linker to do string-pooling of path names.

[aprantl]

Looks reasonable.

llvm/lib/MC/MCDwarf.cpp

313

Sounds like a std::vector<uint_8t> or something would also be sufficient (but I'm not sure if that's any more efficient).

[probinson]

llvm/lib/MC/MCDwarf.cpp

313

This sequence is cargo-culting StringTableBuilder::write(raw_ostream&). I don't think a std::vector would be any more efficient, and EmitBinaryData wants a StringRef anyway which I'd have to construct manually.

[dblaikie]

llvm/lib/MC/MCDwarf.cpp

78

Any op bool should be marked explicit - otherwise there's all manner of implicit conversions that can get weird.

473

I'm not quite sure - is there a reason that emitV5FileDirTables handle the whole MCDwarfLineStr functionality internally without having to pass in an MCDwarfLineStr object? (emitV5FileDirTables could create the MCDwarfLineStr locally, potentially & emit it immediately?)?

llvm/test/MC/ELF/debug-md5.s

18–23

Any way to test that the line table is actually using the indexes into the debug_line_str section?

[probinson]

llvm/lib/MC/MCDwarf.cpp

78

Got it.
Would you rather have it be a normal predicate method? I went with operator bool mainly for compactness.

473

When there are multiple CUs (e.g. LTO) we want the MCDwarfLineStr instance to span emitting all of them. Otherwise we can get multiple instances of the same path in the same .debug_line_str section, in a single .o file.
I could have put MCDwarfLineStr in the MCContext, but this way we have better data hiding.
Also we need a parameter of some kind anyway, to distinguish the DWO and non-DWO cases.

llvm/test/MC/ELF/debug-md5.s

18–23

Maybe, when printing the directory/file names we could print the section+index when they're indirect. I'll look into that.

[probinson]

llvm/test/MC/ELF/debug-md5.s

18–23

So, this would be a missing feature in llvm-dwarfdump, which doesn't provide a way to dump the section/index pointed to by an indirect reference in the line table (like it does in .debug_info). In fact by the time we're dumping the line table header, the relevant information is long gone.
That should be its own patch. Follow-up, or put this on hold to wait for it?

[dblaikie]

llvm/lib/MC/MCDwarf.cpp

78

Nah - op bool is OK, if it's expliict - and it'll still be usable implicitly in bool contexts like "if (x)".

Though, alternatively, I wonder if it'd be better to not give this object the extra state - and pass through a null pointer instead of a 'false' MCDwarfLineStr object? It looks like it's only constructed in one place & so the check for DWARF version could go there rather than inside this class & the other caller could pass null?

473

Ah, right, the line table's one of the things that's not shared between CUs (unlike the abbrev table and string pool, etc - and the line string pool).

llvm/test/MC/ELF/debug-md5.s

18–23

(replied to this on-list too, but: Whichever order you like)

[probinson]

Address review comments:
Pass the MCDwarfLineStr around by pointer, eliminating the operator-bool;
use new dwarfdump feature in the test to show the section for the string references;
put more responsibility on the (only) user of the class.

That last bit is not really my preference, but as this new class is basically an implementation detail within MCDwarf.cpp I think it should be okay.

[dblaikie]

llvm/lib/MC/MCDwarf.cpp

245–246

Maybe using an Optional<MCDwarfLineStr> (you've got the bool and the MCDwarfLineStr there already, this would just wrap it up together & avoid the construction of an MCDwarfLineStr when it's not used)

llvm/include/llvm/MC/MCDwarf.h

 #include <utility>
 #include <vector>
 
 namespace llvm {
 
 template <typename T> class ArrayRef;
 class MCAsmBackend;
 class MCContext;
+class MCDwarfLineStr;
 class MCObjectStreamer;
 class MCStreamer;
 class MCSymbol;
 class raw_ostream;
 class SMLoc;
 class SourceMgr;
 
 /// \brief Instances of this class represent the name of the dwarf
struct MCDwarfLineTableHeader {
   StringRef CompilationDir;
   bool HasMD5 = false;
 
   MCDwarfLineTableHeader() = default;
 
   unsigned getFile(StringRef &Directory, StringRef &FileName,
                    MD5::MD5Result *Checksum, unsigned FileNumber = 0);
   std::pair<MCSymbol *, MCSymbol *> Emit(MCStreamer *MCOS,
-                                         MCDwarfLineTableParams Params) const;
-  std::pair<MCSymbol *, MCSymbol *>
-  Emit(MCStreamer *MCOS, MCDwarfLineTableParams Params,
-       ArrayRef<char> SpecialOpcodeLengths) const;
+                                         MCDwarfLineTableParams Params,
+                                         MCDwarfLineStr *LineStr) const;
+  std::pair<MCSymbol *, MCSymbol *> Emit(MCStreamer *MCOS,
+                                         MCDwarfLineTableParams Params,
+                                         ArrayRef<char> SpecialOpcodeLengths,
+                                         MCDwarfLineStr *LineStr) const;
 
 private:
   void emitV2FileDirTables(MCStreamer *MCOS) const;
-  void emitV5FileDirTables(MCStreamer *MCOS) const;
+  void emitV5FileDirTables(MCStreamer *MCOS, MCDwarfLineStr *LineStr) const;
 };
 
 class MCDwarfDwoLineTable {
   MCDwarfLineTableHeader Header;
 
 public:
   void setCompilationDir(StringRef CompilationDir) {
     Header.CompilationDir = CompilationDir;
class MCDwarfLineTable {
   MCDwarfLineTableHeader Header;
   MCLineSection MCLineSections;
 
 public:
   // This emits the Dwarf file and the line tables for all Compile Units.
   static void Emit(MCObjectStreamer *MCOS, MCDwarfLineTableParams Params);
 
   // This emits the Dwarf file and the line tables for a given Compile Unit.
-  void EmitCU(MCObjectStreamer *MCOS, MCDwarfLineTableParams Params) const;
+  void EmitCU(MCObjectStreamer *MCOS, MCDwarfLineTableParams Params,
+              MCDwarfLineStr *LineStr) const;
 
   unsigned getFile(StringRef &Directory, StringRef &FileName,
                    MD5::MD5Result *Checksum, unsigned FileNumber = 0);
 
   MCSymbol *getLabel() const {
     return Header.Label;
   }
 

llvm/include/llvm/MC/MCObjectFileInfo.h

protected:
   /// to emit them into.
   MCSection *CompactUnwindSection;
 
   // Dwarf sections for debug info.  If a target supports debug info, these must
   // be set.
   MCSection *DwarfAbbrevSection;
   MCSection *DwarfInfoSection;
   MCSection *DwarfLineSection;
+  MCSection *DwarfLineStrSection;
   MCSection *DwarfFrameSection;
   MCSection *DwarfPubTypesSection;
   const MCSection *DwarfDebugInlineSection;
   MCSection *DwarfStrSection;
   MCSection *DwarfLocSection;
   MCSection *DwarfARangesSection;
   MCSection *DwarfRangesSection;
   MCSection *DwarfMacinfoSection;
public:
   MCSection *getDataSection() const { return DataSection; }
   MCSection *getBSSSection() const { return BSSSection; }
   MCSection *getReadOnlySection() const { return ReadOnlySection; }
   MCSection *getLSDASection() const { return LSDASection; }
   MCSection *getCompactUnwindSection() const { return CompactUnwindSection; }
   MCSection *getDwarfAbbrevSection() const { return DwarfAbbrevSection; }
   MCSection *getDwarfInfoSection() const { return DwarfInfoSection; }
   MCSection *getDwarfLineSection() const { return DwarfLineSection; }
+  MCSection *getDwarfLineStrSection() const { return DwarfLineStrSection; }
   MCSection *getDwarfFrameSection() const { return DwarfFrameSection; }
   MCSection *getDwarfPubNamesSection() const { return DwarfPubNamesSection; }
   MCSection *getDwarfPubTypesSection() const { return DwarfPubTypesSection; }
   MCSection *getDwarfGnuPubNamesSection() const {
     return DwarfGnuPubNamesSection;
   }
   MCSection *getDwarfGnuPubTypesSection() const {
     return DwarfGnuPubTypesSection;

llvm/include/llvm/MC/StringTableBuilder.h

 
 namespace llvm {
 
 class raw_ostream;
 
 /// \brief Utility for building string tables with deduplicated suffixes.
 class StringTableBuilder {
 public:
-  enum Kind { ELF, WinCOFF, MachO, RAW };
+  enum Kind { ELF, WinCOFF, MachO, RAW, DWARF };
 
 private:
   DenseMap<CachedHashStringRef, size_t> StringIndexMap;
   size_t Size = 0;
   Kind K;
   unsigned Alignment;
   bool Finalized = false;
 

llvm/lib/MC/MCDwarf.cpp

 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCObjectFileInfo.h"
 #include "llvm/MC/MCObjectStreamer.h"
 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCSection.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSymbol.h"
+#include "llvm/MC/StringTableBuilder.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/EndianStream.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cassert>
 #include <cstdint>
 #include <string>
 #include <utility>
 #include <vector>
 
 using namespace llvm;
 
+/// Manage the .debug_line_str section contents, if we use it.
+class llvm::MCDwarfLineStr {
+  MCSymbol *LineStrLabel = nullptr;
+  StringTableBuilder LineStrings{StringTableBuilder::DWARF};
+  bool UseRelocs = false;
+
+public:
+  /// Construct an instance that can emit .debug_line_str (for use in a normal
+  /// v5 line table).
+  explicit MCDwarfLineStr(MCContext &Ctx) {
+    UseRelocs = Ctx.getAsmInfo()->doesDwarfUseRelocationsAcrossSections();
+    if (UseRelocs)
+      LineStrLabel =
+          Ctx.getObjectFileInfo()->getDwarfLineStrSection()->getBeginSymbol();
+  }
+
+  /// Emit a reference to the string.
+  void emitRef(MCStreamer *MCOS, StringRef Path);
+
+  /// Emit the .debug_line_str section if appropriate.
+  void emitSection(MCStreamer *MCOS);
+};
+
 static inline uint64_t ScaleAddrDelta(MCContext &Context, uint64_t AddrDelta) {
   unsigned MinInsnLength = Context.getAsmInfo()->getMinInstAlignment();
   if (MinInsnLength == 1)
     return AddrDelta;
   if (AddrDelta % MinInsnLength != 0) {
     // TODO: report this error, but really only once.
     ;
   }
   return AddrDelta / MinInsnLength;
 }
 
 //
 // This is called when an instruction is assembled into the specified section
 // and if there is information from the last .loc directive that has yet to have
 // a line entry made for it is made.
static inline const MCExpr *MakeStartMinusEndExpr(const MCStreamer &MCOS,
   const MCExpr *Res2 =
     MCConstantExpr::create(IntVal, MCOS.getContext());
   const MCExpr *Res3 =
     MCBinaryExpr::create(MCBinaryExpr::Sub, Res1, Res2, MCOS.getContext());
   return Res3;
 }
 
 //
+// This helper routine returns an expression of Start + IntVal .
+//
+static inline const MCExpr *
+makeStartPlusIntExpr(MCContext &Ctx, const MCSymbol &Start, int IntVal) {
+  MCSymbolRefExpr::VariantKind Variant = MCSymbolRefExpr::VK_None;
+  const MCExpr *LHS = MCSymbolRefExpr::create(&Start, Variant, Ctx);
+  const MCExpr *RHS = MCConstantExpr::create(IntVal, Ctx);
+  const MCExpr *Res = MCBinaryExpr::create(MCBinaryExpr::Add, LHS, RHS, Ctx);
+  return Res;
+}
+
+//
 // This emits the Dwarf line table for the specified section from the entries
 // in the LineSection.
 //
 static inline void
 EmitDwarfLineTable(MCObjectStreamer *MCOS, MCSection *Section,
                    const MCLineSection::MCDwarfLineEntryCollection &LineEntries) {
   unsigned FileNum = 1;
   unsigned LastLine = 1;
void MCDwarfLineTable::Emit(MCObjectStreamer *MCOS,
 
   auto &LineTables = context.getMCDwarfLineTables();
 
   // Bail out early so we don't switch to the debug_line section needlessly and
   // in doing so create an unnecessary (if empty) section.
   if (LineTables.empty())
     return;
 
+  // In a v5 non-split line table, put the strings in a separate section.
+  bool UseLineStr = context.getDwarfVersion() >= 5;
+  MCDwarfLineStr LineStr(context);
+
   // Switch to the section where the table will be emitted into.
   MCOS->SwitchSection(context.getObjectFileInfo()->getDwarfLineSection());
 
   // Handle the rest of the Compile Units.
   for (const auto &CUIDTablePair : LineTables)
-    CUIDTablePair.second.EmitCU(MCOS, Params);
+    CUIDTablePair.second.EmitCU(MCOS, Params, UseLineStr ? &LineStr : nullptr);
+
+  if (UseLineStr)
+    LineStr.emitSection(MCOS);
 }
 
 void MCDwarfDwoLineTable::Emit(MCStreamer &MCOS,
                                MCDwarfLineTableParams Params) const {
-  MCOS.EmitLabel(Header.Emit(&MCOS, Params, None).second);
+  MCOS.EmitLabel(Header.Emit(&MCOS, Params, None, nullptr).second);
 }
 
 std::pair<MCSymbol *, MCSymbol *>
-MCDwarfLineTableHeader::Emit(MCStreamer *MCOS,
-                             MCDwarfLineTableParams Params) const {
+MCDwarfLineTableHeader::Emit(MCStreamer *MCOS, MCDwarfLineTableParams Params,
+                             MCDwarfLineStr *LineStr) const {
   static const char StandardOpcodeLengths[] = {
       0, // length of DW_LNS_copy
       1, // length of DW_LNS_advance_pc
       1, // length of DW_LNS_advance_line
       1, // length of DW_LNS_set_file
       1, // length of DW_LNS_set_column
       0, // length of DW_LNS_negate_stmt
       0, // length of DW_LNS_set_basic_block
       0, // length of DW_LNS_const_add_pc
       1, // length of DW_LNS_fixed_advance_pc
       0, // length of DW_LNS_set_prologue_end
       0, // length of DW_LNS_set_epilogue_begin
       1  // DW_LNS_set_isa
   };
   assert(array_lengthof(StandardOpcodeLengths) >=
          (Params.DWARF2LineOpcodeBase - 1U));
-  return Emit(MCOS, Params, makeArrayRef(StandardOpcodeLengths,
-                                         Params.DWARF2LineOpcodeBase - 1));
+  return Emit(
+      MCOS, Params,
+      makeArrayRef(StandardOpcodeLengths, Params.DWARF2LineOpcodeBase - 1),
+      LineStr);
 }
 
 static const MCExpr *forceExpAbs(MCStreamer &OS, const MCExpr* Expr) {
   MCContext &Context = OS.getContext();
   assert(!isa<MCSymbolRefExpr>(Expr));
   if (Context.getAsmInfo()->hasAggressiveSymbolFolding())
     return Expr;
 
   MCSymbol *ABS = Context.createTempSymbol();
   OS.EmitAssignment(ABS, Expr);
   return MCSymbolRefExpr::create(ABS, Context);
 }
 
 static void emitAbsValue(MCStreamer &OS, const MCExpr *Value, unsigned Size) {
   const MCExpr *ABS = forceExpAbs(OS, Value);
   OS.EmitValue(ABS, Size);
 }
 
+void MCDwarfLineStr::emitSection(MCStreamer *MCOS) {
+  // Switch to the .debug_line_str section.
+  MCOS->SwitchSection(
+      MCOS->getContext().getObjectFileInfo()->getDwarfLineStrSection());
+  // Emit the strings without perturbing the offsets we used.
+  LineStrings.finalizeInOrder();
+  SmallString<0> Data;
+  Data.resize(LineStrings.getSize());
+  LineStrings.write((uint8_t *)Data.data());
+  MCOS->EmitBinaryData(Data.str());
+}
+
+void MCDwarfLineStr::emitRef(MCStreamer *MCOS, StringRef Path) {
+  int RefSize = 4; // FIXME: Support DWARF-64
+  size_t Offset = LineStrings.add(Path);
+  if (UseRelocs) {
+    MCContext &Ctx = MCOS->getContext();
+    MCOS->EmitValue(makeStartPlusIntExpr(Ctx, *LineStrLabel, Offset), RefSize);
+  } else
+    MCOS->EmitIntValue(Offset, RefSize);
+}
+
 void MCDwarfLineTableHeader::emitV2FileDirTables(MCStreamer *MCOS) const {
   // First the directory table.
   for (auto &Dir : MCDwarfDirs) {
     MCOS->EmitBytes(Dir);                // The DirectoryName, and...
     MCOS->EmitBytes(StringRef("\0", 1)); // its null terminator.
   }
   MCOS->EmitIntValue(0, 1); // Terminate the directory list.
 
   // Second the file table.
   for (unsigned i = 1; i < MCDwarfFiles.size(); i++) {
     assert(!MCDwarfFiles[i].Name.empty());
     MCOS->EmitBytes(MCDwarfFiles[i].Name); // FileName and...
     MCOS->EmitBytes(StringRef("\0", 1));   // its null terminator.
     MCOS->EmitULEB128IntValue(MCDwarfFiles[i].DirIndex); // Directory number.
     MCOS->EmitIntValue(0, 1); // Last modification timestamp (always 0).
     MCOS->EmitIntValue(0, 1); // File size (always 0).
   }
   MCOS->EmitIntValue(0, 1); // Terminate the file list.
 }
 
-void MCDwarfLineTableHeader::emitV5FileDirTables(MCStreamer *MCOS) const {
-  // The directory format, which is just inline null-terminated strings.
+void MCDwarfLineTableHeader::emitV5FileDirTables(
+    MCStreamer *MCOS, MCDwarfLineStr *LineStr) const {
+  // The directory format, which is just a list of the directory paths.  In a
+  // non-split object, these are references to .debug_line_str; in a split
+  // object, they are inline strings.
   MCOS->EmitIntValue(1, 1);
   MCOS->EmitULEB128IntValue(dwarf::DW_LNCT_path);
-  MCOS->EmitULEB128IntValue(dwarf::DW_FORM_string);
-  // Then the list of directory paths.  CompilationDir comes first.
+  MCOS->EmitULEB128IntValue(LineStr ? dwarf::DW_FORM_line_strp
+                                    : dwarf::DW_FORM_string);
   MCOS->EmitULEB128IntValue(MCDwarfDirs.size() + 1);
+  if (LineStr) {
+    // Record path strings, emit references here.
+    LineStr->emitRef(MCOS, CompilationDir);
+    for (auto &Dir : MCDwarfDirs)
+      LineStr->emitRef(MCOS, Dir);
+  } else {
+    // The list of directory paths.  CompilationDir comes first.
     MCOS->EmitBytes(CompilationDir);
     MCOS->EmitBytes(StringRef("\0", 1));
     for (auto &Dir : MCDwarfDirs) {
       MCOS->EmitBytes(Dir);                // The DirectoryName, and...
       MCOS->EmitBytes(StringRef("\0", 1)); // its null terminator.
     }
+  }
 
   // The file format, which is the inline null-terminated filename and a
   // directory index.  We don't track file size/timestamp so don't emit them
   // in the v5 table.  Emit MD5 checksums if we have them.
   MCOS->EmitIntValue(HasMD5 ? 3 : 2, 1);
   MCOS->EmitULEB128IntValue(dwarf::DW_LNCT_path);
-  MCOS->EmitULEB128IntValue(dwarf::DW_FORM_string);
+  MCOS->EmitULEB128IntValue(LineStr ? dwarf::DW_FORM_line_strp
+                                    : dwarf::DW_FORM_string);
   MCOS->EmitULEB128IntValue(dwarf::DW_LNCT_directory_index);
   MCOS->EmitULEB128IntValue(dwarf::DW_FORM_udata);
   if (HasMD5) {
     MCOS->EmitULEB128IntValue(dwarf::DW_LNCT_MD5);
     MCOS->EmitULEB128IntValue(dwarf::DW_FORM_data16);
   }
   // Then the list of file names. These start at 1.
   MCOS->EmitULEB128IntValue(MCDwarfFiles.size() - 1);
   for (unsigned i = 1; i < MCDwarfFiles.size(); ++i) {
     assert(!MCDwarfFiles[i].Name.empty());
+    if (LineStr)
+      LineStr->emitRef(MCOS, MCDwarfFiles[i].Name);
+    else {
       MCOS->EmitBytes(MCDwarfFiles[i].Name); // FileName and...
       MCOS->EmitBytes(StringRef("\0", 1));   // its null terminator.
+    }
     MCOS->EmitULEB128IntValue(MCDwarfFiles[i].DirIndex); // Directory number.
     if (HasMD5) {
       MD5::MD5Result *Cksum = MCDwarfFiles[i].Checksum;
       MCOS->EmitBinaryData(
           StringRef(reinterpret_cast<const char *>(Cksum->Bytes.data()),
                     Cksum->Bytes.size()));
     }
   }
 }
 
 std::pair<MCSymbol *, MCSymbol *>
 MCDwarfLineTableHeader::Emit(MCStreamer *MCOS, MCDwarfLineTableParams Params,
-                             ArrayRef<char> StandardOpcodeLengths) const {
+                             ArrayRef<char> StandardOpcodeLengths,
+                             MCDwarfLineStr *LineStr) const {
   MCContext &context = MCOS->getContext();
 
   // Create a symbol at the beginning of the line table.
   MCSymbol *LineStartSym = Label;
   if (!LineStartSym)
     LineStartSym = context.createTempSymbol();
   // Set the value of the symbol, as we are at the start of the line table.
   MCOS->EmitLabel(LineStartSym);
MCDwarfLineTableHeader::Emit(MCStreamer *MCOS, MCDwarfLineTableParams Params,
 
   // Standard opcode lengths
   for (char Length : StandardOpcodeLengths)
     MCOS->EmitIntValue(Length, 1);
 
   // Put out the directory and file tables.  The formats vary depending on
   // the version.
   if (LineTableVersion >= 5)
-    emitV5FileDirTables(MCOS);
+    emitV5FileDirTables(MCOS, LineStr);
   else
     emitV2FileDirTables(MCOS);
 
   // This is the end of the prologue, so set the value of the symbol at the
   // end of the prologue (that was used in a previous expression).
   MCOS->EmitLabel(ProEndSym);
 
   return std::make_pair(LineStartSym, LineEndSym);
 }
 
 void MCDwarfLineTable::EmitCU(MCObjectStreamer *MCOS,
-                              MCDwarfLineTableParams Params) const {
-  MCSymbol *LineEndSym = Header.Emit(MCOS, Params).second;
+                              MCDwarfLineTableParams Params,
+                              MCDwarfLineStr *LineStr) const {
+  MCSymbol *LineEndSym = Header.Emit(MCOS, Params, LineStr).second;
 
   // Put out the line tables.
   for (const auto &LineSec : MCLineSections.getMCLineEntries())
     EmitDwarfLineTable(MCOS, LineSec.first, LineSec.second);
 
   // This is the end of the section, so set the value of the symbol at the end
   // of this section (that was used in a previous expression).
   MCOS->EmitLabel(LineEndSym);

llvm/lib/MC/MCObjectFileInfo.cpp

DwarfAbbrevSection =
       Ctx->getMachOSection("__DWARF", "__debug_abbrev", MachO::S_ATTR_DEBUG,
                            SectionKind::getMetadata(), "section_abbrev");
   DwarfInfoSection =
       Ctx->getMachOSection("__DWARF", "__debug_info", MachO::S_ATTR_DEBUG,
                            SectionKind::getMetadata(), "section_info");
   DwarfLineSection =
       Ctx->getMachOSection("__DWARF", "__debug_line", MachO::S_ATTR_DEBUG,
                            SectionKind::getMetadata(), "section_line");
+  DwarfLineStrSection =
+      Ctx->getMachOSection("__DWARF", "__debug_line_str", MachO::S_ATTR_DEBUG,
+                           SectionKind::getMetadata(), "section_line_str");
   DwarfFrameSection =
       Ctx->getMachOSection("__DWARF", "__debug_frame", MachO::S_ATTR_DEBUG,
                            SectionKind::getMetadata());
   DwarfPubNamesSection =
       Ctx->getMachOSection("__DWARF", "__debug_pubnames", MachO::S_ATTR_DEBUG,
                            SectionKind::getMetadata());
   DwarfPubTypesSection =
       Ctx->getMachOSection("__DWARF", "__debug_pubtypes", MachO::S_ATTR_DEBUG,
if (T.getArch() == Triple::mips || T.getArch() == Triple::mipsel ||
       T.getArch() == Triple::mips64 || T.getArch() == Triple::mips64el)
     DebugSecType = ELF::SHT_MIPS_DWARF;
 
   // Debug Info Sections.
   DwarfAbbrevSection =
       Ctx->getELFSection(".debug_abbrev", DebugSecType, 0);
   DwarfInfoSection = Ctx->getELFSection(".debug_info", DebugSecType, 0);
   DwarfLineSection = Ctx->getELFSection(".debug_line", DebugSecType, 0);
+  DwarfLineStrSection =
+      Ctx->getELFSection(".debug_line_str", DebugSecType,
+                         ELF::SHF_MERGE | ELF::SHF_STRINGS, 1, "");
   DwarfFrameSection = Ctx->getELFSection(".debug_frame", DebugSecType, 0);
   DwarfPubNamesSection =
       Ctx->getELFSection(".debug_pubnames", DebugSecType, 0);
   DwarfPubTypesSection =
       Ctx->getELFSection(".debug_pubtypes", DebugSecType, 0);
   DwarfGnuPubNamesSection =
       Ctx->getELFSection(".debug_gnu_pubnames", DebugSecType, 0);
   DwarfGnuPubTypesSection =
DwarfInfoSection = Ctx->getCOFFSection(
       COFF::IMAGE_SCN_MEM_DISCARDABLE | COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
           COFF::IMAGE_SCN_MEM_READ,
       SectionKind::getMetadata(), "section_info");
   DwarfLineSection = Ctx->getCOFFSection(
       ".debug_line",
       COFF::IMAGE_SCN_MEM_DISCARDABLE | COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
           COFF::IMAGE_SCN_MEM_READ,
       SectionKind::getMetadata(), "section_line");
-
+  DwarfLineStrSection = Ctx->getCOFFSection(
+      ".debug_line_str",
+      COFF::IMAGE_SCN_MEM_DISCARDABLE | COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
+          COFF::IMAGE_SCN_MEM_READ,
+      SectionKind::getMetadata(), "section_line_str");
   DwarfFrameSection = Ctx->getCOFFSection(
       ".debug_frame",
       COFF::IMAGE_SCN_MEM_DISCARDABLE | COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
           COFF::IMAGE_SCN_MEM_READ,
       SectionKind::getMetadata());
   DwarfPubNamesSection = Ctx->getCOFFSection(
       ".debug_pubnames",
       COFF::IMAGE_SCN_MEM_DISCARDABLE | COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |

 
 void MCObjectFileInfo::initWasmMCObjectFileInfo(const Triple &T) {
   // TODO: Set the section types and flags.
   TextSection = Ctx->getWasmSection(".text", SectionKind::getText());
   DataSection = Ctx->getWasmSection(".data", SectionKind::getData());
 
   // TODO: Set the section types and flags.
   DwarfLineSection = Ctx->getWasmSection(".debug_line", SectionKind::getMetadata());
+  DwarfLineStrSection =
+      Ctx->getWasmSection(".debug_line_str", SectionKind::getMetadata());
   DwarfStrSection = Ctx->getWasmSection(".debug_str", SectionKind::getMetadata());
   DwarfLocSection = Ctx->getWasmSection(".debug_loc", SectionKind::getMetadata());
   DwarfAbbrevSection = Ctx->getWasmSection(".debug_abbrev", SectionKind::getMetadata(), "section_abbrev");
   DwarfARangesSection = Ctx->getWasmSection(".debug_aranges", SectionKind::getMetadata());
   DwarfRangesSection = Ctx->getWasmSection(".debug_ranges", SectionKind::getMetadata(), "debug_range");
   DwarfMacinfoSection = Ctx->getWasmSection(".debug_macinfo", SectionKind::getMetadata(), "debug_macinfo");
   DwarfAddrSection = Ctx->getWasmSection(".debug_addr", SectionKind::getMetadata());
   DwarfCUIndexSection = Ctx->getWasmSection(".debug_cu_index", SectionKind::getMetadata());

llvm/lib/MC/StringTableBuilder.cpp

 
 StringTableBuilder::~StringTableBuilder() = default;
 
 void StringTableBuilder::initSize() {
   // Account for leading bytes in table so that offsets returned from add are
   // correct.
   switch (K) {
   case RAW:
+  case DWARF:
     Size = 0;
     break;
   case MachO:
   case ELF:
     // Start the table with a NUL byte.
     Size = 1;
     break;
   case WinCOFF:
tailcall:
   if (Pivot != -1) {
     Vec = Vec.slice(I, J - I);
     ++Pos;
     goto tailcall;
   }
 }
 
 void StringTableBuilder::finalize() {
+  assert(K != DWARF);
   finalizeStringTable(/*Optimize=*/true);
 }
 
 void StringTableBuilder::finalizeInOrder() {
   finalizeStringTable(/*Optimize=*/false);
 }
 
 void StringTableBuilder::finalizeStringTable(bool Optimize) {

llvm/test/MC/ELF/debug-md5.s

-// RUN: llvm-mc -triple x86_64-unknown-unknown -dwarf-version 5 -filetype=obj %s -o -| llvm-dwarfdump --debug-line - | FileCheck %s
+// RUN: llvm-mc -triple x86_64-unknown-unknown -dwarf-version 5 -filetype=obj %s -o - | llvm-dwarfdump --debug-line --debug-line-str -v - | FileCheck %s
 
         .file 1 "dir1/foo"   md5 "00112233445566778899aabbccddeeff"
         .file 2 "dir2" "bar" md5 "ffeeddccbbaa99887766554433221100"
         .loc 1 1 0
         nop
         .loc 2 1 0
         nop
 
 # CHECK: debug_line[0x00000000]
 # CHECK: version: 5
-# CHECK: include_directories[ 0] = ""
-# CHECK: include_directories[ 1] = "dir1"
-# CHECK: include_directories[ 2] = "dir2"
+# CHECK: include_directories[ 0] = .debug_line_str[0x00000000] = ""
+# CHECK: include_directories[ 1] = .debug_line_str[0x00000001] = "dir1"
+# CHECK: include_directories[ 2] = .debug_line_str[0x00000006] = "dir2"
 # CHECK-NOT: include_directories
 # CHECK: Dir MD5 Checksum File Name
-# CHECK: file_names[ 1] 1 00112233445566778899aabbccddeeff "foo"
-# CHECK: file_names[ 2] 2 ffeeddccbbaa99887766554433221100 "bar"
+# CHECK: file_names[ 1] 1 00112233445566778899aabbccddeeff .debug_line_str[0x0000000b] = "foo"
+# CHECK: file_names[ 2] 2 ffeeddccbbaa99887766554433221100 .debug_line_str[0x0000000f] = "bar"
+
+# CHECK: .debug_line_str contents:
+# CHECK-NEXT: 0x00000000: ""
+# CHECK-NEXT: 0x00000001: "dir1"
+# CHECK-NEXT: 0x00000006: "dir2"
+# CHECK-NEXT: 0x0000000b: "foo"
+# CHECK-NEXT: 0x0000000f: "bar"