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

[wolfgangp]

Summary

This review and the producer portion replaces https://reviews.llvm.org/D32618.

This is the proposed implementation of the DWARF5 string offsets table. Since the last iteration in https://reviews.llvm.org/D32618 support for Mach-O and COFF was added and review comments were addressed.

[dblaikie]

lib/DebugInfo/DWARF/DWARFContext.cpp

100–101

Is there a test case for this?

107–108

Is there a test case for this?

107–109

Maybe flip this around:

if (SegmentSize == 0xffff... ) {
  ...
} else if (SegmentSize > 0xfff...0) {
  ...
}

Though the early return is nice - just be nice if there was a way to avoid checking for the 0xff..ff case twice. At least on the first check perhaps it'd be better to write it as "Size > 0xff..f0 && Size != 0xff..ff" ? rather than < when it'll only check one valeu anyway?

110–111

Is there a test case for this?

118

Does this need to test if the SegmentSize is a multiple of the record size? otherwise the loop below might read a partial record, off the end/past SegmentSize?

118–119

Is there a test case for this?

129–131

Is there a general purpose "apply a reloc" function that could be used here?

1047–1050

Why is this being added now/in this change?

(how did things work without this change - what problem arose that motivated it?)

lib/DebugInfo/DWARF/DWARFFormValue.cpp

608–610

Rather than trying, failing, falling back - should this be implemented in a way to "do the right thing" from the start?

lib/DebugInfo/DWARF/DWARFTypeUnit.cpp

27–30

Seems like there's a few things in this patch that might be sane to separate - like this DWARF64 support for type units.

lib/DebugInfo/DWARF/DWARFUnit.cpp

81

StringOffsetSectionBase is to support DWP files, I assume? Is that tested?

[wolfgangp]

lib/DebugInfo/DWARF/DWARFContext.cpp

100–101

Hmm, I guess not. This would be one of a handful cases of invalid input, so I will add cases for all of them.

107–108

Will add one.

110–111

Will add one.

118–119

Will add one.

129–131

Yes, there is one. I'm not sure why I didn't see it before. I'll work that in.

1047–1050

Adrian reminded me that I should also support Mach-O and COFF. This is part of the support for Mach-O. Since Mach-O limits section names to 16 bytes and some of the DWARF standard section names are longer than that (e.g. .debug_str_offsets) it seemed prudent to map them here to the expected standard names (and provide a general purpose target-dependent mapping for any future formats).
Otherwise I need some other way to recognize that the section with the name "__debug_str_offs" is supposed to represent the string offset section in a Mach-O object file.

lib/DebugInfo/DWARF/DWARFFormValue.cpp

608–610

I was just trying to fit the new functionality into the existing structure but I'll give it a shot.

lib/DebugInfo/DWARF/DWARFTypeUnit.cpp

27–30

This is actually a bugfix. The previous code neglected to take the leading length field into account. This was no big deal since the remainder of the type unit DIE is always longer than 4 anyway. It only showed up in a hand-constructed test case where it wasn't.

In any case, I'll be happy to separate this out as an independent bug fix. Perhaps separating out DWARF64 support in general would be better?

lib/DebugInfo/DWARF/DWARFUnit.cpp

81

Ahem, no. I must confess I was only marginally aware of DWP. I have to give it another look.

[dblaikie]

lib/DebugInfo/DWARF/DWARFContext.cpp

1047–1050

Perhaps the mapping could/should be done after the stripping below? Then fewer cases would need to be handled? Only debug_str_offsets, in fact?

(which would help explain my uncertainty/confusion as to how this wasn't changing existing cases since it seems to be remapping all sorts of section names that weren't modified previously - only because they all collapse back to the same thing after the substr+find_first_not_of case below)

lib/DebugInfo/DWARF/DWARFTypeUnit.cpp

27–30

Independent bug fixes should be separate - easier to review, make sure they're tested, etc.

