DWARF: Implementation of v5 string offsets table (.debug_str_offsets[.dwo] section)

[wolfgangp]

Summary

This is a proposed implementation of the DWARF v5 string offsets table for both producer and consumer side. This includes handling of the DW_AT_str_offsets_base attribute in the unit headers and the usage of DW_FORM_strx for string references.

I'd like to leave the emission of DW_FORM_strx{1,2,3,4} for a follow-on patch. Also, apologies for not handling Mach-O. I'm not familiar with it just yet, though I would like to handle it in another follow-on unless someone else wants to.

This could be easily broken into 2 patches (1 producer, 1 consumer) it that's more manageable.

[aprantl]

Thanks! The patch may be large, but the changes are mostly straightforward and generally look good to me. I found a couple of nits inline.

include/llvm/DebugInfo/DWARF/DWARFContext.h

241

/// DWARF 5.
/// @{
...
/// @}

include/llvm/DebugInfo/DWARF/DWARFUnit.h

217

const RelocAddrMap &getStringOffsetsRelocMap() const?

lib/CodeGen/AsmPrinter/DIE.cpp

618

http://llvm.org/docs/CodingStandards.html#doxygen-use-in-documentation-comments
wants us to comment in on place only. This should be a doxygen comment and it should be on the function prototype inside DIEIndexedString.

lib/CodeGen/AsmPrinter/DwarfUnit.cpp

80

nullptr?

1592

Move comment into header.

lib/CodeGen/AsmPrinter/DwarfUnit.h

314

/// Add a label delta attribute data and value.

318

ditto

lib/DebugInfo/DWARF/DWARFContext.cpp

102

comment why?

104

drop the else

314

"DWARF 5" vs "DWARF v5" vs "DWARF Version 5"?

[aprantl]

Also, apologies for not handling Mach-O.

Typically we try to do a best effort on all supported containers (ELF, Mach-O, COFF) when adding new features.
Could you outline what is necessary there? Is it just coming up with a short-enough section name or is there more to it?

[wolfgangp]

In D32618#740256, @aprantl wrote:

Also, apologies for not handling Mach-O.

Typically we try to do a best effort on all supported containers (ELF, Mach-O, COFF) when adding new features.
Could you outline what is necessary there? Is it just coming up with a short-enough section name or is there more to it?

That is probably it. Basically, the hardest part is just making string references unique to the unit (compile unit, type unit) and putting all the relocatable string references into the new section. Nothing that should be specific to the object file format. I can take a stab at it, it shouldn't take too long.

[aprantl]

In D32618#740265, @wolfgangp wrote:

In D32618#740256, @aprantl wrote:

Also, apologies for not handling Mach-O.

Typically we try to do a best effort on all supported containers (ELF, Mach-O, COFF) when adding new features.
Could you outline what is necessary there? Is it just coming up with a short-enough section name or is there more to it?

That is probably it. Basically, the hardest part is just making string references unique to the unit (compile unit, type unit) and putting all the relocatable string references into the new section. Nothing that should be specific to the object file format. I can take a stab at it, it shouldn't take too long.

Thanks! I looked through my mail archive and found this text that I compiled for the dwarf mailing list last year about the various platforms' name limitations:

I recommend adding the following non-normative text about Mach-O [1] (as used by OS X, iOS, ...):

In the Mach-O object file format, debug info sections are located
in the __DEBUG segment. By convention, section names start with a
double underscore instead of the leading dot. Section names are
truncated to 16 characters. Since Mach-O linkers do not link the
debug information, there is no real use-case for the .dwo
sections.

If I had to invent names for the .dwo sections I would replace the debug prefix with dwo. For example:

1234567890123456 1234567890123456
.debug_str_offsets.dwo -> __dwo_str_offset

But, since no compiler implements DWO support for Mach-O (it is solving a problem that does not exist on the platform), I’m unsure whether we should standardize names at this point.

For COFF, which is used on Windows, the situation is confusing. I’ve been told that the COFF linker truncates section names after 8 characters. Still, apparently the file format can hold more than that and compilers like clang use the full ELF section names and this does not seem to be problem. My best guess is that this works because all of the DWARF 2 section names are unique after 8 characters. Other compilers like Microsoft’s Visual Studio don’t emit DWARF, but use their own CodeView debug file format. I’m unsure how to describe this situation in the text. Maybe we should pass.

• adrian

[wolfgangp]

Added support for Mach-O and COFF and addressed review comments.

[wolfgangp]

lib/CodeGen/AsmPrinter/DwarfUnit.cpp

80

This symbol is not needed in v4 and earlier and only gets created when there is a string offsets section. Could you elaborate what your objection is?

[aprantl]

lib/CodeGen/AsmPrinter/DwarfUnit.cpp

80

It looks like phabricator misleadingly interpreted my source code as formatting :-)
this was meant to say: = nullptr, i.e., doing a C++11-style initialization in the header file might look better here?

[wolfgangp]

Also, Dave would prefer to split the patch in 2, in producer/consumer. Any objections?

lib/CodeGen/AsmPrinter/DwarfUnit.cpp

80

Ah, OK, sure. I agree. I'll make that change.

[aprantl]

By the way: you probably noticed that since last week have a brand new DWARF Verifier (accessible via dwarfdump --verify). It might be nice to develop Verifier checks alongside with the support for new sections/formats.

include/llvm/CodeGen/DIE.h

public:
 
   void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
   unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
 
   void print(raw_ostream &O) const;
 };
 
 //===--------------------------------------------------------------------===//
+/// A container for string pool string values indexed by a unit-specific index.
+///
+/// This class is used with the DW_FORM_strx form.
+class DIEIndexedString {
+  DwarfStringPoolEntryRef S;
+  unsigned Index;
+
+public:
+  DIEIndexedString(const DwarfStringPoolEntryRef S, unsigned Ix)
+      : S(S), Index(Ix) {}
+
+  StringRef getString() const { return S.getString(); }
+  unsigned getIndex() const { return Index; }
+
+  void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
+  unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
+
+  void print(raw_ostream &O) const;
+};
+
+//===--------------------------------------------------------------------===//
 /// A container for inline string values.
 ///
 /// This class is used with the DW_FORM_string form.
 class DIEInlineString {
   StringRef S;
 
 public:
   template <typename Allocator>

include/llvm/CodeGen/DIEValue.def

 HANDLE_DIEVALUE_SMALL(Expr)
 HANDLE_DIEVALUE_SMALL(Label)
 HANDLE_DIEVALUE_LARGE(Delta)
 HANDLE_DIEVALUE_SMALL(Entry)
 HANDLE_DIEVALUE_LARGE(Block)
 HANDLE_DIEVALUE_LARGE(Loc)
 HANDLE_DIEVALUE_SMALL(LocList)
 HANDLE_DIEVALUE_LARGE(InlineString)
+HANDLE_DIEVALUE_LARGE(IndexedString)
 
 #undef HANDLE_DIEVALUE
 #undef HANDLE_DIEVALUE_SMALL
 #undef HANDLE_DIEVALUE_LARGE

include/llvm/CodeGen/DwarfStringPoolEntry.h

MCSymbol *getSymbol() const {
     return I->second.Symbol;
   }
   unsigned getOffset() const { return I->second.Offset; }
   unsigned getIndex() const { return I->second.Index; }
   StringRef getString() const { return I->first(); }
 
   bool operator==(const DwarfStringPoolEntryRef &X) const { return I == X.I; }
   bool operator!=(const DwarfStringPoolEntryRef &X) const { return I != X.I; }
+  bool operator<(const DwarfStringPoolEntryRef &X) const {
+    return getIndex() < X.getIndex();
+  }
 };
 
 } // end namespace llvm
 
 #endif

include/llvm/DebugInfo/DIContext.h

enum DIDumpType {
   DIDT_LocDwo,
   DIDT_Macro,
   DIDT_Ranges,
   DIDT_Pubnames,
   DIDT_Pubtypes,
   DIDT_GnuPubnames,
   DIDT_GnuPubtypes,
   DIDT_Str,
+  DIDT_StrOffsets,
   DIDT_StrDwo,
   DIDT_StrOffsetsDwo,
   DIDT_AppleNames,
   DIDT_AppleTypes,
   DIDT_AppleNamespaces,
   DIDT_AppleObjC,
   DIDT_CUIndex,
   DIDT_GdbIndex,

include/llvm/DebugInfo/DWARF/DWARFCompileUnit.h

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

include/llvm/DebugInfo/DWARF/DWARFContext.h

class DWARFContext : public DIContext {
   std::unique_ptr<DWARFDebugFrame> EHFrame;
   std::unique_ptr<DWARFDebugMacro> Macro;
 
   DWARFUnitSection<DWARFCompileUnit> DWOCUs;
   std::deque<DWARFUnitSection<DWARFTypeUnit>> DWOTUs;
   std::unique_ptr<DWARFDebugAbbrev> AbbrevDWO;
   std::unique_ptr<DWARFDebugLocDWO> LocDWO;
 
+  /// The maximum DWARF version of all units.
+  unsigned MaxVersion;
+
   /// Read compile units from the debug_info section (if necessary)
   /// and store them in CUs.
   void parseCompileUnits();
 
   /// Read type units from the debug_types sections (if necessary)
   /// and store them in TUs.
   void parseTypeUnits();
 
   /// Read compile units from the debug_info.dwo section (if necessary)
   /// and store them in DWOCUs.
   void parseDWOCompileUnits();
 
   /// Read type units from the debug_types.dwo section (if necessary)
   /// and store them in DWOTUs.
   void parseDWOTypeUnits();
 
 public:
-  DWARFContext() : DIContext(CK_DWARF) {}
+  DWARFContext() : DIContext(CK_DWARF), MaxVersion(0) {}
   DWARFContext(DWARFContext &) = delete;
   DWARFContext &operator=(DWARFContext &) = delete;
 
   static bool classof(const DIContext *DICtx) {
     return DICtx->getKind() == CK_DWARF;
   }
 
   void dump(raw_ostream &OS, DIDumpType DumpType = DIDT_All,
public:
   }
 
   /// Get the compile unit at the specified index for the DWO compile units.
   DWARFCompileUnit *getDWOCompileUnitAtIndex(unsigned index) {
     parseDWOCompileUnits();
     return DWOCUs[index].get();
   }
 
+  unsigned getMaxVersion() const { return MaxVersion; }
+
+  void setMaxVersionIfGreater(unsigned Version) {
+    if (Version > MaxVersion)
+      MaxVersion = Version;
+  }
+
   const DWARFUnitIndex &getCUIndex();
   DWARFGdbIndex &getGdbIndex();
   const DWARFUnitIndex &getTUIndex();
 
   /// Get a pointer to the parsed DebugAbbrev object.
   const DWARFDebugAbbrev *getDebugAbbrev();
 
   /// Get a pointer to the parsed DebugLoc object.
public:
   virtual StringRef getStringSection() = 0;
   virtual const DWARFSection& getRangeSection() = 0;
   virtual StringRef getMacinfoSection() = 0;
   virtual StringRef getPubNamesSection() = 0;
   virtual StringRef getPubTypesSection() = 0;
   virtual StringRef getGnuPubNamesSection() = 0;
   virtual StringRef getGnuPubTypesSection() = 0;
 
+  // DWARF v5
+  virtual const DWARFSection &getStringOffsetSection() = 0;
+
   // Sections for DWARF5 split dwarf proposal.
   virtual const DWARFSection &getInfoDWOSection() = 0;
   virtual const TypeSectionMap &getTypesDWOSections() = 0;
   virtual StringRef getAbbrevDWOSection() = 0;
   virtual const DWARFSection &getLineDWOSection() = 0;
   virtual const DWARFSection &getLocDWOSection() = 0;
   virtual StringRef getStringDWOSection() = 0;
-  virtual StringRef getStringOffsetDWOSection() = 0;
+  virtual const DWARFSection &getStringOffsetDWOSection() = 0;
   virtual const DWARFSection &getRangeDWOSection() = 0;
   virtual StringRef getAddrSection() = 0;
   virtual const DWARFSection& getAppleNamesSection() = 0;
   virtual const DWARFSection& getAppleTypesSection() = 0;
   virtual const DWARFSection& getAppleNamespacesSection() = 0;
   virtual const DWARFSection& getAppleObjCSection() = 0;
   virtual StringRef getCUIndexSection() = 0;
   virtual StringRef getGdbIndexSection() = 0;
class DWARFContextInMemory : public DWARFContext {
   StringRef StringSection;
   DWARFSection RangeSection;
   StringRef MacinfoSection;
   StringRef PubNamesSection;
   StringRef PubTypesSection;
   StringRef GnuPubNamesSection;
   StringRef GnuPubTypesSection;
 
+  // DWARF v5
+  DWARFSection StringOffsetSection;
+
   // Sections for DWARF5 split dwarf proposal.
   DWARFSection InfoDWOSection;
   TypeSectionMap TypesDWOSections;
   StringRef AbbrevDWOSection;
   DWARFSection LineDWOSection;
   DWARFSection LocDWOSection;
   StringRef StringDWOSection;
-  StringRef StringOffsetDWOSection;
+  DWARFSection StringOffsetDWOSection;
   DWARFSection RangeDWOSection;
   StringRef AddrSection;
   DWARFSection AppleNamesSection;
   DWARFSection AppleTypesSection;
   DWARFSection AppleNamespacesSection;
   DWARFSection AppleObjCSection;
   StringRef CUIndexSection;
   StringRef GdbIndexSection;
public:
   StringRef getPubTypesSection() override { return PubTypesSection; }
   StringRef getGnuPubNamesSection() override { return GnuPubNamesSection; }
   StringRef getGnuPubTypesSection() override { return GnuPubTypesSection; }
   const DWARFSection& getAppleNamesSection() override { return AppleNamesSection; }
   const DWARFSection& getAppleTypesSection() override { return AppleTypesSection; }
   const DWARFSection& getAppleNamespacesSection() override { return AppleNamespacesSection; }
   const DWARFSection& getAppleObjCSection() override { return AppleObjCSection; }
 
+  // DWARF v5
+  const DWARFSection &getStringOffsetSection() override {
+    return StringOffsetSection;
+  }
+
   // Sections for DWARF5 split dwarf proposal.
   const DWARFSection &getInfoDWOSection() override { return InfoDWOSection; }
 
