[DWARFv5] Support FORM_line_strp when dumping

[probinson]

Summary

This form is like DW_FORM_strp, but points to .debug_line_str instead
of .debug_str as the string section. It's intended to be used from
the line-table header, and allows string-pooling of directory and
filenames across compilation units.

[probinson]

Most of this is just plumbing through cchanges to track the new section. DWARFFormValue.cpp is really the missing functional bit for dumping purposes.

[aprantl]

Most of this is just plumbing through cchanges to track the new section.

Agreed. LGTM

llvm/trunk/include/llvm/BinaryFormat/Dwarf.def

 // Note that these IDs don't mean anything.
 // TODO: Add Mach-O and COFF names.
 // Official DWARF sections.
 HANDLE_DWARF_SECTION(DebugAbbrev, ".debug_abbrev", "debug-abbrev")
 HANDLE_DWARF_SECTION(DebugAranges, ".debug_aranges", "debug-aranges")
 HANDLE_DWARF_SECTION(DebugInfo, ".debug_info", "debug-info")
 HANDLE_DWARF_SECTION(DebugTypes, ".debug_types", "debug-types")
 HANDLE_DWARF_SECTION(DebugLine, ".debug_line", "debug-line")
+HANDLE_DWARF_SECTION(DebugLineStr, ".debug_line_str", "debug-line-str")
 HANDLE_DWARF_SECTION(DebugLoc, ".debug_loc", "debug-loc")
 HANDLE_DWARF_SECTION(DebugFrame, ".debug_frame", "debug-frame")
 HANDLE_DWARF_SECTION(DebugMacro, ".debug_macro", "debug-macro")
 HANDLE_DWARF_SECTION(DebugNames, ".debug_names", "debug-names")
 HANDLE_DWARF_SECTION(DebugRanges, ".debug_ranges", "debug-ranges")
 HANDLE_DWARF_SECTION(DebugPubnames, ".debug_pubnames", "debug-pubnames")
 HANDLE_DWARF_SECTION(DebugPubtypes, ".debug_pubtypes", "debug-pubtypes")
 HANDLE_DWARF_SECTION(DebugGnuPubnames, ".debug_gnu_pubnames", "debug-gnu-pubnames")