As for separating DWARF64 support for str_offsets in general? Eh, if it looks nice separately & makes it clearer, OK - if it seems to work well together but still clear that it needs/has separate test coverage, that's OK too.

[wolfgangp]

lib/DebugInfo/DWARF/DWARFTypeUnit.cpp

27–30

Independent bug fixes should be separate - easier to review, make sure they're tested, etc.

I split this off as https://reviews.llvm.org/D32987

[wolfgangp]

1. Added tests for invalid formatting of the string offsets section (hand-constructed DWARF).
2. Fixed a bug found with handling of dwp files and added a hand-constructed test for it.
3. Addressed review comments: a) rewrote validation of string offset table contribution headers b) moved mapping of debug section names to after stripping of leading _ or .
4. Using the word 'contribution' instead of 'segment' when displaying the string offsets table.

[wolfgangp]

lib/DebugInfo/DWARF/DWARFContext.cpp

118

Yes, thanks for catching that.

lib/DebugInfo/DWARF/DWARFFormValue.cpp

608–610

Looked at this for a while, but couldn't come up with a better way to write it. Do you have any suggestions?

[dblaikie]

A few things to tidy up, but looks plausible.

lib/DebugInfo/DWARF/DWARFContext.cpp

133

Move the declaration to the first use:

uint64_t StringOffset = getRelocatedValue(...

137–141

Probably drop the {} from single line blocks - that tends to be how most of the LLVM code is written.

319–337

Might be worthsinking this all into the dumpStringOffsetsSection function? (potentially pulling out the current function contents as dumpDwarf5StringOffsetsSection or the like?)

test/DebugInfo/dwarfdump-str-offsets-invalid.test

1–9 ↗

(On Diff #100144)

Should these print error messages of some kind? I mean I realize most of dwarfdump is pretty relaxed about error handling, so perhaps it doesn't make much sense to add more just here - but worth a thought.

test/DebugInfo/dwarfdump-str-offsets.test

58–68

Reckon it'd be worth printing the strings that these offsets refer to here? (since the strings are indirected and printed in the debug_info (which has to go through this table and then on to the strings table) it seems weird to have them missing here, maybe?

[wolfgangp]

The patch has been accepted but in order to address the last review comments some non-trivial changes were necessary, so it probably needs another look.

1. error messages will now be emitted when we find invalid contributions to the string offsets table. One test has been added to address the case where we encounter a degenerate .debug_str_offsets section (without a v5 unit present).

2. Per Dave's suggestion the routines dumping the string offsets table have been reorganized a bit, so now the main dump routine for DWARFContext looks cleaner. Dumping a DWARF v5 string offsets table keys off whether we find a unit with version 5 or greater. Otherwise we dump a monolithic table. That means that the *invalid* tests had to be enhanced a bit to contain at least a rudimentary v5 compile unit.

3. Dumping the string offsets table now also displays the strings, so the respective test has been updated.

[wolfgangp]

test/DebugInfo/dwarfdump-str-offsets.test

58–68

I agree. I wasn't sure if somebody who is exclusively looking at the string offsets table would really be interested but there is no reason not to have the strings there as well.

[dblaikie]

Oops, forgot to say anything in my approval so it didn't send mail to the list.

Looks good - please submit. :)

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:
   DWARFCompileUnit *getDWOCompileUnitAtIndex(unsigned index) {
     parseDWOCompileUnits();
     return DWOCUs[index].get();
   }
 
   /// Get a DIE given an exact offset.
   DWARFDie getDIEForOffset(uint32_t Offset);
 
+  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 {

include/llvm/Object/MachO.h

public:
   static Triple getArchTriple(uint32_t CPUType, uint32_t CPUSubType,
                               const char **McpuDefault = nullptr,
                               const char **ArchFlag = nullptr);
   static bool isValidArch(StringRef ArchFlag);
   static Triple getHostArch();
 
   bool isRelocatableObject() const override;
 
+  StringRef mapDebugSectionName(StringRef Name) const override;
+
   bool hasPageZeroSegment() const { return HasPageZeroSegment; }
 
   static bool classof(const Binary *v) {
     return v->isMachO();
   }
 
   static uint32_t
   getVersionMinMajor(MachO::version_min_command &C, bool SDK) {

include/llvm/Object/ObjectFile.h

public:
 
   /// Returns platform-specific object flags, if any.
   virtual std::error_code getPlatformFlags(unsigned &Result) const {
     Result = 0;
     return object_error::invalid_file_type;
   }
 
   virtual std::error_code
-    getBuildAttributes(ARMAttributeParser &Attributes) const {
-      return std::error_code();
-    }
 
+  /// Maps a debug section name to a standard DWARF section name.
+  virtual StringRef mapDebugSectionName(StringRef Name) const { return Name; }
+
   /// True if this is a relocatable object (.o/.obj).
   virtual bool isRelocatableObject() const = 0;
 
   /// @returns Pointer to ObjectFile subclass to handle this type of object.
   /// @param ObjectPath The path to the object file. ObjectPath.isObject must
   ///        return true.
   /// @brief Create ObjectFile from path.
   static Expected<OwningBinary<ObjectFile>>

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);
+    // The DWARF standard mandates that the contribution size must be
+    // less than 0xfffffff0. Since 0xffffffff indicates DWARF64, we
+    // reject the range from 0xfffffff0 to 0xfffffffe.
+    if (SegmentSize > 0xfffffff0 && SegmentSize < 0xffffffff)
+      return;
+    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 v5 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)
if (Decompressor::isCompressed(Section)) {
         continue;
       SmallString<32> Out;
       if (auto Err = Decompressor->decompress(Out))
         continue;
       UncompressedSections.emplace_back(std::move(Out));
       data = UncompressedSections.back();
     }
 
+    // Map platform specific debug section names to DWARF standard section
+    // names.
+    name = Obj.mapDebugSectionName(name);
+
     // Compressed sections names in GNU style starts from ".z",
     // at this point section is decompressed and we drop compression prefix.
     name = name.substr(
         name.find_first_not_of("._z")); // Skip ".", "z" and "_" prefixes.
 
     if (StringRef *SectionData = MapSectionToMember(name)) {
       *SectionData = data;
       if (name == "debug_ranges") {
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

DwarfGnuPubNamesSection =
       Ctx->getMachOSection("__DWARF", "__debug_gnu_pubn", MachO::S_ATTR_DEBUG,
                            SectionKind::getMetadata());
   DwarfGnuPubTypesSection =
       Ctx->getMachOSection("__DWARF", "__debug_gnu_pubt", MachO::S_ATTR_DEBUG,
                            SectionKind::getMetadata());
   DwarfStrSection =
       Ctx->getMachOSection("__DWARF", "__debug_str", MachO::S_ATTR_DEBUG,
                            SectionKind::getMetadata(), "info_string");
+  DwarfStrOffSection =
+      Ctx->getMachOSection("__DWARF", "__debug_str_offs", MachO::S_ATTR_DEBUG,
+                           SectionKind::getMetadata(), "section_str_off");
   DwarfLocSection =
       Ctx->getMachOSection("__DWARF", "__debug_loc", MachO::S_ATTR_DEBUG,
                            SectionKind::getMetadata(), "section_debug_loc");
   DwarfARangesSection =
       Ctx->getMachOSection("__DWARF", "__debug_aranges", MachO::S_ATTR_DEBUG,
                            SectionKind::getMetadata());
   DwarfRangesSection =
       Ctx->getMachOSection("__DWARF", "__debug_ranges", MachO::S_ATTR_DEBUG,
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 =
       Ctx->getELFSection(".debug_str.dwo", DebugSecType,
                          ELF::SHF_MERGE | ELF::SHF_STRINGS, 1, "");
   DwarfLineDWOSection =
       Ctx->getELFSection(".debug_line.dwo", DebugSecType, 0);
   DwarfLocDWOSection =
       Ctx->getELFSection(".debug_loc.dwo", DebugSecType, 0);
   DwarfStrOffDWOSection =
       Ctx->getELFSection(".debug_str_offsets.dwo", DebugSecType, 0);
-  DwarfAddrSection = Ctx->getELFSection(".debug_addr", DebugSecType, 0);
 
   // DWP Sections
   DwarfCUIndexSection =
       Ctx->getELFSection(".debug_cu_index", DebugSecType, 0);
   DwarfTUIndexSection =
       Ctx->getELFSection(".debug_tu_index", DebugSecType, 0);
 
   StackMapSection =
DwarfGnuPubTypesSection = Ctx->getCOFFSection(
       COFF::IMAGE_SCN_MEM_DISCARDABLE | COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
           COFF::IMAGE_SCN_MEM_READ,
       SectionKind::getMetadata());
   DwarfStrSection = Ctx->getCOFFSection(
       ".debug_str",
       COFF::IMAGE_SCN_MEM_DISCARDABLE | COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
           COFF::IMAGE_SCN_MEM_READ,
       SectionKind::getMetadata(), "info_string");
+  DwarfStrOffSection = Ctx->getCOFFSection(
+      ".debug_str_offsets",
+      COFF::IMAGE_SCN_MEM_DISCARDABLE | COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
+          COFF::IMAGE_SCN_MEM_READ,
+      SectionKind::getMetadata(), "section_str_off");
   DwarfLocSection = Ctx->getCOFFSection(
       ".debug_loc",
       COFF::IMAGE_SCN_MEM_DISCARDABLE | COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
           COFF::IMAGE_SCN_MEM_READ,
       SectionKind::getMetadata(), "section_debug_loc");
   DwarfARangesSection = Ctx->getCOFFSection(
       ".debug_aranges",
       COFF::IMAGE_SCN_MEM_DISCARDABLE | COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
DwarfLocDWOSection = Ctx->getCOFFSection(
       ".debug_loc.dwo",
       COFF::IMAGE_SCN_MEM_DISCARDABLE | COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
           COFF::IMAGE_SCN_MEM_READ,
       SectionKind::getMetadata(), "skel_loc");
   DwarfStrOffDWOSection = Ctx->getCOFFSection(
       ".debug_str_offsets.dwo",
       COFF::IMAGE_SCN_MEM_DISCARDABLE | COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
           COFF::IMAGE_SCN_MEM_READ,
-      SectionKind::getMetadata());
+      SectionKind::getMetadata(), "section_str_off_dwo");
   DwarfAddrSection = Ctx->getCOFFSection(
       ".debug_addr",
       COFF::IMAGE_SCN_MEM_DISCARDABLE | COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
           COFF::IMAGE_SCN_MEM_READ,
       SectionKind::getMetadata(), "addr_sec");
   DwarfCUIndexSection = Ctx->getCOFFSection(
       ".debug_cu_index",
       COFF::IMAGE_SCN_MEM_DISCARDABLE | COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |

lib/Object/MachOObjectFile.cpp

if (Magic == "\xFE\xED\xFA\xCF")
     return MachOObjectFile::create(Buffer, false, true,
                                    UniversalCputype, UniversalIndex);
   if (Magic == "\xCF\xFA\xED\xFE")
     return MachOObjectFile::create(Buffer, true, true,
                                    UniversalCputype, UniversalIndex);
   return make_error<GenericBinaryError>("Unrecognized MachO magic number",
                                         object_error::invalid_file_type);
 }
+
+StringRef MachOObjectFile::mapDebugSectionName(StringRef Name) const {
+  return StringSwitch<StringRef>(Name)
+      .Case("__debug_abbrev", ".debug_abbrev")
+      .Case("__debug_info", ".debug_info")
+      .Case("__debug_line", ".debug_line")
+      .Case("__debug_frame", ".debug_frame")
+      .Case("__debug_str", ".debug_str")
+      .Case("__debug_str_offs", ".debug_str_offsets")
+      .Default(Name);
+}

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;