   const TypeSectionMap &getTypesDWOSections() override {
     return TypesDWOSections;
   }
 
   StringRef getAbbrevDWOSection() override { return AbbrevDWOSection; }
   const DWARFSection &getLineDWOSection() override { return LineDWOSection; }
   const DWARFSection &getLocDWOSection() override { return LocDWOSection; }
   StringRef getStringDWOSection() override { return StringDWOSection; }
 
-  StringRef getStringOffsetDWOSection() override {
+  const DWARFSection &getStringOffsetDWOSection() override {
     return StringOffsetDWOSection;
   }
 
   const DWARFSection &getRangeDWOSection() override { return RangeDWOSection; }
 
   StringRef getAddrSection() override {
     return AddrSection;
   }

include/llvm/DebugInfo/DWARF/DWARFTypeUnit.h

 class DWARFTypeUnit : public DWARFUnit {
 private:
   uint64_t TypeHash;
   uint32_t TypeOffset;
 
 public:
   DWARFTypeUnit(DWARFContext &Context, const DWARFSection &Section,
                 const DWARFDebugAbbrev *DA, const DWARFSection *RS,
-                StringRef SS, StringRef SOS, StringRef AOS, StringRef LS,
-                bool LE, bool IsDWO, const DWARFUnitSectionBase &UnitSection,
+                StringRef SS, const DWARFSection &SOS, StringRef AOS,
+                StringRef LS, bool LE, bool IsDWO,
+                const DWARFUnitSectionBase &UnitSection,
                 const DWARFUnitIndex::Entry *Entry)
       : DWARFUnit(Context, Section, DA, RS, SS, SOS, AOS, LS, LE, IsDWO,
                   UnitSection, Entry) {}
 
   uint32_t getHeaderSize() const override {
     return DWARFUnit::getHeaderSize() + 12;
   }
 

include/llvm/DebugInfo/DWARF/DWARFUnit.h

public:
   void parseDWO(DWARFContext &C, const DWARFSection &DWOSection,
                 DWARFUnitIndex *Index = nullptr);
 
 protected:
   ~DWARFUnitSectionBase() = default;
 
   virtual void parseImpl(DWARFContext &Context, const DWARFSection &Section,
                          const DWARFDebugAbbrev *DA, const DWARFSection *RS,
-                         StringRef SS, StringRef SOS, StringRef AOS,
+                         StringRef SS, const DWARFSection &SOS, StringRef AOS,
                          StringRef LS, bool isLittleEndian, bool isDWO) = 0;
 };
 
 const DWARFUnitIndex &getDWARFUnitIndex(DWARFContext &Context,
                                         DWARFSectionKind Kind);
 
 /// Concrete instance of DWARFUnitSection, specialized for one Unit type.
 template<typename UnitType>
UnitType *getUnitForOffset(uint32_t Offset) const override {
     if (CU != this->end())
       return CU->get();
     return nullptr;
   }
 
 private:
   void parseImpl(DWARFContext &Context, const DWARFSection &Section,
                  const DWARFDebugAbbrev *DA, const DWARFSection *RS,
-                 StringRef SS, StringRef SOS, StringRef AOS, StringRef LS,
-                 bool LE, bool IsDWO) override {
+                 StringRef SS, const DWARFSection &SOS, StringRef AOS,
+                 StringRef LS, bool LE, bool IsDWO) override {
     if (Parsed)
       return;
     const auto &Index = getDWARFUnitIndex(Context, UnitType::Section);
     DataExtractor Data(Section.Data, LE, 0);
     uint32_t Offset = 0;
     while (Data.isValidOffset(Offset)) {
       auto U = llvm::make_unique<UnitType>(Context, Section, DA, RS, SS, SOS,
                                            AOS, LS, LE, IsDWO, *this,
class DWARFUnit {
   // Section containing this DWARFUnit.
   const DWARFSection &InfoSection;
 
   const DWARFDebugAbbrev *Abbrev;
   const DWARFSection *RangeSection;
   uint32_t RangeSectionBase;
   StringRef LineSection;
   StringRef StringSection;
-  StringRef StringOffsetSection;
+  const DWARFSection &StringOffsetSection;
+  uint64_t StringOffsetSectionBase;
   StringRef AddrOffsetSection;
   uint32_t AddrOffsetSectionBase;
   bool isLittleEndian;
   bool isDWO;
   const DWARFUnitSectionBase &UnitSection;
 
   uint32_t Offset;
   uint32_t Length;
protected:
   virtual bool extractImpl(DataExtractor debug_info, uint32_t *offset_ptr);
 
   /// Size in bytes of the unit header.
   virtual uint32_t getHeaderSize() const { return Version <= 4 ? 11 : 12; }
 
 public:
   DWARFUnit(DWARFContext &Context, const DWARFSection &Section,
             const DWARFDebugAbbrev *DA, const DWARFSection *RS, StringRef SS,
-            StringRef SOS, StringRef AOS, StringRef LS, bool LE, bool IsDWO,
-            const DWARFUnitSectionBase &UnitSection,
+            const DWARFSection &SOS, StringRef AOS, StringRef LS, bool LE,
+            bool IsDWO, const DWARFUnitSectionBase &UnitSection,
             const DWARFUnitIndex::Entry *IndexEntry = nullptr);
 
   virtual ~DWARFUnit();
 
   DWARFContext& getContext() const { return Context; }
 
   StringRef getLineSection() const { return LineSection; }
   StringRef getStringSection() const { return StringSection; }
-  StringRef getStringOffsetSection() const { return StringOffsetSection; }
+  const DWARFSection &getStringOffsetSection() const {
+    return StringOffsetSection;
+  }
 
   void setAddrOffsetSection(StringRef AOS, uint32_t Base) {
     AddrOffsetSection = AOS;
     AddrOffsetSectionBase = Base;
   }
 
   // Recursively update address to Die map.
   void updateAddressDieMap(DWARFDie Die);
 
   void setRangesSection(const DWARFSection *RS, uint32_t Base) {
     RangeSection = RS;
     RangeSectionBase = Base;
   }
 
   bool getAddrOffsetSectionItem(uint32_t Index, uint64_t &Result) const;
   // FIXME: Result should be uint64_t in DWARF64.
-  bool getStringOffsetSectionItem(uint32_t Index, uint32_t &Result) const;
+  bool getStringOffsetSectionItem(uint32_t Index, uint64_t &Result) const;
+  uint64_t getStringOffsetSectionRelocation(uint32_t Index) const;
 
   DataExtractor getDebugInfoExtractor() const {
     return DataExtractor(InfoSection.Data, isLittleEndian, AddrSize);
   }
 
   DataExtractor getStringExtractor() const {
     return DataExtractor(StringSection, false, 0);
   }
 
   const RelocAddrMap *getRelocMap() const { return &InfoSection.Relocs; }
+  const RelocAddrMap *getStringOffsetsRelocMap() const {
+    return &StringOffsetSection.Relocs;
+  }
 
   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;

include/llvm/MC/MCObjectFileInfo.h

protected:
   // These are used for the Fission separate debug information files.
   MCSection *DwarfInfoDWOSection;
   MCSection *DwarfTypesDWOSection;
   MCSection *DwarfAbbrevDWOSection;
   MCSection *DwarfStrDWOSection;
   MCSection *DwarfLineDWOSection;
   MCSection *DwarfLocDWOSection;
   MCSection *DwarfStrOffDWOSection;
+
+  /// The DWARF v5 string offset and address table sections.
+  MCSection *DwarfStrOffSection;
   MCSection *DwarfAddrSection;
 
   // These are for Fission DWP files.
   MCSection *DwarfCUIndexSection;
   MCSection *DwarfTUIndexSection;
 
   /// Section for newer gnu pubnames.
   MCSection *DwarfGnuPubNamesSection;
public:
   MCSection *getDwarfInfoDWOSection() const { return DwarfInfoDWOSection; }
   MCSection *getDwarfTypesSection(uint64_t Hash) const;
   MCSection *getDwarfTypesDWOSection() const { return DwarfTypesDWOSection; }
   MCSection *getDwarfAbbrevDWOSection() const { return DwarfAbbrevDWOSection; }
   MCSection *getDwarfStrDWOSection() const { return DwarfStrDWOSection; }
   MCSection *getDwarfLineDWOSection() const { return DwarfLineDWOSection; }
   MCSection *getDwarfLocDWOSection() const { return DwarfLocDWOSection; }
   MCSection *getDwarfStrOffDWOSection() const { return DwarfStrOffDWOSection; }
+  MCSection *getDwarfStrOffSection() const { return DwarfStrOffSection; }
   MCSection *getDwarfAddrSection() const { return DwarfAddrSection; }
   MCSection *getDwarfCUIndexSection() const { return DwarfCUIndexSection; }
   MCSection *getDwarfTUIndexSection() const { return DwarfTUIndexSection; }
 
   MCSection *getCOFFDebugSymbolsSection() const {
     return COFFDebugSymbolsSection;
   }
   MCSection *getCOFFDebugTypesSection() const {

lib/CodeGen/AsmPrinter/DIE.cpp

void DIEInteger::EmitValue(const AsmPrinter *Asm, dwarf::Form Form) const {
   case dwarf::DW_FORM_strp_sup:
   case dwarf::DW_FORM_addr:
   case dwarf::DW_FORM_ref_addr:
     Asm->OutStreamer->EmitIntValue(Integer, SizeOf(Asm, Form));
     return;
   case dwarf::DW_FORM_GNU_str_index:
   case dwarf::DW_FORM_GNU_addr_index:
   case dwarf::DW_FORM_ref_udata:
+  case dwarf::DW_FORM_strx:
   case dwarf::DW_FORM_udata:
     Asm->EmitULEB128(Integer);
     return;
   case dwarf::DW_FORM_sdata:
     Asm->EmitSLEB128(Integer);
     return;
   default: llvm_unreachable("DIE Value form not supported yet");
   }
case dwarf::DWARF32:
       return 4;
     case dwarf::DWARF64:
       return 8;
     }
     llvm_unreachable("Invalid DWARF format");
   case dwarf::DW_FORM_GNU_str_index:
   case dwarf::DW_FORM_GNU_addr_index:
   case dwarf::DW_FORM_ref_udata:
+  case dwarf::DW_FORM_strx:
   case dwarf::DW_FORM_udata:
     return getULEB128Size(Integer);
   case dwarf::DW_FORM_sdata:
     return getSLEB128Size(Integer);
   case dwarf::DW_FORM_addr:
     return AP->getPointerSize();
   default: llvm_unreachable("DIE Value form not supported yet");
   }

 }
 
 LLVM_DUMP_METHOD
 void DIEString::print(raw_ostream &O) const {
   O << "String: " << S.getString();
 }
 
 //===----------------------------------------------------------------------===//
+// DIEIndexedString Implementation
+//===----------------------------------------------------------------------===//
+
+/// EmitValue - Emit string value.
+///
+void DIEIndexedString::EmitValue(const AsmPrinter *AP, dwarf::Form Form) const {
+  assert((Form == dwarf::DW_FORM_strx || Form == dwarf::DW_FORM_strx1 ||
+          Form == dwarf::DW_FORM_strx2 || Form == dwarf::DW_FORM_strx3 ||
+          Form == dwarf::DW_FORM_strx4) &&
+         "Expected valid indexed string form");
+  DIEInteger(getIndex()).EmitValue(AP, Form);
+}
+
+/// SizeOf - Determine size of delta value in bytes.
+///
+unsigned DIEIndexedString::SizeOf(const AsmPrinter *AP,
+                                  dwarf::Form Form) const {
+  assert((Form == dwarf::DW_FORM_strx || Form == dwarf::DW_FORM_strx1 ||
+          Form == dwarf::DW_FORM_strx2 || Form == dwarf::DW_FORM_strx3 ||
+          Form == dwarf::DW_FORM_strx4) &&
+         "Expected valid indexed string form");
+  return DIEInteger(getIndex()).SizeOf(AP, Form);
+}
+
+LLVM_DUMP_METHOD
+void DIEIndexedString::print(raw_ostream &O) const {
+  O << "IxString: Ix = " << getIndex() << " " << getString();
+}
+
+//===----------------------------------------------------------------------===//
 // DIEInlineString Implementation
 //===----------------------------------------------------------------------===//
 void DIEInlineString::EmitValue(const AsmPrinter *AP, dwarf::Form Form) const {
   if (Form == dwarf::DW_FORM_string) {
     for (char ch : S)
       AP->EmitInt8(ch);
     AP->EmitInt8(0);
     return;

lib/CodeGen/AsmPrinter/DIEHash.cpp

 #define DEBUG_TYPE "dwarfdebug"
 
 /// \brief Grabs the string in whichever attribute is passed in and returns
 /// a reference to it.
 static StringRef getDIEStringAttr(const DIE &Die, uint16_t Attr) {
   // Iterate through all the attributes until we find the one we're
   // looking for, if we can't find it return an empty string.
   for (const auto &V : Die.values())
-    if (V.getAttribute() == Attr)
+    if (V.getAttribute() == Attr) {
+      switch (V.getType()) {
+      case DIEValue::isString:
         return V.getDIEString().getString();
+      case DIEValue::isIndexedString:
+        return V.getDIEIndexedString().getString();
+      default:
+        llvm_unreachable("Unknown string value type");
+      }
+    }
 
   return StringRef("");
 }
 
 /// \brief Adds the string in \p Str to the hash. This also hashes
 /// a trailing NULL with the string.
 void DIEHash::addString(StringRef Str) {
   DEBUG(dbgs() << "Adding string " << Str << " to hash.\n");
case DIEValue::isInteger: {
     break;
   }
   case DIEValue::isString:
     addULEB128('A');
     addULEB128(Attribute);
     addULEB128(dwarf::DW_FORM_string);
     addString(Value.getDIEString().getString());
     break;
+  case DIEValue::isIndexedString:
+    addULEB128('A');
+    addULEB128(Attribute);
+    addULEB128(dwarf::DW_FORM_string);
+    addString(Value.getDIEIndexedString().getString());
+    break;
   case DIEValue::isInlineString:
     addULEB128('A');
     addULEB128(Attribute);
     addULEB128(dwarf::DW_FORM_string);
     addString(Value.getDIEInlineString().getString());
     break;
   case DIEValue::isBlock:
   case DIEValue::isLoc:

lib/CodeGen/AsmPrinter/DwarfCompileUnit.h

public:
   void addLabelAddress(DIE &Die, dwarf::Attribute Attribute,
                        const MCSymbol *Label);
 
   /// addLocalLabelAddress - Add a dwarf label attribute data and value using
   /// DW_FORM_addr only.
   void addLocalLabelAddress(DIE &Die, dwarf::Attribute Attribute,
                             const MCSymbol *Label);
 
-  /// addSectionDelta - Add a label delta attribute data and value.
-  DIE::value_iterator addSectionDelta(DIE &Die, dwarf::Attribute Attribute,
-                                      const MCSymbol *Hi, const MCSymbol *Lo);
-
   DwarfCompileUnit &getCU() override { return *this; }
 
   unsigned getOrCreateSourceID(StringRef FileName, StringRef DirName) override;
 
   void addImportedEntity(const DIImportedEntity* IE) {
     DIScope *Scope = IE->getScope();
     assert(Scope && "Invalid Scope encoding!");
     if (!isa<DILocalScope>(Scope))
       // No need to add imported enities that are not local declaration.
       return;
 
     auto *LocalScope = cast<DILocalScope>(Scope)->getNonLexicalBlockFileScope();
     ImportedEntities[LocalScope].push_back(IE);
   }
 
   /// addRange - Add an address range to the list of ranges for this unit.
   void addRange(RangeSpan Range);
 
   void attachLowHighPC(DIE &D, const MCSymbol *Begin, const MCSymbol *End);
 
-  /// addSectionLabel - Add a Dwarf section label attribute data and value.
-  ///
-  DIE::value_iterator addSectionLabel(DIE &Die, dwarf::Attribute Attribute,
-                                      const MCSymbol *Label,
-                                      const MCSymbol *Sec);
-
   /// \brief Find DIE for the given subprogram and attach appropriate
   /// DW_AT_low_pc and DW_AT_high_pc attributes. If there are global
   /// variables in this scope then create and insert DIEs for these
   /// variables.
   DIE &updateSubprogramScopeDIE(const DISubprogram *SP);
 
   void constructScopeDIE(LexicalScope *Scope,
                          SmallVectorImpl<DIE *> &FinalChildren);

lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

if (CURanges.empty() || !SameAsPrevCU ||
        &Range.getEnd()->getSection())) {
     CURanges.push_back(Range);
     return;
   }
 
   CURanges.back().setEnd(Range.getEnd());
 }
 
-DIE::value_iterator
-DwarfCompileUnit::addSectionLabel(DIE &Die, dwarf::Attribute Attribute,
-                                  const MCSymbol *Label, const MCSymbol *Sec) {
-  if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
-    return addLabel(Die, Attribute,
-                    DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset
-                                               : dwarf::DW_FORM_data4,
-                    Label);
-  return addSectionDelta(Die, Attribute, Label, Sec);
-}
-
 void DwarfCompileUnit::initStmtList() {
   // Define start line table label for each Compile Unit.
   MCSymbol *LineTableStartSym =
       Asm->OutStreamer->getDwarfLineTableSymbol(getUniqueID());
 
   // DW_AT_stmt_list is a offset of line number information for this
   // compile unit in debug_line section. For split dwarf this is
   // left in the skeleton CU and so not included.
void DwarfCompileUnit::constructScopeDIE(
 
   // Add children
   for (auto &I : Children)
     ScopeDIE->addChild(std::move(I));
 
   FinalChildren.push_back(std::move(ScopeDIE));
 }
 
-DIE::value_iterator
-DwarfCompileUnit::addSectionDelta(DIE &Die, dwarf::Attribute Attribute,
-                                  const MCSymbol *Hi, const MCSymbol *Lo) {
-  return Die.addValue(DIEValueAllocator, Attribute,
-                      DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset
-                                                 : dwarf::DW_FORM_data4,
-                      new (DIEValueAllocator) DIEDelta(Hi, Lo));
-}
-
 void DwarfCompileUnit::addScopeRangeList(DIE &ScopeDIE,
                                          SmallVector<RangeSpan, 2> Range) {
   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
 
   // Emit offset in .debug_range as a relocatable label. emitDIE will handle
   // emitting it appropriately.
   const MCSymbol *RangeSectionSym =
       TLOF.getDwarfRangesSection()->getBeginSymbol();

lib/CodeGen/AsmPrinter/DwarfDebug.h

class DwarfDebug : public DebugHandlerBase {
   bool UseAllLinkageNames;
 
   /// DWARF5 Experimental Options
   /// @{
   bool HasDwarfAccelTables;
   bool HasAppleExtensionAttributes;
   bool HasSplitDwarf;
 
+  /// Whether to use the DWARF v5 string offsets table.
+  bool UseSegmentedStringOffsetsTable;
+
   /// Separated Dwarf Variables
   /// In general these will all be for bits that are left in the
   /// original object file, rather than things that are meant
   /// to be in the .dwo sections.
 
   /// Holder for the skeleton information.
   DwarfFile SkeletonHolder;
 
public:
   bool useAppleExtensionAttributes() const {
     return HasAppleExtensionAttributes;
   }
 
   /// Returns whether or not to change the current debug info for the
   /// split dwarf proposal support.
   bool useSplitDwarf() const { return HasSplitDwarf; }
 
+  /// Returns whether to generate a string offsets table with contributions from
+  /// each CU and type unit. This implies the use of DW_FORM_strx* indirect
+  /// references with DWARF v5 and beyond. Note that DW_FORM_GNU_str_index is
+  /// also an indirect reference, but it is used with a pre-DWARF v5
+  /// implementation of split DWARF sections, which uses a monolithic string
+  /// offsets table.
+  bool useSegmentedStringOffsetsTable() const {
+    return UseSegmentedStringOffsetsTable;
+  }
+
   /// Returns the Dwarf Version.
   uint16_t getDwarfVersion() const;
 
   /// Returns the previous CU that was being updated
   const DwarfCompileUnit *getPrevCU() const { return PrevCU; }
   void setPrevCU(const DwarfCompileUnit *PrevCU) { this->PrevCU = PrevCU; }
 
   /// Returns the entries for the .debug_loc section.

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
   // is defined as of DWARF 3.
   // See GDB bug 11616 - DW_OP_form_tls_address is unimplemented
   // https://sourceware.org/bugzilla/show_bug.cgi?id=11616
   UseGNUTLSOpcode = tuneForGDB() || DwarfVersion < 3;
 
   // GDB does not fully support the DWARF 4 representation for bitfields.
   UseDWARF2Bitfields = (DwarfVersion < 4) || tuneForGDB();
 
+  // The DWARF v5 string offsets table has contributions from each compile
+  // and type unit each preceded by a header. The string offsets
+  // table used by the pre-DWARF v5 split-DWARF implementation uses
+  // a monolithic string offsets table without any header.
+  // FIXME: Enable the string offsets table for Mach-O
+  UseSegmentedStringOffsetsTable = (DwarfVersion >= 5 && !IsDarwin);
+
   Asm->OutStreamer->getContext().setDwarfVersion(DwarfVersion);
 }
 
 // Define out of line so we don't have to include DwarfUnit.h in DwarfDebug.h.
 DwarfDebug::~DwarfDebug() { }
 
 static bool isObjCClass(StringRef Name) {
   return Name.startswith("+") || Name.startswith("-");
if (!Flags.empty()) {
     NewCU.addString(Die, dwarf::DW_AT_producer, ProducerWithFlags);
   } else
     NewCU.addString(Die, dwarf::DW_AT_producer, Producer);
 
   NewCU.addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
                 DIUnit->getSourceLanguage());
   NewCU.addString(Die, dwarf::DW_AT_name, FN);
 
+  if (useSegmentedStringOffsetsTable())
+    NewCU.initStringOffsetsSegment();
+
   if (!useSplitDwarf()) {
     NewCU.initStmtList();
 
     // If we're using split dwarf the compilation dir is going to be in the
     // skeleton CU and so we don't need to duplicate it here.
     if (!CompilationDir.empty())
       NewCU.addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
 
DwarfCompileUnit &DwarfDebug::constructSkeletonCU(const DwarfCompileUnit &CU) {
 
   auto OwnedUnit = make_unique<DwarfCompileUnit>(
       CU.getUniqueID(), CU.getCUNode(), Asm, this, &SkeletonHolder);
   DwarfCompileUnit &NewCU = *OwnedUnit;
   NewCU.setSection(Asm->getObjFileLowering().getDwarfInfoSection());
 
   NewCU.initStmtList();
 
+  if (useSegmentedStringOffsetsTable())
+    NewCU.initStringOffsetsSegment();
+
   initSkeletonUnit(CU, NewCU.getUnitDie(), std::move(OwnedUnit));
 
   return NewCU;
 }
 
 // Emit the .debug_info.dwo section for separated dwarf. This contains the
 // compile units that would normally be in debug_info.
 void DwarfDebug::emitDebugInfoDWO() {
void DwarfDebug::emitDebugLineDWO() {
   SplitTypeUnitFileTable.Emit(*Asm->OutStreamer, MCDwarfLineTableParams());
 }
 
 // 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() {
   assert(useSplitDwarf() && "No split dwarf?");
+  if (useSegmentedStringOffsetsTable()) {
+    InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection());
+  } else {
     MCSection *OffSec = Asm->getObjFileLowering().getDwarfStrOffDWOSection();
     InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
                            OffSec);
   }
+}
 
 MCDwarfDwoLineTable *DwarfDebug::getDwoLineTable(const DwarfCompileUnit &CU) {
   if (!useSplitDwarf())
     return nullptr;
   if (SingleCU)
     SplitTypeUnitFileTable.setCompilationDir(CU.getCUNode()->getDirectory());
   return &SplitTypeUnitFileTable;
 }
void DwarfDebug::addDwarfTypeUnitType(DwarfCompileUnit &CU,
 
   if (useSplitDwarf())
     NewTU.setSection(Asm->getObjFileLowering().getDwarfTypesDWOSection());
   else {
     CU.applyStmtList(UnitDie);
     NewTU.setSection(Asm->getObjFileLowering().getDwarfTypesSection(Signature));
   }
 
+  if (useSegmentedStringOffsetsTable())
+    NewTU.initStringOffsetsSegment();
+
   NewTU.setType(NewTU.createTypeDIE(CTy));
 
   if (TopLevelType) {
     auto TypeUnitsToAdd = std::move(TypeUnitsUnderConstruction);
     TypeUnitsUnderConstruction.clear();
 
     // Types referencing entries in the address table cannot be placed in type
     // units.

lib/CodeGen/AsmPrinter/DwarfFile.cpp

 void DwarfFile::emitUnit(DwarfUnit *TheU, bool UseOffsets) {
   DIE &Die = TheU->getUnitDie();
   MCSection *USection = TheU->getSection();
   Asm->OutStreamer->SwitchSection(USection);
 
   TheU->emitHeader(UseOffsets);
 
   Asm->emitDwarfDIE(Die);
+
+  // Emit the unit's contribution to the string offsets table.
+  if (TheU->useSegmentedStringOffsetsTable()) {
+    TheU->emitStringOffsets();
+  }
 }
 
 // Compute the size and offset for each DIE.
 void DwarfFile::computeSizeAndOffsets() {
   // 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

lib/CodeGen/AsmPrinter/DwarfUnit.h

 
 #ifndef LLVM_LIB_CODEGEN_ASMPRINTER_DWARFUNIT_H
 #define LLVM_LIB_CODEGEN_ASMPRINTER_DWARFUNIT_H
 
 #include "DwarfDebug.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringMap.h"
+#include "llvm/ADT/UniqueVector.h"
 #include "llvm/CodeGen/AsmPrinter.h"
 #include "llvm/CodeGen/DIE.h"
 #include "llvm/IR/DIBuilder.h"
 #include "llvm/IR/DebugInfo.h"
 #include "llvm/MC/MCDwarf.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCSection.h"
 
protected:
   /// A list of all the DIELocs in use.
   std::vector<DIELoc *> DIELocs;
 
   /// This map is used to keep track of subprogram DIEs that need
   /// DW_AT_containing_type attribute. This attribute points to a DIE that
   /// corresponds to the MDNode mapped with the subprogram DIE.
   DenseMap<DIE *, const DINode *> ContainingTypeMap;
 
+  /// DWARF v5: Keep track of strings that are referenced by this unit, so
+  /// we can build its contribution to the string offsets table.
+  UniqueVector<DwarfStringPoolEntryRef> Strings;
+
+  /// DWARF v5: The symbol at the start of the unit's contribution to the string
+  /// offsets table.
+  MCSymbol *StringOffsetsStartSym;
+
   DwarfUnit(dwarf::Tag, const DICompileUnit *CU, AsmPrinter *A, DwarfDebug *DW,
             DwarfFile *DWU);
 
   bool applySubprogramDefinitionAttributes(const DISubprogram *SP, DIE &SPDie);
 
 public:
   // Accessors.
   AsmPrinter* getAsmPrinter() const { return Asm; }
public:
 
   /// Construct function argument DIEs.
   void constructSubprogramArguments(DIE &Buffer, DITypeRefArray Args);
 
   /// Create a DIE with the given Tag, add the DIE to its parent, and
   /// call insertDIE if MD is not null.
   DIE &createAndAddDIE(unsigned Tag, DIE &Parent, const DINode *N = nullptr);
 
+  const UniqueVector<DwarfStringPoolEntryRef> &getStrings() const {
+    return Strings;
+  }
+
+  bool useSegmentedStringOffsetsTable() const {
+    return DD->useSegmentedStringOffsetsTable();
+  }
+
   /// Compute the size of a header for this unit, not including the initial
   /// length field.
   virtual unsigned getHeaderSize() const {
     return sizeof(int16_t) + // DWARF version number
            sizeof(int32_t) + // Offset Into Abbrev. Section
            sizeof(int8_t) +  // Pointer Size (in bytes)
            (DD->getDwarfVersion() >= 5 ? sizeof(int8_t)
                                        : 0); // DWARF v5 unit type
   }
 
   /// Emit the header for this unit, not including the initial length field.
   virtual void emitHeader(bool UseOffsets) = 0;
 
+  /// Prepare the unit's contribution to the string offsets section.
+  void initStringOffsetsSegment();
+
+  void emitStringOffsets();
+
   virtual DwarfCompileUnit &getCU() = 0;
 
   void constructTypeDIE(DIE &Buffer, const DICompositeType *CTy);
 
+  /// addSectionDelta - Add a label delta attribute data and value.
+  DIE::value_iterator addSectionDelta(DIE &Die, dwarf::Attribute Attribute,
+                                      const MCSymbol *Hi, const MCSymbol *Lo);
+
+  /// addSectionLabel - Add a Dwarf section label attribute data and value.
+  ///
+  DIE::value_iterator addSectionLabel(DIE &Die, dwarf::Attribute Attribute,
+                                      const MCSymbol *Label,
+                                      const MCSymbol *Sec);
+
 protected:
   ~DwarfUnit();
 
   /// Create new static data member DIE.
   DIE *getOrCreateStaticMemberDIE(const DIDerivedType *DT);
 
   /// Look up the source ID with the given directory and source file names. If
   /// none currently exists, create a new ID and insert it in the line table.

lib/CodeGen/AsmPrinter/DwarfUnit.cpp

 
 #include "DwarfUnit.h"
 #include "AddressPool.h"
 #include "DwarfCompileUnit.h"
 #include "DwarfDebug.h"
 #include "DwarfExpression.h"
 #include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/APInt.h"
-#include "llvm/ADT/iterator_range.h"
 #include "llvm/ADT/None.h"
+#include "llvm/ADT/iterator_range.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineOperand.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/GlobalValue.h"
 #include "llvm/IR/Metadata.h"
-#include "llvm/MC/MachineLocation.h"
 #include "llvm/MC/MCAsmInfo.h"
+#include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCDwarf.h"
 #include "llvm/MC/MCSection.h"
 #include "llvm/MC/MCStreamer.h"
+#include "llvm/MC/MachineLocation.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Target/TargetLoweringObjectFile.h"
 #include "llvm/Target/TargetRegisterInfo.h"
 #include "llvm/Target/TargetSubtargetInfo.h"
 #include <cassert>
 #include <cstdint>
 #include <string>

 bool DIEDwarfExpression::isFrameRegister(const TargetRegisterInfo &TRI,
                                          unsigned MachineReg) {
   return MachineReg == TRI.getFrameRegister(*AP.MF);
 }
 
 DwarfUnit::DwarfUnit(dwarf::Tag UnitTag, const DICompileUnit *Node,
                      AsmPrinter *A, DwarfDebug *DW, DwarfFile *DWU)
     : DIEUnit(A->getDwarfVersion(), A->MAI->getCodePointerSize(), UnitTag),
-      CUNode(Node), Asm(A), DD(DW), DU(DWU), IndexTyDie(nullptr) {
-}
+      CUNode(Node), Asm(A), DD(DW), DU(DWU), IndexTyDie(nullptr),
+      StringOffsetsStartSym(nullptr) {}
 
 DwarfTypeUnit::DwarfTypeUnit(DwarfCompileUnit &CU, AsmPrinter *A,
                              DwarfDebug *DW, DwarfFile *DWU,
                              MCDwarfDwoLineTable *SplitLineTable)
     : DwarfUnit(dwarf::DW_TAG_type_unit, CU.getCUNode(), A, DW, DWU), CU(CU),
       SplitLineTable(SplitLineTable) {
   if (SplitLineTable)
     addSectionOffset(getUnitDie(), dwarf::DW_AT_stmt_list, 0);

 
 void DwarfUnit::addSInt(DIELoc &Die, Optional<dwarf::Form> Form,
                         int64_t Integer) {
   addSInt(Die, (dwarf::Attribute)0, Form, Integer);
 }
 
 void DwarfUnit::addString(DIE &Die, dwarf::Attribute Attribute,
                           StringRef String) {
+  auto StringPoolEntry = DU->getStringPool().getEntry(*Asm, String);
+  if (useSegmentedStringOffsetsTable()) {
+    // FIXME: Use DW_FORM_strx{1,2,3,4}
+    unsigned Index = Strings.insert(StringPoolEntry) - 1;
+    Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_strx,
+                 new (DIEValueAllocator)
+                     DIEIndexedString(StringPoolEntry, Index));
+  } else {
     Die.addValue(DIEValueAllocator, Attribute,
-               isDwoUnit() ? dwarf::DW_FORM_GNU_str_index : dwarf::DW_FORM_strp,
-               DIEString(DU->getStringPool().getEntry(*Asm, String)));
+                 isDwoUnit() ? dwarf::DW_FORM_GNU_str_index
+                             : dwarf::DW_FORM_strp,
+                 DIEString(StringPoolEntry));
+  }
 }
 
 DIEValueList::value_iterator DwarfUnit::addLabel(DIEValueList &Die,
                                                  dwarf::Attribute Attribute,
                                                  dwarf::Form Form,
                                                  const MCSymbol *Label) {
   return Die.addValue(DIEValueAllocator, Attribute, Form, DIELabel(Label));
 }
Asm->emitDwarfSymbolReference(
         TLOF.getDwarfAbbrevSection()->getBeginSymbol(), false);
 
   if (Version <= 4) {
     Asm->OutStreamer->AddComment("Address Size (in bytes)");
     Asm->EmitInt8(Asm->MAI->getCodePointerSize());
   }
 }
 
+// Emit the unit's contribution to the string offsets table.
+void DwarfUnit::emitStringOffsets() {
+  assert(StringOffsetsStartSym && "No Start symbol for string offset segment");
+  const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
+  MCSection *StrOffSection = isDwoUnit() ? TLOF.getDwarfStrOffDWOSection()
+                                         : TLOF.getDwarfStrOffSection();
+  Asm->OutStreamer->SwitchSection(StrOffSection);
+  unsigned EntrySize = 4;
+  // TODO: DWARF64
+  // The header for the contribution contains the size of the contribution
+  // (not including the header) and the DWARF version.
+  Asm->EmitInt32(Strings.size() * EntrySize);
+  Asm->EmitInt16(Asm->getDwarfVersion());
+  Asm->EmitInt16(0);
+  // Define the symbol that marks the start of the contribution and is
+  // referenced by the unit header (DW_AT_str_offsets_base).
+  Asm->OutStreamer->EmitLabel(StringOffsetsStartSym);
+  for (const auto &Entry : Strings)
+    if (isDwoUnit())
+      Asm->OutStreamer->EmitIntValue(Entry.getOffset(), EntrySize);
+    else
+      Asm->EmitLabelReference(Entry.getSymbol(), EntrySize, true);
+}
+
 void DwarfTypeUnit::emitHeader(bool UseOffsets) {
   DwarfUnit::emitCommonHeader(UseOffsets, 
                               DD->useSplitDwarf() ? dwarf::DW_UT_split_type
                                                   : dwarf::DW_UT_type);
   Asm->OutStreamer->AddComment("Type Signature");
   Asm->OutStreamer->EmitIntValue(TypeSignature, sizeof(TypeSignature));
   Asm->OutStreamer->AddComment("Type DIE Offset");
   // In a skeleton type unit there is no type DIE so emit a zero offset.

 
 const MCSymbol *DwarfUnit::getCrossSectionRelativeBaseAddress() const {
   if (!Asm->MAI->doesDwarfUseRelocationsAcrossSections())
     return nullptr;
   if (isDwoUnit())
     return nullptr;
   return getSection()->getBeginSymbol();
 }
+
+DIE::value_iterator DwarfUnit::addSectionDelta(DIE &Die,
+                                               dwarf::Attribute Attribute,
+                                               const MCSymbol *Hi,
+                                               const MCSymbol *Lo) {
+  return Die.addValue(DIEValueAllocator, Attribute,
+                      DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset
+                                                 : dwarf::DW_FORM_data4,
+                      new (DIEValueAllocator) DIEDelta(Hi, Lo));
+}
+
+DIE::value_iterator DwarfUnit::addSectionLabel(DIE &Die,
+                                               dwarf::Attribute Attribute,
+                                               const MCSymbol *Label,
+                                               const MCSymbol *Sec) {
+  if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
+    return addLabel(Die, Attribute,
+                    DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset
+                                               : dwarf::DW_FORM_data4,
+                    Label);
+  return addSectionDelta(Die, Attribute, Label, Sec);
+}
+
+/// DWARF v5: Create the symbol that designates the start of the string offset
+/// table for this unit and add a reference to it to the unit DIE.
+void DwarfUnit::initStringOffsetsSegment() {
+  StringOffsetsStartSym = Asm->createTempSymbol("str_offsets_base");
+  const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
+  if (isDwoUnit())
+    addSectionDelta(getUnitDie(), dwarf::DW_AT_str_offsets_base,
+                    StringOffsetsStartSym,
+                    TLOF.getDwarfStrOffDWOSection()->getBeginSymbol());
+  else
+    addSectionLabel(getUnitDie(), dwarf::DW_AT_str_offsets_base,
+                    StringOffsetsStartSym,
+                    TLOF.getDwarfStrOffSection()->getBeginSymbol());
+}

lib/DebugInfo/DWARF/DWARFContext.cpp

static void dumpAccelSection(raw_ostream &OS, StringRef Name,
   DataExtractor StrData(StringSection, LittleEndian, 0);
   OS << "\n." << Name << " contents:\n";
   DWARFAcceleratorTable Accel(AccelSection, StrData, Section.Relocs);
   if (!Accel.extract())
     return;
   Accel.dump(OS);
 }
 
+// Dump the DWARF v5 string offsets section. It consists of per-unit
+// contributions (segments) of string offsets, each preceded by a header
+// describing its size.
+static void dumpStringOffsetsSection(raw_ostream &OS, StringRef SectionName,
+                                     const DWARFSection &Section,
+                                     bool LittleEndian) {
+  if (Section.Data.empty())
+    return;
+  OS << "\n." << SectionName << " contents:\n";
+  DataExtractor StrOffsetExt(Section.Data, LittleEndian, 0);
+  uint32_t Offset = 0;
+  uint64_t SectionSize = Section.Data.size();
+
+  while (Offset < SectionSize) {
+    unsigned Version = 0;
+    DwarfFormat Format = DWARF32;
+    // Perform validation and extract the segment size from the header.
+    if (!StrOffsetExt.isValidOffsetForDataOfSize(Offset, 4))
+      return;
+    uint32_t SegmentStart = Offset;
+    uint64_t SegmentSize = StrOffsetExt.getU32(&Offset);
+    if (SegmentSize > 0xfffffff0 && SegmentSize < 0xffffffff)
+      return;
+    else if (SegmentSize == 0xffffffff) {
+      if (!StrOffsetExt.isValidOffsetForDataOfSize(Offset, 8))
+        return;
+      Format = DWARF64;
+      SegmentSize = StrOffsetExt.getU64(&Offset);
+    }
+    // Before we start dumping the actual string offsets, we're expecting a
+    // version number and padding (a total of 4 bytes), so we validate for
+    // SegmentSize + 4.
+    if (!StrOffsetExt.isValidOffsetForDataOfSize(Offset, SegmentSize + 4))
+      return;
+
+    Version = StrOffsetExt.getU16(&Offset);
+    Offset += 2;
+    OS << format("0x%8.8x: ", SegmentStart);
+    OS << "Segment size = " << SegmentSize << ", Version = " << Version << "\n";
+
+    uint32_t SegmentBase = Offset;
+    while (Offset - SegmentBase < SegmentSize) {
+      uint64_t StringOffset = 0;
+      RelocAddrMap::const_iterator AI = Section.Relocs.find(Offset);
+      if (AI != Section.Relocs.end())
+        StringOffset += AI->second.second;
+      OS << format("0x%8.8x: ", Offset);
+      if (Format == DWARF32) {
+        StringOffset += StrOffsetExt.getU32(&Offset);
+        OS << format("%8.8x\n", StringOffset);
+      } else {
+        StringOffset += StrOffsetExt.getU64(&Offset);
+        OS << format("%16.16x\n", StringOffset);
+      }
+    }
+  }
+}
+
 void DWARFContext::dump(raw_ostream &OS, DIDumpType DumpType, bool DumpEH,
                         bool SummarizeTypes) {
   if (DumpType == DIDT_All || DumpType == DIDT_Abbrev) {
     OS << ".debug_abbrev contents:\n";
     getDebugAbbrev()->dump(OS);
   }
 
   if (DumpType == DIDT_All || DumpType == DIDT_AbbrevDwo)
DWARFDebugPubTable(getGnuPubNamesSection(), isLittleEndian(),
                        true /* GnuStyle */)
         .dump("debug_gnu_pubnames", OS);
 
   if (DumpType == DIDT_All || DumpType == DIDT_GnuPubtypes)
     DWARFDebugPubTable(getGnuPubTypesSection(), isLittleEndian(),
                        true /* GnuStyle */)
         .dump("debug_gnu_pubtypes", OS);
 
-  if ((DumpType == DIDT_All || DumpType == DIDT_StrOffsetsDwo) &&
-      !getStringOffsetDWOSection().empty()) {
+  if (DumpType == DIDT_All || DumpType == DIDT_StrOffsets)
+    dumpStringOffsetsSection(OS, "debug_str_offsets", getStringOffsetSection(),
+                             isLittleEndian());
+
+  if (DumpType == DIDT_All || DumpType == DIDT_StrOffsetsDwo) {
+    // If we have at least one unit with DWARF Version 5 or greater, we assume
+    // that the DWO string offsets section is formatted like the regular string
+    // offsets section, i.e. a series of contributions by compile and type
+    // units, each preceded by a header. Otherwise, we treat it as a monolithic
+    // sequence of string offsets.
+    if (getMaxVersion() >= 5)
+      dumpStringOffsetsSection(OS, "debug_str_offsets.dwo",
+                               getStringOffsetDWOSection(), isLittleEndian());
+    else if (!getStringOffsetDWOSection().Data.empty()) {
       OS << "\n.debug_str_offsets.dwo contents:\n";
-    DataExtractor strOffsetExt(getStringOffsetDWOSection(), isLittleEndian(),
-                               0);
+      DataExtractor strOffsetExt(getStringOffsetDWOSection().Data,
+                                 isLittleEndian(), 0);
       offset = 0;
-    uint64_t size = getStringOffsetDWOSection().size();
+      uint64_t size = getStringOffsetDWOSection().Data.size();
       while (offset < size) {
         OS << format("0x%8.8x: ", offset);
         OS << format("%8.8x\n", strOffsetExt.getU32(&offset));
       }
     }
+  }
 
   if ((DumpType == DIDT_All || DumpType == DIDT_GdbIndex) &&
       !getGdbIndexSection().empty()) {
     OS << "\n.gnu_index contents:\n";
     getGdbIndex().dump(OS);
   }
 
   if (DumpType == DIDT_All || DumpType == DIDT_AppleNames)
for (const SectionRef &Section : Obj.sections()) {
     if (!L && isa<MachOObjectFile>(&Obj))
       continue;
 
     RelSecName = RelSecName.substr(
         RelSecName.find_first_not_of("._")); // Skip . and _ prefixes.
 
     // TODO: Add support for relocations in other sections as needed.
     // Record relocations for the debug_info and debug_line sections.
-    RelocAddrMap *Map = StringSwitch<RelocAddrMap*>(RelSecName)
+    RelocAddrMap *Map =
+        StringSwitch<RelocAddrMap *>(RelSecName)
             .Case("debug_info", &InfoSection.Relocs)
             .Case("debug_loc", &LocSection.Relocs)
             .Case("debug_info.dwo", &InfoDWOSection.Relocs)
             .Case("debug_line", &LineSection.Relocs)
+            .Case("debug_str_offsets", &StringOffsetSection.Relocs)
             .Case("debug_ranges", &RangeSection.Relocs)
             .Case("apple_names", &AppleNamesSection.Relocs)
             .Case("apple_types", &AppleTypesSection.Relocs)
             .Case("apple_namespaces", &AppleNamespacesSection.Relocs)
             .Case("apple_namespac", &AppleNamespacesSection.Relocs)
             .Case("apple_objc", &AppleObjCSection.Relocs)
             .Default(nullptr);
     if (!Map) {
       // Find debug_types relocs by section rather than name as there are
       // multiple, comdat grouped, debug_types sections.
       if (RelSecName == "debug_types")
         Map = &TypesSections[*RelocatedSection].Relocs;
       else if (RelSecName == "debug_types.dwo")
         Map = &TypesDWOSections[*RelocatedSection].Relocs;
       else
return StringSwitch<StringRef *>(Name)
       .Case("debug_info", &InfoSection.Data)
       .Case("debug_abbrev", &AbbrevSection)
       .Case("debug_loc", &LocSection.Data)
       .Case("debug_line", &LineSection.Data)
       .Case("debug_aranges", &ARangeSection)
       .Case("debug_frame", &DebugFrameSection)
       .Case("eh_frame", &EHFrameSection)
       .Case("debug_str", &StringSection)
+      .Case("debug_str_offsets", &StringOffsetSection.Data)
       .Case("debug_ranges", &RangeSection.Data)
       .Case("debug_macinfo", &MacinfoSection)
       .Case("debug_pubnames", &PubNamesSection)
       .Case("debug_pubtypes", &PubTypesSection)
       .Case("debug_gnu_pubnames", &GnuPubNamesSection)
       .Case("debug_gnu_pubtypes", &GnuPubTypesSection)
       .Case("debug_info.dwo", &InfoDWOSection.Data)
       .Case("debug_abbrev.dwo", &AbbrevDWOSection)
       .Case("debug_loc.dwo", &LocDWOSection.Data)
       .Case("debug_line.dwo", &LineDWOSection.Data)
       .Case("debug_str.dwo", &StringDWOSection)
-      .Case("debug_str_offsets.dwo", &StringOffsetDWOSection)
+      .Case("debug_str_offsets.dwo", &StringOffsetDWOSection.Data)
       .Case("debug_addr", &AddrSection)
       .Case("apple_names", &AppleNamesSection.Data)
       .Case("apple_types", &AppleTypesSection.Data)
       .Case("apple_namespaces", &AppleNamespacesSection.Data)
       .Case("apple_namespac", &AppleNamespacesSection.Data)
       .Case("apple_objc", &AppleObjCSection.Data)
       .Case("debug_cu_index", &CUIndexSection)
       .Case("debug_tu_index", &TUIndexSection)
       .Case("gdb_index", &GdbIndexSection)
       // Any more debug info sections go here.
       .Default(nullptr);
 }
 
 void DWARFContextInMemory::anchor() {}

lib/DebugInfo/DWARF/DWARFFormValue.cpp

bool DWARFFormValue::isFormClass(DWARFFormValue::FormClass FC) const {
   switch (Form) {
   case DW_FORM_ref_sig8:
   case DW_FORM_GNU_ref_alt:
     return (FC == FC_Reference);
   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:
     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
do {
     case DW_FORM_flag_present:
       Value.uval = 1;
       break;
     case DW_FORM_ref_sig8:
       Value.uval = data.getU64(offset_ptr);
       break;
     case DW_FORM_GNU_addr_index:
     case DW_FORM_GNU_str_index:
+    case DW_FORM_strx:
       Value.uval = data.getULEB128(offset_ptr);
       break;
     default:
       // DWARFFormValue::skipValue() will have caught this and caused all
       // DWARF DIEs to fail to be parsed, so this code is not be reachable.
       llvm_unreachable("unsupported form");
     }
   } while (indirect);
case DW_FORM_block4:
     break;
 
   case DW_FORM_sdata:     OS << Value.sval; break;
   case DW_FORM_udata:     OS << Value.uval; break;
   case DW_FORM_strp:
     OS << format(" .debug_str[0x%8.8x] = ", (uint32_t)uvalue);
     dumpString(OS);
     break;
+  case DW_FORM_strx:
   case DW_FORM_GNU_str_index:
     OS << format(" indexed (%8.8x) string = ", (uint32_t)uvalue);
     dumpString(OS);
     break;
   case DW_FORM_GNU_strp_alt:
     OS << format("alt indirect string, offset: 0x%" PRIx64 "", uvalue);
     dumpString(OS);
     break;
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_GNU_str_index) {
-    uint32_t StrOffset;
+  if (Form == DW_FORM_GNU_str_index || Form == DW_FORM_strx) {
+    uint64_t StrOffset;
     if (!U->getStringOffsetSectionItem(Offset, StrOffset))
       return None;
+    StrOffset += U->getStringOffsetSectionRelocation(Offset);
     Offset = StrOffset;
   }
   if (const char *Str = U->getStringExtractor().getCStr(&Offset)) {
     return Str;
   }
   return None;
 }
 

lib/DebugInfo/DWARF/DWARFTypeUnit.cpp

 using namespace llvm;
 
 bool DWARFTypeUnit::extractImpl(DataExtractor debug_info,
                                 uint32_t *offset_ptr) {
   if (!DWARFUnit::extractImpl(debug_info, offset_ptr))
     return false;
   TypeHash = debug_info.getU64(offset_ptr);
   TypeOffset = debug_info.getU32(offset_ptr);
-  return TypeOffset < getLength();
+  // TypeOffset is relative to the beginning of the header,
+  // so we have to account for the leading length field.
+  unsigned SizeOfLength = getFormat() == dwarf::DwarfFormat::DWARF64 ? 12 : 4;
+  return TypeOffset < getLength() + SizeOfLength;
 }
 
 void DWARFTypeUnit::dump(raw_ostream &OS, bool SummarizeTypes) {
   DWARFDie TD = getDIEForOffset(TypeOffset + getOffset());
   const char *Name = TD.getName(DINameKind::ShortName);
 
   if (SummarizeTypes) {
     OS << "name = '" << Name << "'"

lib/DebugInfo/DWARF/DWARFUnit.cpp

 #include <cstdio>
 #include <vector>
 
 using namespace llvm;
 using namespace dwarf;
 
 void DWARFUnitSectionBase::parse(DWARFContext &C, const DWARFSection &Section) {
   parseImpl(C, Section, C.getDebugAbbrev(), &C.getRangeSection(),
-            C.getStringSection(), StringRef(), C.getAddrSection(),
-            C.getLineSection().Data, C.isLittleEndian(), false);
+            C.getStringSection(), C.getStringOffsetSection(),
+            C.getAddrSection(), C.getLineSection().Data, C.isLittleEndian(),
+            false);
 }
 
 void DWARFUnitSectionBase::parseDWO(DWARFContext &C,
                                     const DWARFSection &DWOSection,
                                     DWARFUnitIndex *Index) {
   parseImpl(C, DWOSection, C.getDebugAbbrevDWO(), &C.getRangeDWOSection(),
             C.getStringDWOSection(), C.getStringOffsetDWOSection(),
             C.getAddrSection(), C.getLineDWOSection().Data, C.isLittleEndian(),
             true);
 }
 
 DWARFUnit::DWARFUnit(DWARFContext &DC, const DWARFSection &Section,
                      const DWARFDebugAbbrev *DA, const DWARFSection *RS,
-                     StringRef SS, StringRef SOS, StringRef AOS, StringRef LS,
-                     bool LE, bool IsDWO,
+                     StringRef SS, const DWARFSection &SOS, StringRef AOS,
+                     StringRef LS, bool LE, bool IsDWO,
                      const DWARFUnitSectionBase &UnitSection,
                      const DWARFUnitIndex::Entry *IndexEntry)
     : Context(DC), InfoSection(Section), Abbrev(DA), RangeSection(RS),
-      LineSection(LS), StringSection(SS), StringOffsetSection([&]() {
-        if (IndexEntry)
-          if (const auto *C = IndexEntry->getOffset(DW_SECT_STR_OFFSETS))
-            return SOS.slice(C->Offset, C->Offset + C->Length);
-        return SOS;
-      }()),
-      AddrOffsetSection(AOS), isLittleEndian(LE), isDWO(IsDWO),
-      UnitSection(UnitSection), IndexEntry(IndexEntry) {
-  clear();
+      LineSection(LS), StringSection(SS), StringOffsetSection(SOS),
+      StringOffsetSectionBase(0), AddrOffsetSection(AOS), isLittleEndian(LE),
+      isDWO(IsDWO), UnitSection(UnitSection), IndexEntry(IndexEntry) {
+  clear();
+      StringOffsetSectionBase = C->Offset;
 }
 
 DWARFUnit::~DWARFUnit() = default;
 
 bool DWARFUnit::getAddrOffsetSectionItem(uint32_t Index,
                                                 uint64_t &Result) const {
   uint32_t Offset = AddrOffsetSectionBase + Index * AddrSize;
   if (AddrOffsetSection.size() < Offset + AddrSize)
     return false;
   DataExtractor DA(AddrOffsetSection, isLittleEndian, AddrSize);
   Result = DA.getAddress(&Offset);
   return true;
 }
 
 bool DWARFUnit::getStringOffsetSectionItem(uint32_t Index,
-                                                  uint32_t &Result) const {
-  // FIXME: string offset section entries are 8-byte for DWARF64.
-  const uint32_t ItemSize = 4;
-  uint32_t Offset = Index * ItemSize;
-  if (StringOffsetSection.size() < Offset + ItemSize)
+                                           uint64_t &Result) const {
+  unsigned ItemSize = getFormat() == DWARF64 ? 8 : 4;
+  uint32_t Offset = StringOffsetSectionBase + Index * ItemSize;
+  if (StringOffsetSection.Data.size() < Offset + ItemSize)
     return false;
-  DataExtractor DA(StringOffsetSection, isLittleEndian, 0);
-  Result = DA.getU32(&Offset);
+  DataExtractor DA(StringOffsetSection.Data, isLittleEndian, 0);
+  Result = ItemSize == 4 ? DA.getU32(&Offset) : DA.getU64(&Offset);
   return true;
 }
 
+uint64_t DWARFUnit::getStringOffsetSectionRelocation(uint32_t Index) const {
+  unsigned ItemSize = getFormat() == DWARF64 ? 8 : 4;
+  uint64_t ByteOffset = StringOffsetSectionBase + Index * ItemSize;
+  RelocAddrMap::const_iterator AI =
+      getStringOffsetsRelocMap()->find(ByteOffset);
+  if (AI != getStringOffsetsRelocMap()->end())
+    return AI->second.second;
+  return 0;
+}
+
 bool DWARFUnit::extractImpl(DataExtractor debug_info, uint32_t *offset_ptr) {
   Length = debug_info.getU32(offset_ptr);
   Version = debug_info.getU16(offset_ptr);
   uint64_t AbbrOffset;
   if (Version >= 5) {
     UnitType = debug_info.getU8(offset_ptr);
     AddrSize = debug_info.getU8(offset_ptr);
     AbbrOffset = debug_info.getU32(offset_ptr);
bool DWARFUnit::extractImpl(DataExtractor debug_info, uint32_t *offset_ptr) {
 
   bool LengthOK = debug_info.isValidOffset(getNextUnitOffset() - 1);
   bool VersionOK = DWARFContext::isSupportedVersion(Version);
   bool AddrSizeOK = AddrSize == 4 || AddrSize == 8;
 
   if (!LengthOK || !VersionOK || !AddrSizeOK)
     return false;
 
+  // Keep track of the highest DWARF version we encounter across all units.
+  Context.setMaxVersionIfGreater(Version);
+
   Abbrevs = Abbrev->getAbbreviationDeclarationSet(AbbrOffset);
   return Abbrevs != nullptr;
 }
 
 bool DWARFUnit::extract(DataExtractor debug_info, uint32_t *offset_ptr) {
   clear();
 
   Offset = *offset_ptr;
size_t DWARFUnit::extractDIEsIfNeeded(bool CUDieOnly) {
   // If CU DIE was just parsed, copy several attribute values from it.
   if (!HasCUDie) {
     DWARFDie UnitDie = getUnitDIE();
     auto BaseAddr = toAddress(UnitDie.find({DW_AT_low_pc, DW_AT_entry_pc}));
     if (BaseAddr)
       setBaseAddress(*BaseAddr);
     AddrOffsetSectionBase = toSectionOffset(UnitDie.find(DW_AT_GNU_addr_base), 0);
     RangeSectionBase = toSectionOffset(UnitDie.find(DW_AT_rnglists_base), 0);
+    // Pre-DWARF v5 split-dwarf implementation derive their string offset
+    // section start from the index table. Make sure we don't overwrite it when
+    // we look for the str_offsets_base attribute and don't find it.
+    StringOffsetSectionBase = toSectionOffset(
+        UnitDie.find(DW_AT_str_offsets_base), StringOffsetSectionBase);
     // Don't fall back to DW_AT_GNU_ranges_base: it should be ignored for
     // skeleton CU DIE, so that DWARF users not aware of it are not broken.
   }
 
   return DieArray.size();
 }
 
 DWARFUnit::DWOHolder::DWOHolder(StringRef DWOPath) {

lib/MC/MCObjectFileInfo.cpp

DwarfAccelNamesSection =
       Ctx->getELFSection(".apple_names", ELF::SHT_PROGBITS, 0);
   DwarfAccelObjCSection =
       Ctx->getELFSection(".apple_objc", ELF::SHT_PROGBITS, 0);
   DwarfAccelNamespaceSection =
       Ctx->getELFSection(".apple_namespaces", ELF::SHT_PROGBITS, 0);
   DwarfAccelTypesSection =
       Ctx->getELFSection(".apple_types", ELF::SHT_PROGBITS, 0);
 
+  // String Offset and Address Sections
+  DwarfStrOffSection =
+      Ctx->getELFSection(".debug_str_offsets", DebugSecType, 0);
+  DwarfAddrSection = Ctx->getELFSection(".debug_addr", DebugSecType, 0);
+
   // Fission Sections
   DwarfInfoDWOSection =
       Ctx->getELFSection(".debug_info.dwo", DebugSecType, 0);
   DwarfTypesDWOSection =
       Ctx->getELFSection(".debug_types.dwo", DebugSecType, 0);
   DwarfAbbrevDWOSection =
       Ctx->getELFSection(".debug_abbrev.dwo", DebugSecType, 0);
   DwarfStrDWOSection =

test/DebugInfo/Generic/string-offsets-multiple-cus.ll

+; RUN: %llc_dwarf -filetype=obj < %s | llvm-dwarfdump - | FileCheck --check-prefix=DEFAULT \
+; RUN:    --check-prefix=BOTH %s
+; RUN: %llc_dwarf -filetype=obj -generate-type-units < %s | llvm-dwarfdump - | \
+; RUN:    FileCheck --check-prefix=TYPEUNITS --check-prefix=BOTH %s
+;
+; Check the correct handling of multiple compile and type units with regard to the
+; string offset section. 
+;
+; Constructed from the following sources:
+;
+; int aglob;
+; struct A {
+;   int i;
+;   float f;
+; };
+; 
+; void afunc(int i)
+; {
+;   A a;
+; }
+;
+; b.cpp:
+; int bglob;
+;
+; void bfunc(int i)
+; {
+; }
+;
+; int cglob;
+; void cfunc(int j)
+; {
+; }
+;
+;
+; Check that all 3 compile units have the correct DW_AT_str_offsets_base attributes
+; with the correct offsets.
+;
+; CU 1
+; BOTH:        .debug_info contents:
+; BOTH-NOT:    .contents:
+; BOTH:        DW_TAG_compile_unit
+; BOTH-NOT:    {{DW_TAG|NULL}}
+; BOTH:        DW_AT_str_offsets_base [DW_FORM_sec_offset] (0x[[CU1_STROFF:[0-9a-f]+]])
+;
+; CU 2
+; BOTH-NOT:    contents:
+; BOTH:        DW_TAG_compile_unit
+; BOTH-NOT:    {{DW_TAG|NULL}}
+; BOTH:        DW_AT_str_offsets_base [DW_FORM_sec_offset] (0x[[CU2_STROFF:[0-9a-f]+]])
+; BOTH-NOT:    NULL
+; BOTH:        DW_TAG_variable
+; BOTH-NOT:    {{DW_TAG|NULL}}
+; BOTH:        DW_AT_name [DW_FORM_strx] ( indexed (00000003) string = "bglob")
+;
+; CU 3
+; BOTH-NOT:    contents:
+; BOTH:        DW_TAG_compile_unit
+; BOTH-NOT:    {{DW_TAG|NULL}}
+; BOTH:        DW_AT_str_offsets_base [DW_FORM_sec_offset] (0x[[CU3_STROFF:[0-9a-f]+]])
+; BOTH-NOT:    NULL
+; BOTH:        DW_TAG_variable
+; BOTH-NOT:    {{DW_TAG|NULL}}
+; BOTH:        DW_AT_name [DW_FORM_strx] ( indexed (00000003) string = "cglob")
+;
+; Verify that type units have the proper DW_AT_str_offsets_base attribute and 
+; a segment in the .debug_str_offsets section.
+;
+; TYPEUNITS:      .debug_types contents:
+; TYPEUNITS-NOT:  contents:
+; TYPEUNITS:      DW_TAG_type_unit
+; TYPEUNITS-NOT:  {{DW_TAG|NULL}}
+; TYPEUNITS:      DW_AT_str_offsets_base [DW_FORM_sec_offset] (0x[[TU_STROFF:[0-9]+]])
+; TYPEUNITS-NOT:  NULL
+; TYPEUNITS:      DW_TAG_member
+; TYPEUNITS-NOT:  NULL
+; TYPEUNITS:      DW_TAG_member
+; TYPEUNITS-NOT:  {{DW_TAG|NULL}}
+; TYPEUNITS:      DW_AT_name [DW_FORM_strx] ( indexed (00000002) string = "f")
+;
+; BOTH:           .debug_str contents:
+; BOTH-NOT:       contents:
+; BOTH:           0x[[BGLOBOFF:[0-9a-f]+]]: "bglob"
+;
+; Check the .debug_str_offsets section
+; DEFAULT:        .debug_str_offsets contents:
+; DEFAULT-NEXT:   0x00000000: Segment size = 48, Version = 5
+; DEFAULT-NEXT:   0x[[CU1_STROFF]]:
+; DEFAULT:        0x00000038: Segment size = 28, Version = 5
+; DEFAULT-NEXT:   0x[[CU2_STROFF]]:
+; DEFAULT-NEXT:   {{.*:}}
+; DEFAULT-NEXT:   {{.*:}}
+; The string with index 3 in segment 1 should be "bglob"
+; DEFAULT-NEXT:   {{.*:}} [[BGLOBOFF]]
+; DEFAULT:        0x0000005c: Segment size = 28, Version = 5
+; DEFAULT-NEXT:   0x[[CU3_STROFF]]:
+
+; TYPEUNITS:      .debug_str_offsets contents:
+; TYPEUNITS-NEXT: 0x00000000: Segment size = 20, Version = 5
+; TYPEUNITS-NEXT: 0x[[TU_STROFF]]:
+; TYPEUNITS:      0x0000001c: Segment size = 36, Version = 5
+; TYPEUNITS-NEXT: 0x[[CU1_STROFF]]:
+; TYPEUNITS:      0x00000048: Segment size = 32, Version = 5
+; TYPEUNITS-NEXT: 0x[[CU2_STROFF]]:
+; TYPEUNITS-NEXT: {{.*:}}
+; TYPEUNITS-NEXT: {{.*:}}
+; The string with index 3 in segment 1 should be "bglob"
+; TYPEUNITS-NEXT: {{.*:}} [[BGLOBOFF]]
+; TYPEUNITS:      0x00000070: Segment size = 32, Version = 5
+; TYPEUNITS-NEXT: 0x[[CU3_STROFF]]:
+
+
+; ModuleID = 'test.bc'
+source_filename = "llvm-link"
+; target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+; target triple = "x86_64-unknown-linux-gnu"
+
+%struct.A = type { i32, float }
+
+@aglob = global i32 0, align 4, !dbg !0
+@bglob = global i32 0, align 4, !dbg !7
+@cglob = global i32 0, align 4, !dbg !12
+
+; Function Attrs: noinline nounwind uwtable
+define void @_Z5afunci(i32 %i) #0 !dbg !20 {
+entry:
+  %i.addr = alloca i32, align 4
+  %a = alloca %struct.A, align 4
+  store i32 %i, i32* %i.addr, align 4
+  call void @llvm.dbg.declare(metadata i32* %i.addr, metadata !23, metadata !24), !dbg !25
+  call void @llvm.dbg.declare(metadata %struct.A* %a, metadata !26, metadata !24), !dbg !32
+  ret void, !dbg !33
+}
+
+; Function Attrs: nounwind readnone
+declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
+
+; Function Attrs: noinline nounwind uwtable
+define void @_Z5bfunci(i32 %i) #0 !dbg !34 {
+entry:
+  %i.addr = alloca i32, align 4
+  store i32 %i, i32* %i.addr, align 4
+  call void @llvm.dbg.declare(metadata i32* %i.addr, metadata !35, metadata !24), !dbg !36
+  ret void, !dbg !37
+}
+
+; Function Attrs: noinline nounwind uwtable
+define void @_Z5cfunci(i32 %j) #0 !dbg !38 {
+entry:
+  %j.addr = alloca i32, align 4
+  store i32 %j, i32* %j.addr, align 4
+  call void @llvm.dbg.declare(metadata i32* %j.addr, metadata !39, metadata !24), !dbg !40
+  ret void, !dbg !41
+}
+
+attributes #0 = { noinline nounwind uwtable }
+attributes #1 = { nounwind readnone }
+
+!llvm.dbg.cu = !{!2, !9, !14}
+!llvm.ident = !{!17, !17, !17}
+!llvm.module.flags = !{!18, !19}
+
+!0 = !DIGlobalVariableExpression(var: !1)
+!1 = distinct !DIGlobalVariable(name: "aglob", scope: !2, file: !3, line: 1, type: !6, isLocal: false, isDefinition: true)
+!2 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !3, producer: "clang version 5.0.0 (trunk 300143)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5)
+!3 = !DIFile(filename: "a.cpp", directory: "/home/test/debuginfo/DWARF5/LTO")
+!4 = !{}
+!5 = !{!0}
+!6 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!7 = !DIGlobalVariableExpression(var: !8)
+!8 = distinct !DIGlobalVariable(name: "bglob", scope: !9, file: !10, line: 1, type: !6, isLocal: false, isDefinition: true)
+!9 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !10, producer: "clang version 5.0.0 (trunk 300143)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !11)
+!10 = !DIFile(filename: "b.cpp", directory: "/home/test/debuginfo/DWARF5/LTO")
+!11 = !{!7}
+!12 = !DIGlobalVariableExpression(var: !13)
+!13 = distinct !DIGlobalVariable(name: "cglob", scope: !14, file: !15, line: 1, type: !6, isLocal: false, isDefinition: true)
+!14 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !15, producer: "clang version 5.0.0 (trunk 300143)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !16)
+!15 = !DIFile(filename: "c.cpp", directory: "/home/test/debuginfo/DWARF5/LTO")
+!16 = !{!12}
+!17 = !{!"clang version 5.0.0 (trunk 300143)"}
+!18 = !{i32 2, !"Dwarf Version", i32 5}
+!19 = !{i32 2, !"Debug Info Version", i32 3}
+!20 = distinct !DISubprogram(name: "afunc", linkageName: "_Z5afunci", scope: !3, file: !3, line: 8, type: !21, isLocal: false, isDefinition: true, scopeLine: 9, flags: DIFlagPrototyped, isOptimized: false, unit: !2, variables: !4)
+!21 = !DISubroutineType(types: !22)
+!22 = !{null, !6}
+!23 = !DILocalVariable(name: "i", arg: 1, scope: !20, file: !3, line: 8, type: !6)
+!24 = !DIExpression()
+!25 = !DILocation(line: 8, column: 16, scope: !20)
+!26 = !DILocalVariable(name: "a", scope: !20, file: !3, line: 10, type: !27)
+!27 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "A", file: !3, line: 3, size: 64, elements: !28, identifier: "_ZTS1A")
+!28 = !{!29, !30}
+!29 = !DIDerivedType(tag: DW_TAG_member, name: "i", scope: !27, file: !3, line: 4, baseType: !6, size: 32)
+!30 = !DIDerivedType(tag: DW_TAG_member, name: "f", scope: !27, file: !3, line: 5, baseType: !31, size: 32, offset: 32)
+!31 = !DIBasicType(name: "float", size: 32, encoding: DW_ATE_float)
+!32 = !DILocation(line: 10, column: 5, scope: !20)
+!33 = !DILocation(line: 11, column: 1, scope: !20)
+!34 = distinct !DISubprogram(name: "bfunc", linkageName: "_Z5bfunci", scope: !10, file: !10, line: 3, type: !21, isLocal: false, isDefinition: true, scopeLine: 4, flags: DIFlagPrototyped, isOptimized: false, unit: !9, variables: !4)
+!35 = !DILocalVariable(name: "i", arg: 1, scope: !34, file: !10, line: 3, type: !6)
+!36 = !DILocation(line: 3, column: 16, scope: !34)
+!37 = !DILocation(line: 5, column: 1, scope: !34)
+!38 = distinct !DISubprogram(name: "cfunc", linkageName: "_Z5cfunci", scope: !15, file: !15, line: 3, type: !21, isLocal: false, isDefinition: true, scopeLine: 4, flags: DIFlagPrototyped, isOptimized: false, unit: !14, variables: !4)
+!39 = !DILocalVariable(name: "j", arg: 1, scope: !38, file: !15, line: 3, type: !6)
+!40 = !DILocation(line: 3, column: 16, scope: !38)
+!41 = !DILocation(line: 5, column: 1, scope: !38)

test/DebugInfo/Generic/string-offsets-table.ll

+; RUN: %llc_dwarf -filetype=obj < %s | llvm-dwarfdump - | FileCheck --check-prefix=MONOLITHIC %s
+; RUN: %llc_dwarf -split-dwarf-file=foo.dwo -filetype=obj < %s | llvm-dwarfdump - \
+; RUN:   | FileCheck --check-prefix=SPLIT %s
+
+; Test the proper emission of the DWARF v5 string offsets table. 
+; We test both default (monolithic) dwarf generation and splitting into *.dwo sections.
+; 
+; Constructed from the following source with
+; clang -S -emit-llvm -gdwarf-5:
+;
+; int aglob;
+; 
+; struct A {
+;   int i;
+;   float f;
+; };
+; 
+; void afunc(int i)
+; {
+;   A a;
+; }
+
+; Check the DW_AT_str_offsets_base attribute in .debug_abbrev
+; MONOLITHIC:          .debug_abbrev contents:
+; MONOLITHIC-NOT:      contents:
+; MONOLITHIC:          DW_TAG_compile_unit
+; MONOLITHIC-NOT:      DW_TAG
+; MONOLITHIC:          DW_AT_str_offsets_base DW_FORM_sec_offset
+
+; Check that indexed strings come out correctly and that the DW_str_offsets_base attribute
+; is there.
+; MONOLITHIC:          .debug_info contents:
+; MONOLITHIC-NOT:      contents:
+; MONOLITHIC:          DW_TAG_compile_unit
+; MONOLITHIC-NOT:      {{DW_TAG|NULL}}
+; MONOLITHIC:          DW_AT_producer [DW_FORM_strx] ( indexed (00000000) string = "clang{{.*}}")
+; MONOLITHIC-NOT:      {{DW_TAG|NULL}}
+; MONOLITHIC:          DW_AT_str_offsets_base [DW_FORM_sec_offset] (0x00000008)
+; MONOLITHIC-NOT:      {{DW_TAG|NULL}}
+; MONOLITHIC:          DW_AT_comp_dir [DW_FORM_strx] ( indexed (00000002) string = "/home/{{.*}}")
+; MONOLITHIC-NOT:      NULL 
+; MONOLITHIC:          DW_TAG_subprogram
+; MONOLITHIC-NOT:      {{DW_TAG|NULL}}
+; MONOLITHIC:          DW_AT_linkage_name [DW_FORM_strx] ( indexed (00000005) string = "_Z5afunci")
+
+; Verify that the .debug_str_offsets section is there and
+; that it starts with an 8-byte header, followed by relocatable
+; offsets into the .debug_str section.
+; MONOLITHIC:          .debug_str_offsets contents:
+; MONOLITHIC-NEXT:     0x00000000: Segment size = 48, Version = 5
+; MONOLITHIC-NEXT:     0x00000008: 00000000
+; MONOLITHIC-NEXT:     0x0000000c: 00000023
+; MONOLITHIC-NEXT:     0x00000010: 00000029
+;
+; For split dwarf, verify first that the skeleton unit has the DW_AT_str_offsets_base
+; attribute and that there is a .debug_str_offsets section with a proper header.
+;
+; SPLIT:      .debug_info contents:
+; SPLIT-NEXT: 0x00000000: Compile Unit:{{.*}}DW_UT_skeleton
+; SPLIT-NOT:  contents:
+; SPLIT:      DW_TAG_compile_unit
+; SPLIT-NOT:  {{DW_TAG|contents:}}
+; SPLIT:      DW_AT_str_offsets_base [DW_FORM_sec_offset] (0x00000008)
+;
+; Check the split CU in .debug_info.dwo for a DW_AT_str_offsets_base attribute.
+; SPLIT:      .debug_info.dwo contents:
+; SPLIT-NEXT: 0x00000000: Compile Unit:{{.*}}DW_UT_split_compile
+; SPLIT-NOT:  contents:
+; SPLIT:      DW_TAG_compile_unit
+; SPLIT-NOT:  {{DW_TAG|NULL}}
+; SPLIT:      DW_AT_str_offsets_base [DW_FORM_sec_offset] (0x00000008)
+;
+; Check for a couple of indexed strings.
+; SPLIT-NOT:  contents:
+; SPLIT:      DW_TAG_variable
+; SPLIT-NEXT: DW_AT_name [DW_FORM_strx] ( indexed (00000003) string = "aglob")
+; SPLIT-NOT:  contents:
+; SPLIT:      DW_TAG_subprogram
+; SPLIT-NOT:  {{DW_TAG|NULL}}
+; SPLIT:      DW_AT_linkage_name [DW_FORM_strx] ( indexed (00000005) string = "_Z5afunci")
+;
+; Check the string_offsets sections: .debug_str_offsets and .debug_str_offsets.dwo
+; SPLIT:      .debug_str_offsets contents:
+; SPLIT-NEXT: 0x00000000: Segment size = 8, Version = 5
+; SPLIT-NEXT: 0x00000008: 00000000
+; SPLIT-NEXT: 0x0000000c: 00000008
+; SPLIT:      .debug_str_offsets.dwo contents:
+; SPLIT-NEXT: 0x00000000: Segment size = 48, Version = 5
+; SPLIT-NEXT: 0x00000008: 00000000
+; SPLIT-NEXT: 0x0000000c: 00000008
+; SPLIT-NEXT: 0x00000010: 0000002b
+;
+; ModuleID = 'a.cpp'
+source_filename = "a.cpp"
+
+%struct.A = type { i32, float }
+
+@aglob = global i32 0, align 4, !dbg !0
+
+; Function Attrs: noinline nounwind uwtable
+define void @_Z5afunci(i32 %i) #0 !dbg !10 {
+entry:
+  %i.addr = alloca i32, align 4
+  %a = alloca %struct.A, align 4
+  store i32 %i, i32* %i.addr, align 4
+  call void @llvm.dbg.declare(metadata i32* %i.addr, metadata !13, metadata !14), !dbg !15
+  call void @llvm.dbg.declare(metadata %struct.A* %a, metadata !16, metadata !14), !dbg !22
+  ret void, !dbg !23
+}
+
+; Function Attrs: nounwind readnone
+declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
+
+attributes #0 = { noinline nounwind uwtable }
+attributes #1 = { nounwind readnone }
+
+!llvm.dbg.cu = !{!2}
+!llvm.module.flags = !{!7, !8}
+!llvm.ident = !{!9}
+
+!0 = !DIGlobalVariableExpression(var: !1)
+!1 = distinct !DIGlobalVariable(name: "aglob", scope: !2, file: !3, line: 1, type: !6, isLocal: false, isDefinition: true)
+!2 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !3, producer: "clang version 5.0.0 (trunk 300364)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5)
+!3 = !DIFile(filename: "a.cpp", directory: "/home/test/debuginfo/DWARF5")
+!4 = !{}
+!5 = !{!0}
+!6 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!7 = !{i32 2, !"Dwarf Version", i32 5}
+!8 = !{i32 2, !"Debug Info Version", i32 3}
+!9 = !{!"clang version 5.0.0 (trunk 300364)"}
+!10 = distinct !DISubprogram(name: "afunc", linkageName: "_Z5afunci", scope: !3, file: !3, line: 8, type: !11, isLocal: false, isDefinition: true, scopeLine: 9, flags: DIFlagPrototyped, isOptimized: false, unit: !2, variables: !4)
+!11 = !DISubroutineType(types: !12)
+!12 = !{null, !6}
+!13 = !DILocalVariable(name: "i", arg: 1, scope: !10, file: !3, line: 8, type: !6)
+!14 = !DIExpression()
+!15 = !DILocation(line: 8, column: 16, scope: !10)
+!16 = !DILocalVariable(name: "a", scope: !10, file: !3, line: 10, type: !17)
+!17 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "A", file: !3, line: 3, size: 64, elements: !18, identifier: "_ZTS1A")
+!18 = !{!19, !20}
+!19 = !DIDerivedType(tag: DW_TAG_member, name: "i", scope: !17, file: !3, line: 4, baseType: !6, size: 32)
+!20 = !DIDerivedType(tag: DW_TAG_member, name: "f", scope: !17, file: !3, line: 5, baseType: !21, size: 32, offset: 32)
+!21 = !DIBasicType(name: "float", size: 32, encoding: DW_ATE_float)
+!22 = !DILocation(line: 10, column: 5, scope: !10)
+!23 = !DILocation(line: 11, column: 1, scope: !10)

test/DebugInfo/Inputs/dwarfdump-str-offsets.s

+# Test object to verify dwarfdump handles v5 string offset tables.
+# We have 2 v5 CUs, a v5 TU, and a split v5 CU and TU.
+#
+# To generate the test object:
+# llvm-mc -triple x86_64-unknown-linux dwarfdump-str-offsets.s -filetype=obj \
+#         -o dwarfdump-str-offsets.elf-x86-64
+
+        .section .debug_str,"MS",@progbits,1
+str_producer:
+        .asciz "Handmade DWARF producer"
+str_CU1:
+        .asciz "Compile_Unit_1"
+str_CU1_dir:
+        .asciz "/home/test/CU1"
+str_CU2:
+        .asciz "Compile_Unit_2"
+str_CU2_dir:
+        .asciz "/home/test/CU2"
+str_TU:
+        .asciz "Type_Unit"
+str_TU_type:
+        .asciz "MyStruct"
+
+# Every unit contributes to the string_offsets table.
+        .section .debug_str_offsets,"",@progbits
+# CU1's contribution
+        .long .debug_str_offsets_segment0_end-.debug_str_offsets_base0
+        .short 5    # DWARF version
+        .short 0    # Padding
+.debug_str_offsets_base0:
+        .long str_producer
+        .long str_CU1
+        .long str_CU1_dir
+.debug_str_offsets_segment0_end:
+# CU2's contribution
+        .long .debug_str_offsets_segment1_end-.debug_str_offsets_base1
+        .short 5    # DWARF version
+        .short 0    # Padding
+.debug_str_offsets_base1:
+        .long str_producer
+        .long str_CU2
+        .long str_CU2_dir
+.debug_str_offsets_segment1_end:
+# The TU's contribution
+        .long .debug_str_offsets_segment2_end-.debug_str_offsets_base2
+        .short 5    # DWARF version
+        .short 0    # Padding
+.debug_str_offsets_base2:
+        .long str_TU
+        .long str_TU_type
+.debug_str_offsets_segment2_end:
+
+        .section .debug_str.dwo,"MS",@progbits,1
+dwo_str_CU_5_producer:
+        .asciz "Handmade split DWARF producer"
+dwo_str_CU_5_name:
+        .asciz "V5_split_compile_unit"
+dwo_str_CU_5_comp_dir:
+        .asciz "/home/test/splitCU"
+dwo_str_TU_5:
+        .asciz "V5_split_type_unit"
+dwo_str_TU_5_type:
+        .asciz "V5_split_Mystruct"
+
+        .section .debug_str_offsets.dwo,"",@progbits
+# The split CU's contribution
+        .long .debug_dwo_str_offsets_segment0_end-.debug_dwo_str_offsets_base0
+        .short 5    # DWARF version
+        .short 0    # Padding
+.debug_dwo_str_offsets_base0:
+        .long dwo_str_CU_5_producer-.debug_str.dwo
+        .long dwo_str_CU_5_name-.debug_str.dwo
+        .long dwo_str_CU_5_comp_dir-.debug_str.dwo
+.debug_dwo_str_offsets_segment0_end:
+# The split TU's contribution
+        .long .debug_dwo_str_offsets_segment1_end-.debug_dwo_str_offsets_base1
+        .short 5    # DWARF version
+        .short 0    # Padding
+.debug_dwo_str_offsets_base1:
+        .long dwo_str_TU_5-.debug_str.dwo
+        .long dwo_str_TU_5_type-.debug_str.dwo
+.debug_dwo_str_offsets_segment1_end:
+
+# All CUs/TUs use the same abbrev section for simplicity.
+        .section .debug_abbrev,"",@progbits
+        .byte 0x01  # Abbrev code
+        .byte 0x11  # DW_TAG_compile_unit
+        .byte 0x00  # DW_CHILDREN_no
+        .byte 0x25  # DW_AT_producer
+        .byte 0x1a  # DW_FORM_strx
+        .byte 0x03  # DW_AT_name
+        .byte 0x1a  # DW_FORM_strx
+        .byte 0x72  # DW_AT_str_offsets_base
+        .byte 0x17  # DW_FORM_sec_offset
+        .byte 0x1b  # DW_AT_comp_dir
+        .byte 0x1a  # DW_FORM_strx
+        .byte 0x00  # EOM(1)
+        .byte 0x00  # EOM(2)
+        .byte 0x02  # Abbrev code
+        .byte 0x41  # DW_TAG_type_unit
+        .byte 0x01  # DW_CHILDREN_yes
+        .byte 0x03  # DW_AT_name
+        .byte 0x1a  # DW_FORM_strx
+        .byte 0x72  # DW_AT_str_offsets_base
+        .byte 0x17  # DW_FORM_sec_offset
+        .byte 0x00  # EOM(1)
+        .byte 0x00  # EOM(2)
+        .byte 0x03  # Abbrev code
+        .byte 0x13  # DW_TAG_structure_type
+        .byte 0x00  # DW_CHILDREN_no (no members)
+        .byte 0x03  # DW_AT_name
+        .byte 0x1a  # DW_FORM_strx
+        .byte 0x00  # EOM(1)
+        .byte 0x00  # EOM(2)
+        .byte 0x00  # EOM(3)
+
+# And a .dwo copy for the .dwo sections.
+        .section .debug_abbrev.dwo,"",@progbits
+        .byte 0x01  # Abbrev code
+        .byte 0x11  # DW_TAG_compile_unit
+        .byte 0x00  # DW_CHILDREN_no
+        .byte 0x25  # DW_AT_producer
+        .byte 0x1a  # DW_FORM_strx
+        .byte 0x03  # DW_AT_name
+        .byte 0x1a  # DW_FORM_strx
+        .byte 0x72  # DW_AT_str_offsets_base
+        .byte 0x17  # DW_FORM_sec_offset
+        .byte 0x1b  # DW_AT_comp_dir
+        .byte 0x1a  # DW_FORM_strx
+        .byte 0x00  # EOM(1)
+        .byte 0x00  # EOM(2)
+        .byte 0x02  # Abbrev code
+        .byte 0x41  # DW_TAG_type_unit
+        .byte 0x01  # DW_CHILDREN_yes
+        .byte 0x03  # DW_AT_name
+        .byte 0x1a  # DW_FORM_strx
+        .byte 0x72  # DW_AT_str_offsets_base
+        .byte 0x17  # DW_FORM_sec_offset
+        .byte 0x00  # EOM(1)
+        .byte 0x00  # EOM(2)
+        .byte 0x03  # Abbrev code
+        .byte 0x13  # DW_TAG_structure_type
+        .byte 0x00  # DW_CHILDREN_no (no members)
+        .byte 0x03  # DW_AT_name
+        .byte 0x1a  # DW_FORM_strx
+        .byte 0x00  # EOM(1)
+        .byte 0x00  # EOM(2)
+        .byte 0x00  # EOM(3)
+        
+        .section .debug_info,"",@progbits
+
+# DWARF v5 CU header.
+        .long  CU1_5_end-CU1_5_version  # Length of Unit
+CU1_5_version:
+        .short 5               # DWARF version number
+        .byte 1                # DWARF Unit Type
+        .byte 8                # Address Size (in bytes)
+        .long .debug_abbrev    # Offset Into Abbrev. Section
+# The compile-unit DIE, which has a DW_AT_producer, DW_AT_name, 
+# DW_AT_str_offsets and DW_AT_compdir.
+        .byte 1                # Abbreviation code
+        .byte 0                # The index of the producer string
+        .byte 1                # The index of the CU name string
+        .long .debug_str_offsets_base0
+        .byte 2                # The index of the comp dir string
+        .byte 0 # NULL
+CU1_5_end:
+
+# DWARF v5 CU header
+        .long  CU2_5_end-CU2_5_version  # Length of Unit
+CU2_5_version:
+        .short 5               # DWARF version number
+        .byte 1                # DWARF Unit Type
+        .byte 8                # Address Size (in bytes)
+        .long .debug_abbrev    # Offset Into Abbrev. Section
+# The compile-unit DIE, which has a DW_AT_producer, DW_AT_name, 
+# DW_AT_str_offsets and DW_AT_compdir.
+        .byte 1                # Abbreviation code
+        .byte 0                # The index of the producer string
+        .byte 1                # The index of the CU name string
+        .long .debug_str_offsets_base1
+        .byte 2                # The index of the comp dir string
+        .byte 0 # NULL
+CU2_5_end:
+
+        .section .debug_types,"",@progbits
+# DWARF v5 Type unit header.
+TU_5_start:
+        .long  TU_5_end-TU_5_version  # Length of Unit
+TU_5_version:
+        .short 5               # DWARF version number
+        .byte 2                # DWARF Unit Type
+        .byte 8                # Address Size (in bytes)
+        .long .debug_abbrev    # Offset Into Abbrev. Section
+        .quad 0x0011223344556677 # Type Signature
+        .long TU_5_type-TU_5_start # Type offset
+# The type-unit DIE, which has a name.
+        .byte 2                # Abbreviation code
+        .byte 0                # Index of the unit type name string
+        .long .debug_str_offsets_base2  # offset into the str_offsets section
+# The type DIE, which has a name.
+TU_5_type:
+        .byte 3                # Abbreviation code
+        .byte 1                # Index of the type name string
+        .byte 0 # NULL
+        .byte 0 # NULL
+TU_5_end:
+        
+        .section .debug_info.dwo,"",@progbits
+
+# DWARF v5 split CU header.
+        .long  CU_split_5_end-CU_split_5_version  # Length of Unit
+CU_split_5_version:
+        .short 5               # DWARF version number
+        .byte 1                # DWARF Unit Type
+        .byte 8                # Address Size (in bytes)
+        .long .debug_abbrev.dwo  # Offset Into Abbrev Section
+# The compile-unit DIE, which has a DW_AT_producer, DW_AT_name, 
+# DW_AT_str_offsets and DW_AT_compdir.
+        .byte 1                # Abbreviation code
+        .byte 0                # The index of the producer string
+        .byte 1                # The index of the CU name string
+        .long .debug_dwo_str_offsets_base0-.debug_str_offsets.dwo
+        .byte 2                # The index of the comp dir string
+        .byte 0 # NULL
+CU_split_5_end:
+        
+        .section .debug_types.dwo,"",@progbits
+
+# DWARF v5 split type unit header.
+TU_split_5_start:
+        .long  TU_split_5_end-TU_split_5_version  # Length of Unit
+TU_split_5_version:
+        .short 5               # DWARF version number
+        .byte 6                # DWARF Unit Type
+        .byte 8                # Address Size (in bytes)
+        .long .debug_abbrev.dwo  # Offset Into Abbrev Section
+        .quad 0x8899aabbccddeeff # Type Signature
+        .long TU_split_5_type-TU_split_5_start  # Type offset
+# The type-unit DIE, which has a name.
+        .byte 2                # Abbreviation code
+        .byte 0                # The index of the type unit name string
+        .long .debug_dwo_str_offsets_base1-.debug_str_offsets.dwo 
+# The type DIE, which has a name.
+TU_split_5_type:
+        .byte 3                # Abbreviation code
+        .byte 1                # The index of the type name string
+        .byte 0 # NULL
+        .byte 0 # NULL
+TU_split_5_end:

test/DebugInfo/dwarfdump-str-offsets.test

+RUN: llvm-dwarfdump %p/Inputs/dwarfdump-str-offsets.elf-x86-64 | FileCheck %s
+
+; We are using a hand-constructed object file and are interest in the correct
+; diplay of the DW_str_offsetsbase attribute, the correct display of strings
+; and the dump of the .debug_str_offsets[.dwo] table.
+;
+; Abbreviation for DW_AT_str_offsets_base
+CHECK:      .debug_abbrev contents:
+CHECK-NOT:  contents:
+CHECK:      DW_TAG_compile_unit
+CHECK-NOT:  DW_TAG
+CHECK:      DW_AT_str_offsets_base DW_FORM_sec_offset
+
+; Verify that strings are displayed correctly as indexed strings
+CHECK:      .debug_info contents:
+CHECK-NOT:  contents:     
+CHECK:      DW_TAG_compile_unit
+CHECK-NEXT: DW_AT_producer [DW_FORM_strx] ( indexed (00000000) string = "Handmade DWARF producer")
+CHECK-NEXT: DW_AT_name [DW_FORM_strx] ( indexed (00000001) string = "Compile_Unit_1")
+CHECK-NEXT: DW_AT_str_offsets_base [DW_FORM_sec_offset] (0x00000008)
+CHECK-NEXT: DW_AT_comp_dir [DW_FORM_strx] ( indexed (00000002) string = "/home/test/CU1")
+
+; Second compile unit (b.cpp)
+CHECK:      DW_TAG_compile_unit
+CHECK-NEXT: DW_AT_producer [DW_FORM_strx] ( indexed (00000000) string = "Handmade DWARF producer")
+CHECK-NEXT: DW_AT_name [DW_FORM_strx] ( indexed (00000001) string = "Compile_Unit_2")
+CHECK-NEXT: DW_AT_str_offsets_base [DW_FORM_sec_offset] (0x0000001c)
+CHECK-NEXT: DW_AT_comp_dir [DW_FORM_strx] ( indexed (00000002) string = "/home/test/CU2")
+
+; The split CU
+CHECK:      .debug_info.dwo contents:
+CHECK-NOT:  contents:
+CHECK:      DW_TAG_compile_unit
+CHECK-NEXT: DW_AT_producer [DW_FORM_strx] ( indexed (00000000) string = "Handmade split DWARF producer")
+CHECK-NEXT: DW_AT_name [DW_FORM_strx] ( indexed (00000001) string = "V5_split_compile_unit")
+CHECK-NEXT: DW_AT_str_offsets_base [DW_FORM_sec_offset] (0x00000008)
+CHECK-NEXT: DW_AT_comp_dir [DW_FORM_strx] ( indexed (00000002) string = "/home/test/splitCU")
+
+; The type unit
+CHECK:      .debug_types contents:
+CHECK:      DW_TAG_type_unit
+CHECK-NEXT: DW_AT_name [DW_FORM_strx] ( indexed (00000000) string = "Type_Unit")
+CHECK-NEXT: DW_AT_str_offsets_base [DW_FORM_sec_offset]       (0x00000030)
+CHECK:      DW_TAG_structure_type
+CHECK-NEXT: DW_AT_name [DW_FORM_strx] ( indexed (00000001) string = "MyStruct")
+
+; The split type unit
+CHECK:      .debug_types.dwo contents:
+CHECK:      DW_TAG_type_unit
+CHECK-NEXT: DW_AT_name [DW_FORM_strx] ( indexed (00000000) string = "V5_split_type_unit")
+CHECK-NEXT: DW_AT_str_offsets_base [DW_FORM_sec_offset]       (0x0000001c)
+CHECK:      DW_TAG_structure_type
+CHECK-NEXT: DW_AT_name [DW_FORM_strx] ( indexed (00000001) string = "V5_split_Mystruct")
+
+; The .debug_str_offsets section
+CHECK:      .debug_str_offsets contents:
+CHECK-NEXT: 0x00000000: Segment size = 12, Version = 5
+CHECK-NEXT: 0x00000008: 00000000
+CHECK-NEXT: 0x0000000c: 00000018
+CHECK-NEXT: 0x00000010: 00000027
+CHECK-NEXT: 0x00000014: Segment size = 12, Version = 5
+CHECK-NEXT: 0x0000001c: 00000000
+CHECK-NEXT: 0x00000020: 00000036
+CHECK-NEXT: 0x00000024: 00000045
+CHECK-NEXT: 0x00000028: Segment size = 8, Version = 5
+CHECK-NEXT: 0x00000030: 00000054
+CHECK-NEXT: 0x00000034: 0000005e
+
+CHECK:      .debug_str_offsets.dwo contents:
+CHECK-NEXT: 0x00000000: Segment size = 12, Version = 5
+CHECK-NEXT: 0x00000008: 00000000
+CHECK-NEXT: 0x0000000c: 0000001e
+CHECK-NEXT: 0x00000010: 00000034
+CHECK-NEXT: 0x00000014: Segment size = 8, Version = 5
+CHECK-NEXT: 0x0000001c: 00000047
+CHECK-NEXT: 0x00000020: 0000005a

tools/llvm-dwarfdump/llvm-dwarfdump.cpp

cl::values(
         clEnumValN(DIDT_Frames, "frames", ".debug_frame"),
         clEnumValN(DIDT_Macro, "macro", ".debug_macinfo"),
         clEnumValN(DIDT_Ranges, "ranges", ".debug_ranges"),
         clEnumValN(DIDT_Pubnames, "pubnames", ".debug_pubnames"),
         clEnumValN(DIDT_Pubtypes, "pubtypes", ".debug_pubtypes"),
         clEnumValN(DIDT_GnuPubnames, "gnu_pubnames", ".debug_gnu_pubnames"),
         clEnumValN(DIDT_GnuPubtypes, "gnu_pubtypes", ".debug_gnu_pubtypes"),
         clEnumValN(DIDT_Str, "str", ".debug_str"),
+        clEnumValN(DIDT_StrOffsets, "str_offsets", ".debug_str_offsets"),
         clEnumValN(DIDT_StrDwo, "str.dwo", ".debug_str.dwo"),
         clEnumValN(DIDT_StrOffsetsDwo, "str_offsets.dwo",
                    ".debug_str_offsets.dwo"),
         clEnumValN(DIDT_CUIndex, "cu_index", ".debug_cu_index"),
         clEnumValN(DIDT_GdbIndex, "gdb_index", ".gdb_index"),
         clEnumValN(DIDT_TUIndex, "tu_index", ".debug_tu_index")));
 
 static cl::opt<bool>

tools/obj2yaml/dwarf2yaml.cpp

for (auto DIE : CU->dies()) {
               break;
             case dwarf::DW_FORM_strp:
             case dwarf::DW_FORM_sec_offset:
             case dwarf::DW_FORM_GNU_ref_alt:
             case dwarf::DW_FORM_GNU_strp_alt:
             case dwarf::DW_FORM_line_strp:
             case dwarf::DW_FORM_strp_sup:
             case dwarf::DW_FORM_GNU_str_index:
+            case dwarf::DW_FORM_strx:
               if (auto Val = FormValue.getValue().getAsCStringOffset())
                 NewValue.Value = Val.getValue();
               break;
             case dwarf::DW_FORM_flag_present:
               NewValue.Value = 1;
               break;
             default:
               break;