llvm/trunk/include/llvm/DebugInfo/DWARF/DWARFCompileUnit.h

 
 namespace llvm {
 
 class DWARFCompileUnit : public DWARFUnit {
 public:
   DWARFCompileUnit(DWARFContext &Context, const DWARFSection &Section,
                    const DWARFDebugAbbrev *DA, const DWARFSection *RS,
                    StringRef SS, const DWARFSection &SOS,
-                   const DWARFSection *AOS, const DWARFSection &LS, bool LE,
-                   bool IsDWO, const DWARFUnitSectionBase &UnitSection,
+                   const DWARFSection *AOS, const DWARFSection &LS,
+                   StringRef LSS, bool LE, bool IsDWO,
+                   const DWARFUnitSectionBase &UnitSection,
                    const DWARFUnitIndex::Entry *Entry)
-      : DWARFUnit(Context, Section, DA, RS, SS, SOS, AOS, LS, LE, IsDWO,
+      : DWARFUnit(Context, Section, DA, RS, SS, SOS, AOS, LS, LSS, LE, IsDWO,
                   UnitSection, Entry) {}
 
   // VTable anchor.
   ~DWARFCompileUnit() override;
 
   void dump(raw_ostream &OS, DIDumpOptions DumpOpts);
 
   static const DWARFSectionKind Section = DW_SECT_INFO;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_DWARFCOMPILEUNIT_H

llvm/trunk/include/llvm/DebugInfo/DWARF/DWARFObject.h

public:
   virtual void
   forEachTypesSections(function_ref<void(const DWARFSection &)> F) const {}
   virtual StringRef getAbbrevSection() const { return ""; }
   virtual const DWARFSection &getLocSection() const { return Dummy; }
   virtual StringRef getARangeSection() const { return ""; }
   virtual StringRef getDebugFrameSection() const { return ""; }
   virtual StringRef getEHFrameSection() const { return ""; }
   virtual const DWARFSection &getLineSection() const { return Dummy; }
+  virtual StringRef getLineStringSection() const { return ""; }
   virtual StringRef getStringSection() const { return ""; }
   virtual const DWARFSection &getRangeSection() const { return Dummy; }
   virtual StringRef getMacinfoSection() const { return ""; }
   virtual StringRef getPubNamesSection() const { return ""; }
   virtual StringRef getPubTypesSection() const { return ""; }
   virtual StringRef getGnuPubNamesSection() const { return ""; }
   virtual StringRef getGnuPubTypesSection() const { return ""; }
   virtual const DWARFSection &getStringOffsetSection() const { return Dummy; }

llvm/trunk/include/llvm/DebugInfo/DWARF/DWARFTypeUnit.h

 private:
   uint64_t TypeHash;
   uint32_t TypeOffset;
 
 public:
   DWARFTypeUnit(DWARFContext &Context, const DWARFSection &Section,
                 const DWARFDebugAbbrev *DA, const DWARFSection *RS,
                 StringRef SS, const DWARFSection &SOS, const DWARFSection *AOS,
-                const DWARFSection &LS, bool LE, bool IsDWO,
+                const DWARFSection &LS, StringRef LSS, bool LE, bool IsDWO,
                 const DWARFUnitSectionBase &UnitSection,
                 const DWARFUnitIndex::Entry *Entry)
-      : DWARFUnit(Context, Section, DA, RS, SS, SOS, AOS, LS, LE, IsDWO,
+      : DWARFUnit(Context, Section, DA, RS, SS, SOS, AOS, LS, LSS, LE, IsDWO,
                   UnitSection, Entry) {}
 
   uint32_t getHeaderSize() const override {
     return DWARFUnit::getHeaderSize() + 12;
   }
 
   void dump(raw_ostream &OS, DIDumpOptions DumpOpts = {});
   static const DWARFSectionKind Section = DW_SECT_TYPES;
 
 protected:
   bool extractImpl(DataExtractor debug_info, uint32_t *offset_ptr) override;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_DWARF_DWARFTYPEUNIT_H

llvm/trunk/include/llvm/DebugInfo/DWARF/DWARFUnit.h

 
 protected:
   ~DWARFUnitSectionBase() = default;
 
   virtual void parseImpl(DWARFContext &Context, const DWARFSection &Section,
                          const DWARFDebugAbbrev *DA, const DWARFSection *RS,
                          StringRef SS, const DWARFSection &SOS,
                          const DWARFSection *AOS, const DWARFSection &LS,
-                         bool isLittleEndian, bool isDWO, bool Lazy) = 0;
+                         StringRef LSS, bool isLittleEndian, bool isDWO,
+                         bool Lazy) = 0;
 };
 
 const DWARFUnitIndex &getDWARFUnitIndex(DWARFContext &Context,
                                         DWARFSectionKind Kind);
 
 /// Concrete instance of DWARFUnitSection, specialized for one Unit type.
 template<typename UnitType>
 class DWARFUnitSection final : public SmallVector<std::unique_ptr<UnitType>, 1>,
UnitType *getUnitForIndexEntry(const DWARFUnitIndex::Entry &E) override {
     this->insert(CU, std::move(U));
     return NewCU;
   }
 
 private:
   void parseImpl(DWARFContext &Context, const DWARFSection &Section,
                  const DWARFDebugAbbrev *DA, const DWARFSection *RS,
                  StringRef SS, const DWARFSection &SOS, const DWARFSection *AOS,
-                 const DWARFSection &LS, bool LE, bool IsDWO,
+                 const DWARFSection &LS, StringRef LSS, bool LE, bool IsDWO,
                  bool Lazy) override {
     if (Parsed)
       return;
     DataExtractor Data(Section.Data, LE, 0);
     if (!Parser) {
       const DWARFUnitIndex *Index = nullptr;
       if (IsDWO)
         Index = &getDWARFUnitIndex(Context, UnitType::Section);
       Parser = [=, &Context, &Section, &SOS,
                 &LS](uint32_t Offset) -> std::unique_ptr<UnitType> {
         if (!Data.isValidOffset(Offset))
           return nullptr;
         auto U = llvm::make_unique<UnitType>(
-            Context, Section, DA, RS, SS, SOS, AOS, LS, LE, IsDWO, *this,
+            Context, Section, DA, RS, SS, SOS, AOS, LS, LSS, LE, IsDWO, *this,
             Index ? Index->getFromOffset(Offset) : nullptr);
         if (!U->extract(Data, &Offset))
           return nullptr;
         return U;
       };
     }
     if (Lazy)
       return;
class DWARFUnit {
   DWARFContext &Context;
   /// Section containing this DWARFUnit.
   const DWARFSection &InfoSection;
 
   const DWARFDebugAbbrev *Abbrev;
   const DWARFSection *RangeSection;
   uint32_t RangeSectionBase;
   const DWARFSection &LineSection;
+  StringRef LineStringSection;
   StringRef StringSection;
   const DWARFSection &StringOffsetSection;
   const DWARFSection *AddrOffsetSection;
   uint32_t AddrOffsetSectionBase = 0;
   bool isLittleEndian;
   bool isDWO;
   const DWARFUnitSectionBase &UnitSection;
 
protected:
   Optional<StrOffsetsContributionDescriptor>
   determineStringOffsetsTableContributionDWO(DWARFDataExtractor &DA,
                                              uint64_t Offset);
 
 public:
   DWARFUnit(DWARFContext &Context, const DWARFSection &Section,
             const DWARFDebugAbbrev *DA, const DWARFSection *RS, StringRef SS,
             const DWARFSection &SOS, const DWARFSection *AOS,
-            const DWARFSection &LS, bool LE, bool IsDWO,
+            const DWARFSection &LS, StringRef LSS, bool LE, bool IsDWO,
             const DWARFUnitSectionBase &UnitSection,
             const DWARFUnitIndex::Entry *IndexEntry = nullptr);
 
   virtual ~DWARFUnit();
 
   DWARFContext& getContext() const { return Context; }
 
   const DWARFSection &getLineSection() const { return LineSection; }
+  StringRef getLineStringSection() const { return LineStringSection; }
   StringRef getStringSection() const { return StringSection; }
   const DWARFSection &getStringOffsetSection() const {
     return StringOffsetSection;
   }
 
   void setAddrOffsetSection(const DWARFSection *AOS, uint32_t Base) {
     AddrOffsetSection = AOS;
     AddrOffsetSectionBase = Base;
   }
 
   void setRangesSection(const DWARFSection *RS, uint32_t Base) {
     RangeSection = RS;
     RangeSectionBase = Base;
   }
 
   bool getAddrOffsetSectionItem(uint32_t Index, uint64_t &Result) const;
   bool getStringOffsetSectionItem(uint32_t Index, uint64_t &Result) const;
 
   DWARFDataExtractor getDebugInfoExtractor() const;
 
+  DataExtractor getLineStringExtractor() const {
+    return DataExtractor(LineStringSection, false, 0);
+  }
   DataExtractor getStringExtractor() const {
     return DataExtractor(StringSection, false, 0);
   }
 
-
   bool extract(DataExtractor debug_info, uint32_t* offset_ptr);
 
   /// extractRangeList - extracts the range list referenced by this compile
   /// unit from .debug_ranges section. Returns true on success.
   /// Requires that compile unit is already extracted.
   bool extractRangeList(uint32_t RangeListOffset,
                         DWARFDebugRangeList &RangeList) const;
   void clear();

llvm/trunk/lib/DebugInfo/DWARF/DWARFContext.cpp

if (shouldDump(ExplicitDWO, ".debug_str.dwo", DIDT_ID_DebugStr,
     DataExtractor strDWOData(DObj->getStringDWOSection(), isLittleEndian(), 0);
     uint32_t offset = 0;
     uint32_t strDWOOffset = 0;
     while (const char *s = strDWOData.getCStr(&offset)) {
       OS << format("0x%8.8x: \"%s\"\n", strDWOOffset, s);
       strDWOOffset = offset;
     }
   }
+  if (shouldDump(Explicit, ".debug_line_str", DIDT_ID_DebugLineStr,
+                 DObj->getLineStringSection())) {
+    DataExtractor strData(DObj->getLineStringSection(), isLittleEndian(), 0);
+    uint32_t offset = 0;
+    uint32_t strOffset = 0;
+    while (const char *s = strData.getCStr(&offset)) {
+      OS << format("0x%8.8x: \"%s\"\n", strOffset, s);
+      strOffset = offset;
+    }
+  }
 
   if (shouldDump(Explicit, ".debug_ranges", DIDT_ID_DebugRanges,
                  DObj->getRangeSection().Data)) {
     // In fact, different compile units may have different address byte
     // sizes, but for simplicity we just use the address byte size of the
     // last compile unit (there is no easy and fast way to associate address
     // range list and the compile unit it describes).
     // FIXME: savedAddressByteSize seems sketchy.
class DWARFObjInMemory final : public DWARFObject {
   StringRef PubTypesSection;
   StringRef GnuPubNamesSection;
   StringRef AbbrevDWOSection;
   StringRef StringDWOSection;
   StringRef GnuPubTypesSection;
   StringRef CUIndexSection;
   StringRef GdbIndexSection;
   StringRef TUIndexSection;
+  StringRef LineStringSection;
 
   SmallVector<SmallString<32>, 4> UncompressedSections;
 
   StringRef *mapSectionToMember(StringRef Name) {
     if (DWARFSection *Sec = mapNameToDWARFSection(Name))
       return &Sec->Data;
     return StringSwitch<StringRef *>(Name)
         .Case("debug_abbrev", &AbbrevSection)
         .Case("debug_aranges", &ARangeSection)
         .Case("debug_frame", &DebugFrameSection)
         .Case("eh_frame", &EHFrameSection)
         .Case("debug_str", &StringSection)
         .Case("debug_macinfo", &MacinfoSection)
         .Case("debug_pubnames", &PubNamesSection)
         .Case("debug_pubtypes", &PubTypesSection)
         .Case("debug_gnu_pubnames", &GnuPubNamesSection)
         .Case("debug_gnu_pubtypes", &GnuPubTypesSection)
         .Case("debug_abbrev.dwo", &AbbrevDWOSection)
         .Case("debug_str.dwo", &StringDWOSection)
         .Case("debug_cu_index", &CUIndexSection)
         .Case("debug_tu_index", &TUIndexSection)
         .Case("gdb_index", &GdbIndexSection)
+        .Case("debug_line_str", &LineStringSection)
         // Any more debug info sections go here.
         .Default(nullptr);
   }
 
   /// If Sec is compressed section, decompresses and updates its contents
   /// provided by Data. Otherwise leaves it unchanged.
   Error maybeDecompress(const object::SectionRef &Sec, StringRef Name,
                         StringRef &Data) {
public:
   StringRef getCUIndexSection() const override { return CUIndexSection; }
   StringRef getGdbIndexSection() const override { return GdbIndexSection; }
   StringRef getTUIndexSection() const override { return TUIndexSection; }
 
   // DWARF v5
   const DWARFSection &getStringOffsetSection() const override {
     return StringOffsetSection;
   }
+  StringRef getLineStringSection() const override { return LineStringSection; }
 
   // Sections for DWARF5 split dwarf proposal.
   const DWARFSection &getInfoDWOSection() const override {
     return InfoDWOSection;
   }
   void forEachTypesDWOSections(
       function_ref<void(const DWARFSection &)> F) const override {
     for (auto &P : TypesDWOSections)

llvm/trunk/lib/DebugInfo/DWARF/DWARFFormValue.cpp

case DW_FORM_GNU_addr_index:
     return (FC == FC_Address);
   case DW_FORM_GNU_str_index:
   case DW_FORM_GNU_strp_alt:
   case DW_FORM_strx:
   case DW_FORM_strx1:
   case DW_FORM_strx2:
   case DW_FORM_strx3:
   case DW_FORM_strx4:
+  case DW_FORM_line_strp:
     return (FC == FC_String);
   case DW_FORM_implicit_const:
     return (FC == FC_Constant);
   default:
     break;
   }
   // In DWARF3 DW_FORM_data4 and DW_FORM_data8 served also as a section offset.
   // Don't check for DWARF version here, as some producers may still do this
Optional<const char *> DWARFFormValue::getAsCString() const {
   if (!isFormClass(FC_String))
     return None;
   if (Form == DW_FORM_string)
     return Value.cstr;
   // FIXME: Add support for DW_FORM_GNU_strp_alt
   if (Form == DW_FORM_GNU_strp_alt || U == nullptr)
     return None;
   uint32_t Offset = Value.uval;
+  if (Form == DW_FORM_line_strp) {
+    if (const char *Str = U->getLineStringExtractor().getCStr(&Offset))
+      return Str;
+    return None;
+  }
   if (Form == DW_FORM_GNU_str_index || Form == DW_FORM_strx ||
       Form == DW_FORM_strx1 || Form == DW_FORM_strx2 || Form == DW_FORM_strx3 ||
       Form == DW_FORM_strx4) {
     uint64_t StrOffset;
     if (!U->getStringOffsetSectionItem(Offset, StrOffset))
       return None;
     Offset = StrOffset;
   }

llvm/trunk/lib/DebugInfo/DWARF/DWARFUnit.cpp

 
 using namespace llvm;
 using namespace dwarf;
 
 void DWARFUnitSectionBase::parse(DWARFContext &C, const DWARFSection &Section) {
   const DWARFObject &D = C.getDWARFObj();
   parseImpl(C, Section, C.getDebugAbbrev(), &D.getRangeSection(),
             D.getStringSection(), D.getStringOffsetSection(),
-            &D.getAddrSection(), D.getLineSection(), D.isLittleEndian(), false,
-            false);
+            &D.getAddrSection(), D.getLineSection(), D.getLineStringSection(),
+            D.isLittleEndian(), false, false);
 }
 
 void DWARFUnitSectionBase::parseDWO(DWARFContext &C,
                                     const DWARFSection &DWOSection, bool Lazy) {
   const DWARFObject &D = C.getDWARFObj();
   parseImpl(C, DWOSection, C.getDebugAbbrevDWO(), &D.getRangeDWOSection(),
             D.getStringDWOSection(), D.getStringOffsetDWOSection(),
-            &D.getAddrSection(), D.getLineDWOSection(), C.isLittleEndian(),
-            true, Lazy);
+            &D.getAddrSection(), D.getLineDWOSection(), StringRef(),
+            C.isLittleEndian(), true, Lazy);
 }
 
 DWARFUnit::DWARFUnit(DWARFContext &DC, const DWARFSection &Section,
                      const DWARFDebugAbbrev *DA, const DWARFSection *RS,
                      StringRef SS, const DWARFSection &SOS,
-                     const DWARFSection *AOS, const DWARFSection &LS, bool LE,
-                     bool IsDWO, const DWARFUnitSectionBase &UnitSection,
+                     const DWARFSection *AOS, const DWARFSection &LS,
+                     StringRef LSS, bool LE, bool IsDWO,
+                     const DWARFUnitSectionBase &UnitSection,
                      const DWARFUnitIndex::Entry *IndexEntry)
     : Context(DC), InfoSection(Section), Abbrev(DA), RangeSection(RS),
-      LineSection(LS), StringSection(SS), StringOffsetSection(SOS),
-      AddrOffsetSection(AOS), isLittleEndian(LE), isDWO(IsDWO),
-      UnitSection(UnitSection), IndexEntry(IndexEntry) {
+      LineSection(LS), LineStringSection(LSS), StringSection(SS),
+      StringOffsetSection(SOS), AddrOffsetSection(AOS), isLittleEndian(LE),
+      isDWO(IsDWO), UnitSection(UnitSection), IndexEntry(IndexEntry) {
   clear();
 }
 
 DWARFUnit::~DWARFUnit() = default;
 
 DWARFDataExtractor DWARFUnit::getDebugInfoExtractor() const {
   return DWARFDataExtractor(Context.getDWARFObj(), InfoSection, isLittleEndian,
                             getAddressByteSize());

llvm/trunk/lib/DebugInfo/DWARF/DWARFVerifier.cpp

if (!verifyUnitHeader(DebugInfoData, &Offset, UnitIdx, UnitType,
       std::unique_ptr<DWARFUnit> Unit;
       switch (UnitType) {
       case dwarf::DW_UT_type:
       case dwarf::DW_UT_split_type: {
         Unit.reset(new DWARFTypeUnit(
             DCtx, DObj.getInfoSection(), DCtx.getDebugAbbrev(),
             &DObj.getRangeSection(), DObj.getStringSection(),
             DObj.getStringOffsetSection(), &DObj.getAppleObjCSection(),
-            DObj.getLineSection(), DCtx.isLittleEndian(), false, TUSection,
-            nullptr));
+            DObj.getLineSection(), DObj.getLineStringSection(),
+            DCtx.isLittleEndian(), false, TUSection, nullptr));
         break;
       }
       case dwarf::DW_UT_skeleton:
       case dwarf::DW_UT_split_compile:
       case dwarf::DW_UT_compile:
       case dwarf::DW_UT_partial:
       // UnitType = 0 means that we are
       // verifying a compile unit in DWARF v4.
       case 0: {
         Unit.reset(new DWARFCompileUnit(
             DCtx, DObj.getInfoSection(), DCtx.getDebugAbbrev(),
             &DObj.getRangeSection(), DObj.getStringSection(),
             DObj.getStringOffsetSection(), &DObj.getAppleObjCSection(),
-            DObj.getLineSection(), DCtx.isLittleEndian(), false, CUSection,
-            nullptr));
+            DObj.getLineSection(), DObj.getLineStringSection(),
+            DCtx.isLittleEndian(), false, CUSection, nullptr));
         break;
       }
       default: { llvm_unreachable("Invalid UnitType."); }
       }
       Unit->extract(DebugInfoData, &OffsetStart);
       if (!verifyUnitContents(*Unit, UnitType))
         ++NumDebugInfoErrors;
     }

llvm/trunk/test/DebugInfo/X86/dwarfdump-header.s

LH_5_params:
         .byte   0x0e            # DW_FORM_strp (-> .debug_str)
         # Directory table entries
         .byte   2               # Two directories
         .long   str_LT_5a
         .long   str_LT_5b
         # File table format
         .byte   3               # Three elements per file entry
         .byte   1               # DW_LNCT_path
-        .byte   0x08            # DW_FORM_string
+        .byte   0x1f            # DW_FORM_line_strp (-> .debug_line_str)
         .byte   2               # DW_LNCT_directory_index
         .byte   0x0b            # DW_FORM_data1
         .byte   5               # DW_LNCT_MD5
         .byte   0x1e            # DW_FORM_data16
         # File table entries
         .byte   2               # Two files
-        .asciz "File5a"
+        .long   lstr_LT_5a
         .byte   0
         .quad   0x7766554433221100
         .quad   0xffeeddccbbaa9988
-        .asciz "File5b"
+        .long   lstr_LT_5b
         .byte   1
         .quad   0x8899aabbccddeeff
         .quad   0x0011223344556677
 LH_5_header_end:
         # Line number program, which is empty.
 LH_5_end:
 
 # CHECK: Line table prologue:
 # CHECK: version: 5
 # CHECK: address_size: 8
 # CHECK: seg_select_size: 0
 # CHECK: max_ops_per_inst: 1
 # CHECK: include_directories[  0] = 'Directory5a'
 # CHECK: include_directories[  1] = 'Directory5b'
 # CHECK-NOT: include_directories
 # CHECK: MD5 Checksum
 # CHECK: file_names[  1]    0 00112233445566778899aabbccddeeff File5a{{$}}
 # CHECK: file_names[  2]    1 ffeeddccbbaa99887766554433221100 File5b{{$}}
 # CHECK-NOT: file_names
 
+        .section .debug_line_str,"MS",@progbits,1
+lstr_LT_5a:
+        .asciz "File5a"
+lstr_LT_5b:
+        .asciz "File5b"
+
   .section .debug_line.dwo,"",@progbits
 # CHECK-LABEL: .debug_line.dwo
 
 # DWARF v5 DWO line-table header.
 dwo_LH_5_start:
         .long   dwo_LH_5_end-dwo_LH_5_version   # Length of Unit
 dwo_LH_5_version:
         .short  5               # DWARF version number