Emit a .debug_str_offsets section with dsymutil to support DW_FORM_strx in dsymutil.

[rastogishubham]

Summary

With this change, dsymutil can emit a .debug_str_offsets section, therefore it can also emit DW_FORM_strx in the .debug_info section.

I elected to emit only one .debug_str_offset contribution for all compile units, because any shared strings between compile units wouldn't be assigned different offsets for different compile units. Therefore, dsymutil rewrites every DW_AT_str_offsets_base to 8 which is the size of the .debug_str_offsets section header and the start of the offsets for all compile units.

Before this change, the size of the .debug_info section + .debug_str section was for clang.dSYM ~1.17 GB
After this change, the size of the .debug_info section + .debug_str section + .debug_str_offsets section is ~1.12 GB

This results in a 4.35% size decrease

[avl]

llvm/lib/DWARFLinker/DWARFLinker.cpp

1063

I would suggest to use DwarfVersion as a sign of which resulting form would be used:

if (DwarfVersion >= 5) {
      // Switch everything to DW_FORM_strx strings.
      auto StringOffsetIndex =
          StringOffsetPool.getValueIndex(StringEntry.getOffset());
      return Die
          .addValue(DIEAlloc, AttrSpec.Attr,
                    dwarf::DW_FORM_strx, DIEInteger(StringOffsetIndex))
          ->sizeOf(U.getFormParams());
}

    // Switch everything to DW_FORM_strp strings.
    return Die
          .addValue(DIEAlloc, AttrSpec.Attr,
                    dwarf::DW_FORM_strp, DIEInteger(StringEntry.getOffset()))
          ->sizeOf(U.getFormParams());

This allows to save more space if original CU is of 5 version but uses DW_FORM_strp forms. Also it would allow to simplify patch by removing StrxFoundInCU and AttrStrOffsetBaseSeen flags.

Though we would need to pay attention to the case when original CU of 5 dwarf version does not have DW_AT_str_offsets_base because it uses DW_FORM_strp forms. We would need to add DW_AT_str_offsets_base in that case.

[aprantl]

This results in a 4.35% size decrease

Sweet.

llvm/lib/DWARFLinker/DWARFLinker.cpp

1063

That seems reasonable — if makes the patch simpler.

1068

Very nitpicky nit: it's DIE because it's an abbreviation for Debug Info Entry ;-)

2025

Just double-checking that this is really unreachable, even with malformed input?

2592

If I'm reading the DWARF spec correctly, isn't the header size 4+2+2 in DWARF32 and 4+8+2+2 in DWARF64?

[rastogishubham]

All dwarf 5 cus get their strings converted to strxs.

[rastogishubham]

llvm/lib/DWARFLinker/DWARFLinker.cpp

2025

With the updates to the patch, this should truly be unreachable

2592

Yes, but we only emit DWARF32 on our platforms

[avl]

Thank you for the update. Would you mind creating the test case for DW_AT_str_offsets_base and debug_str_offsets, please?(similar to dwarf5-addr_base.test, i.e. several compile units, update/no-update). And, probably, add checks for strings forms into the dwarf5-dwarf4-combination-macho.test(that dwarf5 has all required new forms, and dwarf4 still uses old forms), please.

llvm/include/llvm/DWARFLinker/DWARFLinker.h

665

there is AttributesInfo structure which keeps exactly that kind of info. it would be good to make AttrStrOffsetBaseSeen to be member of AttributesInfo.

880

the DWARFLinkerOptions::TargetDWARFVersion version could be used instead of this additional flag. It would be set into the version 5 in case any DWARFv5 CU seen.

llvm/include/llvm/DWARFLinker/DWARFStreamer.h

85

llvm/lib/DWARFLinker/DWARFLinker.cpp

1845

It should be added to only DW_TAG_compile_unit DIEs.

2015

usage of patchStrOffsetsBase looks a bit reversed. That patch* routines are used when the value is not known at the moment the input DIE is clonned. In this concrete case the offset value is known. It would be more straightforward if proper value of DW_AT_str_offsets_base would be set in cloneScalarAttribute routine(and patchStrOffsetsBase would be removed):

unsigned DWARFLinker::DIECloner::cloneScalarAttribute()
...
if (AttrSpec.Form == dwarf::DW_AT_str_offsets_base) {
    // DWARFLinker generates common .debug_str_offsets table used for all compile units.
    // The offset to the common .debug_str_offsets table is 8 on DWARF32.
    AttrSpec.AttrStrOffsetBaseSeen = true;
    return Die.addValue(DIEAlloc, dwarf::DW_AT_str_offsets_base,
                  dwarf::DW_FORM_sec_offset, DIEInteger(8))->sizeOf(U.getFormParams())
}
...

2944

It would probably look cleaner if checking for above conditions would be hidden inside emitStringOffsets like in emitDebugAddrSection.

llvm/lib/DWARFLinker/DWARFStreamer.cpp

262

[rastogishubham]

Thanks for the review Alexey.

Added a test to specifically check for strx and str_offsets_base, similar to dwarf5-addr_base.test. One thing to note, right now, when using --update, the strx1's get converted to strxs, I don't know if we want to change that.

Moved AttrStrOffsetBaseSeen to AttributesInfo

Removed Dwarf5CUSeen

Added check for DW_TAG_compile_unit tag when adding a DW_AT_str_offsets_base in a CU

Removed patchStrOffsetsBase, added the code to cloneScalarAttribute

Moved Dwarf5 check to emitStringOffsets

[avl]

Added a test to specifically check for strx and str_offsets_base, similar to dwarf5-addr_base.test. One thing to note, right now, when using --update, the strx1's get converted to strxs, I don't know if we want to change that.

I think that is OK. We already have the similar situation for update DWARFv4. DW_FORM_string is replaced with DW_FORM_strp.

llvm/include/llvm/DWARFLinker/DWARFLinker.h

117

llvm/lib/DWARFLinker/DWARFLinker.cpp

2024

It looks patchStrOffsetsBase is not removed still.

llvm/lib/DWARFLinker/DWARFStreamer.cpp

268

should not we check here for empty StringOffsets and return?

if (StringOffsets.empty())
  return;

llvm/test/tools/dsymutil/ARM/dwarf5-addr-base.test

48–49

Oh, excuse me, I did not notice it earlier : please, do not use underscore in file names. It is really inconvenient if underscores mixed up with hyphens. Other file names use hyphens. Please rename all of this:

Inputs/DWARF5-addr_base-str_off_base -> Inputs/DWARF5-addr-base-str-off-base 
Inputs/DWARF5-addr_base/ -> Inputs/DWARF5-addr-base/
dwarf5-addr_base.dSYM -> dwarf5-addr-base.dSYM
dwarf5-str_offsets_base-strx.test -> dwarf5-str-offsets-base-strx.test
dwarf5-addr_base.test -> dwarf5-addr-base.test

llvm/test/tools/dsymutil/ARM/dwarf5-dwarf4-combination-macho.test

66

probably:

CHECK-NOT: DW_AT_str_offsets_base

llvm/test/tools/dsymutil/ARM/dwarf5-str_offsets_base-strx.test

1 ↗

(On Diff #549131)

[rastogishubham]

llvm/lib/DWARFLinker/DWARFLinker.cpp

2024

Apologies, I forgot to remove the code, but I did add the proper code to cloneScalarAttribute

llvm/lib/DWARFLinker/DWARFStreamer.cpp

268

My thought was that if there is a DWARF5 cu, then there has to be a debug_str_offset section, but I am wrong, what if the CU doesn't have any strings?

[avl]

Thanks! LGTM.

llvm/lib/DWARFLinker/DWARFStreamer.cpp

268

Actually, that case(when CU does not have any string) looks very specific. Usually at least DW_TAG_compile_unit has a name. Anyway, it would still be good to not create empty table in this case.

llvm/include/llvm/DWARFLinker/DWARFLinker.h

virtual bool applyValidRelocs(MutableArrayRef<char> Data, uint64_t BaseOffset,
                                 bool IsLittleEndian) = 0;
 
   /// Erases all data.
   virtual void clear() = 0;
 };
 
 using Offset2UnitMap = DenseMap<uint64_t, CompileUnit *>;
 
-struct DebugAddrPool {
-  DenseMap<uint64_t, uint64_t> AddrIndexMap;
-  SmallVector<uint64_t> Addrs;
-
-  uint64_t getAddrIndex(uint64_t Addr) {
-    DenseMap<uint64_t, uint64_t>::iterator It = AddrIndexMap.find(Addr);
-    if (It == AddrIndexMap.end()) {
-      It = AddrIndexMap.insert(std::make_pair(Addr, Addrs.size())).first;
-      Addrs.push_back(Addr);
+struct DebugDieValuePool {
+  DenseMap<uint64_t, uint64_t> DieValueMap;
+  SmallVector<uint64_t> DieValues;
+
+  uint64_t getValueIndex(uint64_t Value) {
+    DenseMap<uint64_t, uint64_t>::iterator It = DieValueMap.find(Value);
+    if (It == DieValueMap.end()) {
+      It = DieValueMap.insert(std::make_pair(Value, DieValues.size())).first;
+      DieValues.push_back(Value);
     }
     return It->second;
   }
 
   void clear() {
-    AddrIndexMap.clear();
-    Addrs.clear();
+    DieValueMap.clear();
+    DieValues.clear();
   }
 };
 
 /// DwarfEmitter presents interface to generate all debug info tables.
 class DwarfEmitter {
 public:
   virtual ~DwarfEmitter();
 
   /// Emit DIE containing warnings.
   virtual void emitPaperTrailWarningsDie(DIE &Die) = 0;
 
   /// Emit section named SecName with data SecData.
   virtual void emitSectionContents(StringRef SecData, StringRef SecName) = 0;
 
   /// Emit the abbreviation table \p Abbrevs to the .debug_abbrev section.
   virtual void
   emitAbbrevs(const std::vector<std::unique_ptr<DIEAbbrev>> &Abbrevs,
               unsigned DwarfVersion) = 0;
 
   /// Emit the string table described by \p Pool into .debug_str table.
   virtual void emitStrings(const NonRelocatableStringpool &Pool) = 0;
 
+  /// Emit the debug string offset table described by \p StringOffsets into the
+  /// .debug_str_offsets table.
+  virtual void emitStringOffsets(const SmallVector<uint64_t> &StringOffsets,
+                                 uint16_t TargetDWARFVersion) = 0;
+
   /// Emit the string table described by \p Pool into .debug_line_str table.
   virtual void emitLineStrings(const NonRelocatableStringpool &Pool) = 0;
 
   /// Emit DWARF debug names.
   virtual void
   emitDebugNames(AccelTable<DWARF5AccelTableStaticData> &Table) = 0;
 
   /// Emit Apple namespaces accelerator table.
public:
   emitAppleTypes(AccelTable<AppleAccelTableStaticTypeData> &Table) = 0;
 
   /// Emit debug ranges (.debug_ranges, .debug_rnglists) header.
   virtual MCSymbol *emitDwarfDebugRangeListHeader(const CompileUnit &Unit) = 0;
 
   /// Emit debug ranges (.debug_ranges, .debug_rnglists) fragment.
   virtual void emitDwarfDebugRangeListFragment(
       const CompileUnit &Unit, const AddressRanges &LinkedRanges,
-      PatchLocation Patch, DebugAddrPool &AddrPool) = 0;
+      PatchLocation Patch, DebugDieValuePool &AddrPool) = 0;
 
   /// Emit debug ranges (.debug_ranges, .debug_rnglists) footer.
   virtual void emitDwarfDebugRangeListFooter(const CompileUnit &Unit,
                                              MCSymbol *EndLabel) = 0;
 
   /// Emit debug locations (.debug_loc, .debug_loclists) header.
   virtual MCSymbol *emitDwarfDebugLocListHeader(const CompileUnit &Unit) = 0;
 
   /// Emit debug locations (.debug_loc, .debug_loclists) fragment.
   virtual void emitDwarfDebugLocListFragment(
       const CompileUnit &Unit,
       const DWARFLocationExpressionsVector &LinkedLocationExpression,
-      PatchLocation Patch, DebugAddrPool &AddrPool) = 0;
+      PatchLocation Patch, DebugDieValuePool &AddrPool) = 0;
 
   /// Emit debug locations (.debug_loc, .debug_loclists) footer.
   virtual void emitDwarfDebugLocListFooter(const CompileUnit &Unit,
                                            MCSymbol *EndLabel) = 0;
 
   /// Emit .debug_addr header.
   virtual MCSymbol *emitDwarfDebugAddrsHeader(const CompileUnit &Unit) = 0;
 
Error loadClangModule(objFileLoader Loader, const DWARFDie &CUDie,
                         const std::string &PCMFile, LinkContext &Context,
                         CompileUnitHandler OnCUDieLoaded, unsigned Indent = 0);
 
   /// Clone specified Clang module unit \p Unit.
   Error cloneModuleUnit(LinkContext &Context, RefModuleUnit &Unit,
                         DeclContextTree &ODRContexts,
                         OffsetsStringPool &DebugStrPool,
                         OffsetsStringPool &DebugLineStrPool,
+                        DebugDieValuePool &StringOffsetPool,
                         unsigned Indent = 0);
 
   unsigned shouldKeepDIE(AddressesMap &RelocMgr, const DWARFDie &DIE,
                          const DWARFFile &File, CompileUnit &Unit,
                          CompileUnit::DIEInfo &MyInfo, unsigned Flags);
 
   /// This function checks whether variable has DWARF expression containing
   /// operation referencing live address(f.e. DW_OP_addr, DW_OP_addrx...).
private:
   struct DWARFLinkerOptions;
 
   class DIECloner {
     DWARFLinker &Linker;
     DwarfEmitter *Emitter;
     DWARFFile &ObjFile;
     OffsetsStringPool &DebugStrPool;
     OffsetsStringPool &DebugLineStrPool;
-    DebugAddrPool AddrPool;
+    DebugDieValuePool &StringOffsetPool;
+    DebugDieValuePool AddrPool;
 
     /// Allocator used for all the DIEValue objects.
     BumpPtrAllocator &DIEAlloc;
 
     std::vector<std::unique_ptr<CompileUnit>> &CompileUnits;
 
     /// Keeps mapping from offset of the macro table to corresponding
     /// compile unit.
     Offset2UnitMap UnitMacroMap;
 
     bool Update;
 
   public:
     DIECloner(DWARFLinker &Linker, DwarfEmitter *Emitter, DWARFFile &ObjFile,
               BumpPtrAllocator &DIEAlloc,
               std::vector<std::unique_ptr<CompileUnit>> &CompileUnits,
               bool Update, OffsetsStringPool &DebugStrPool,
-              OffsetsStringPool &DebugLineStrPool)
+              OffsetsStringPool &DebugLineStrPool,
+              DebugDieValuePool &StringOffsetPool)
         : Linker(Linker), Emitter(Emitter), ObjFile(ObjFile),
           DebugStrPool(DebugStrPool), DebugLineStrPool(DebugLineStrPool),
-          DIEAlloc(DIEAlloc), CompileUnits(CompileUnits), Update(Update) {}
+          StringOffsetPool(StringOffsetPool), DIEAlloc(DIEAlloc),
+          CompileUnits(CompileUnits), Update(Update) {}
 
     /// Recursively clone \p InputDIE into an tree of DIE objects
     /// where useless (as decided by lookForDIEsToKeep()) bits have been
     /// stripped out and addresses have been rewritten according to the
     /// address map.
     ///
     /// \param OutOffset is the offset the cloned DIE in the output
     /// compile unit.
struct AttributesInfo {
       bool HasLowPc = false;
 
       /// Does the DIE have a ranges attribute?
       bool HasRanges = false;
 
       /// Is this DIE only a declaration?
       bool IsDeclaration = false;
 
+      /// Is there a DW_AT_str_offsets_base in the CU?
+      bool AttrStrOffsetBaseSeen = false;
+
       AttributesInfo() = default;
     };
 
     /// Helper for cloneDIE.
     unsigned cloneAttribute(DIE &Die, const DWARFDie &InputDIE,
                             const DWARFFile &File, CompileUnit &U,
                             const DWARFFormValue &Val,
                             const AttributeSpec AttrSpec, unsigned AttrSize,
private:
   };
 
   /// Assign an abbreviation number to \p Abbrev
   void assignAbbrev(DIEAbbrev &Abbrev);
 
   /// Compute and emit debug ranges(.debug_aranges, .debug_ranges,
   /// .debug_rnglists) for \p Unit, patch the attributes referencing it.
   void generateUnitRanges(CompileUnit &Unit, const DWARFFile &File,
-                          DebugAddrPool &AddrPool) const;
+                          DebugDieValuePool &AddrPool) const;
 
   /// Emit the accelerator entries for \p Unit.
   void emitAcceleratorEntriesForUnit(CompileUnit &Unit);
 
   /// Patch the frame info for an object file and emit it.
   void patchFrameInfoForObject(LinkContext &Context);
 
   /// FoldingSet that uniques the abbreviations.
private:
   StringMap<uint32_t> EmittedCIEs;
 
   /// Offset of the last CIE that has been emitted in the output
   /// .debug_frame section.
   uint32_t LastCIEOffset = 0;
 
   /// Apple accelerator tables.
   AccelTable<DWARF5AccelTableStaticData> DebugNames;
   AccelTable<AppleAccelTableStaticOffsetData> AppleNames;
   AccelTable<AppleAccelTableStaticOffsetData> AppleNamespaces;
   AccelTable<AppleAccelTableStaticOffsetData> AppleObjc;
   AccelTable<AppleAccelTableStaticTypeData> AppleTypes;
 
   /// Mapping the PCM filename to the DwoId.
   StringMap<uint64_t> ClangModules;
 
   DwarfLinkerClient DwarfLinkerClientID;

llvm/include/llvm/DWARFLinker/DWARFStreamer.h

public:
   void emitPaperTrailWarningsDie(DIE &Die) override;
 
   /// Emit contents of section SecName From Obj.
   void emitSectionContents(StringRef SecData, StringRef SecName) override;
 
   /// Emit the string table described by \p Pool into .debug_str table.
   void emitStrings(const NonRelocatableStringpool &Pool) override;
 
+  /// Emit the debug string offset table described by \p StringOffsets into the
+  /// .debug_str_offsets table.
+  void emitStringOffsets(const SmallVector<uint64_t> &StringOffset,
+                         uint16_t TargetDWARFVersion) override;
+
   /// Emit the string table described by \p Pool into .debug_line_str table.
   void emitLineStrings(const NonRelocatableStringpool &Pool) override;
 
   /// Emit the swift_ast section stored in \p Buffer.
   void emitSwiftAST(StringRef Buffer) override;
 
   /// Emit the swift reflection section stored in \p Buffer.
   void emitSwiftReflectionSection(
       llvm::binaryformat::Swift5ReflectionSectionKind ReflSectionKind,
       StringRef Buffer, uint32_t Alignment, uint32_t Size) override;
 
   /// Emit debug ranges(.debug_ranges, .debug_rnglists) header.
   MCSymbol *emitDwarfDebugRangeListHeader(const CompileUnit &Unit) override;
 
   /// Emit debug ranges(.debug_ranges, .debug_rnglists) fragment.
   void emitDwarfDebugRangeListFragment(const CompileUnit &Unit,
                                        const AddressRanges &LinkedRanges,
                                        PatchLocation Patch,
-                                       DebugAddrPool &AddrPool) override;
+                                       DebugDieValuePool &AddrPool) override;
 
   /// Emit debug ranges(.debug_ranges, .debug_rnglists) footer.
   void emitDwarfDebugRangeListFooter(const CompileUnit &Unit,
                                      MCSymbol *EndLabel) override;
 
   /// Emit debug locations(.debug_loc, .debug_loclists) header.
   MCSymbol *emitDwarfDebugLocListHeader(const CompileUnit &Unit) override;
 
   /// Emit .debug_addr header.
   MCSymbol *emitDwarfDebugAddrsHeader(const CompileUnit &Unit) override;
 
   /// Emit the addresses described by \p Addrs into .debug_addr table.
   void emitDwarfDebugAddrs(const SmallVector<uint64_t> &Addrs,
                            uint8_t AddrSize) override;
 
   /// Emit .debug_addr footer.
   void emitDwarfDebugAddrsFooter(const CompileUnit &Unit,
                                  MCSymbol *EndLabel) override;
 
   /// Emit debug ranges(.debug_loc, .debug_loclists) fragment.
   void emitDwarfDebugLocListFragment(
       const CompileUnit &Unit,
       const DWARFLocationExpressionsVector &LinkedLocationExpression,
-      PatchLocation Patch, DebugAddrPool &AddrPool) override;
+      PatchLocation Patch, DebugDieValuePool &AddrPool) override;
 
   /// Emit debug ranges(.debug_loc, .debug_loclists) footer.
   void emitDwarfDebugLocListFooter(const CompileUnit &Unit,
                                    MCSymbol *EndLabel) override;
 
   /// Emit .debug_aranges entries for \p Unit
   void emitDwarfDebugArangesTable(const CompileUnit &Unit,
                                   const AddressRanges &LinkedRanges) override;
private:
   void emitDwarfDebugRangesTableFragment(const CompileUnit &Unit,
                                          const AddressRanges &LinkedRanges,
                                          PatchLocation Patch);
 
   /// Emit piece of .debug_rnglists for \p LinkedRanges.
   void emitDwarfDebugRngListsTableFragment(const CompileUnit &Unit,
                                            const AddressRanges &LinkedRanges,
                                            PatchLocation Patch,
-                                           DebugAddrPool &AddrPool);
+                                           DebugDieValuePool &AddrPool);
 
   /// Emit piece of .debug_loc for \p LinkedRanges.
   void emitDwarfDebugLocTableFragment(
       const CompileUnit &Unit,
       const DWARFLocationExpressionsVector &LinkedLocationExpression,
       PatchLocation Patch);
 
   /// Emit piece of .debug_loclists for \p LinkedRanges.
   void emitDwarfDebugLocListsTableFragment(
       const CompileUnit &Unit,
       const DWARFLocationExpressionsVector &LinkedLocationExpression,
-      PatchLocation Patch, DebugAddrPool &AddrPool);
+      PatchLocation Patch, DebugDieValuePool &AddrPool);
 
   /// \defgroup Line table emission
   /// @{
   void emitLineTablePrologue(const DWARFDebugLine::Prologue &P,
                              OffsetsStringPool &DebugStrPool,
                              OffsetsStringPool &DebugLineStrPool);
   void emitLineTableString(const DWARFDebugLine::Prologue &P,
                            const DWARFFormValue &String,
private:
   uint64_t LocSectionSize = 0;
   uint64_t LocListsSectionSize = 0;
   uint64_t LineSectionSize = 0;
   uint64_t FrameSectionSize = 0;
   uint64_t DebugInfoSectionSize = 0;
   uint64_t MacInfoSectionSize = 0;
   uint64_t MacroSectionSize = 0;
   uint64_t AddrSectionSize = 0;
+  uint64_t StrOffsetSectionSize = 0;
 
   /// Keep track of emitted CUs and their Unique ID.
   struct EmittedUnit {
     unsigned ID;
     MCSymbol *LabelBegin;
   };
   std::vector<EmittedUnit> EmittedUnits;
 

llvm/lib/DWARFLinker/DWARFLinker.cpp

if (InSet) {
     Abbrev.setNumber(Abbreviations.size());
     Abbreviations.back()->setNumber(Abbreviations.size());
   }
 }
 
 unsigned DWARFLinker::DIECloner::cloneStringAttribute(DIE &Die,
                                                       AttributeSpec AttrSpec,
                                                       const DWARFFormValue &Val,
-                                                      const DWARFUnit &,
+                                                      const DWARFUnit &U,
                                                       AttributesInfo &Info) {
   std::optional<const char *> String = dwarf::toString(Val);
   if (!String)
     return 0;
-
   DwarfStringPoolEntryRef StringEntry;
   if (AttrSpec.Form == dwarf::DW_FORM_line_strp) {
     StringEntry = DebugLineStrPool.getEntry(*String);
   } else {
     StringEntry = DebugStrPool.getEntry(*String);
-
     // Update attributes info.
     if (AttrSpec.Attr == dwarf::DW_AT_name)
       Info.Name = StringEntry;
     else if (AttrSpec.Attr == dwarf::DW_AT_MIPS_linkage_name ||
              AttrSpec.Attr == dwarf::DW_AT_linkage_name)
       Info.MangledName = StringEntry;
-
+    if (U.getVersion() >= 5) {
+      // Switch everything to DW_FORM_strx strings.
+      auto StringOffsetIndex =
+          StringOffsetPool.getValueIndex(StringEntry.getOffset());
+      return Die
+          .addValue(DIEAlloc, dwarf::Attribute(AttrSpec.Attr),
+                    dwarf::DW_FORM_strx, DIEInteger(StringOffsetIndex))
+          ->sizeOf(U.getFormParams());
+    }
     // Switch everything to out of line strings.
     AttrSpec.Form = dwarf::DW_FORM_strp;
   }
-
   Die.addValue(DIEAlloc, dwarf::Attribute(AttrSpec.Attr), AttrSpec.Form,
                DIEInteger(StringEntry.getOffset()));
-
   return 4;
 }
 
 unsigned DWARFLinker::DIECloner::cloneDieReferenceAttribute(
     DIE &Die, const DWARFDie &InputDIE, AttributeSpec AttrSpec,
     unsigned AttrSize, const DWARFFormValue &Val, const DWARFFile &File,
     CompileUnit &Unit) {
   const DWARFUnit &U = Unit.getOrigUnit();
   uint64_t Ref = *Val.getAsReference();
 
   DIE *NewRefDie = nullptr;
   CompileUnit *RefUnit = nullptr;
 
   DWARFDie RefDie =
       Linker.resolveDIEReference(File, CompileUnits, Val, InputDIE, RefUnit);
 
   // If the referenced DIE is not found,  drop the attribute.
   if (!RefDie || AttrSpec.Attr == dwarf::DW_AT_sibling)
     return 0;
 
   CompileUnit::DIEInfo &RefInfo = RefUnit->getInfo(RefDie);
 
   // If we already have emitted an equivalent DeclContext, just point
   // at it.
   if (isODRAttribute(AttrSpec.Attr) && RefInfo.Ctxt &&
       RefInfo.Ctxt->getCanonicalDIEOffset()) {
     assert(RefInfo.Ctxt->hasCanonicalDIE() &&
            "Offset to canonical die is set, but context is not marked");
     DIEInteger Attr(RefInfo.Ctxt->getCanonicalDIEOffset());
     Die.addValue(DIEAlloc, dwarf::Attribute(AttrSpec.Attr),
unsigned DWARFLinker::DIECloner::cloneAddressAttribute(
   }
 
   if (AttrSpec.Form == dwarf::DW_FORM_addr) {
     Die.addValue(DIEAlloc, static_cast<dwarf::Attribute>(AttrSpec.Attr),
                  AttrSpec.Form, DIEInteger(*Addr));
     return Unit.getOrigUnit().getAddressByteSize();
   }
 
-  auto AddrIndex = AddrPool.getAddrIndex(*Addr);
+  auto AddrIndex = AddrPool.getValueIndex(*Addr);
 
   return Die
       .addValue(DIEAlloc, static_cast<dwarf::Attribute>(AttrSpec.Attr),
                 dwarf::Form::DW_FORM_addrx, DIEInteger(AddrIndex))
       ->sizeOf(Unit.getOrigUnit().getFormParams());
 }
 
 unsigned DWARFLinker::DIECloner::cloneScalarAttribute(
unsigned DWARFLinker::DIECloner::cloneScalarAttribute(
   if (AttrSpec.Attr == dwarf::DW_AT_macros) {
     if (std::optional<uint64_t> Offset = Val.getAsSectionOffset()) {
       const DWARFDebugMacro *Macro = File.Dwarf->getDebugMacro();
       if (Macro == nullptr || !Macro->hasEntryForOffset(*Offset))
         return 0;
     }
   }
 
+  if (AttrSpec.Attr == dwarf::DW_AT_str_offsets_base) {
+    // DWARFLinker generates common .debug_str_offsets table used for all
+    // compile units. The offset to the common .debug_str_offsets table is 8 on
+    // DWARF32.
+    Info.AttrStrOffsetBaseSeen = true;
+    return Die
+        .addValue(DIEAlloc, dwarf::DW_AT_str_offsets_base,
+                  dwarf::DW_FORM_sec_offset, DIEInteger(8))
+        ->sizeOf(Unit.getOrigUnit().getFormParams());
+  }
+
   if (LLVM_UNLIKELY(Linker.Options.Update)) {
     if (auto OptionalValue = Val.getAsUnsignedConstant())
       Value = *OptionalValue;
     else if (auto OptionalValue = Val.getAsSignedConstant())
       Value = *OptionalValue;
     else if (auto OptionalValue = Val.getAsSectionOffset())
       Value = *OptionalValue;
     else {
shouldSkipAttribute(bool Update,
   case dwarf::DW_AT_ranges:
     return !Update && SkipPC;
   case dwarf::DW_AT_rnglists_base:
     // In case !Update the .debug_addr table is not generated/preserved.
     // Thus instead of DW_FORM_rnglistx the DW_FORM_sec_offset is used.
     // Since DW_AT_rnglists_base is used for only DW_FORM_rnglistx the
     // DW_AT_rnglists_base is removed.
     return !Update;
-  case dwarf::DW_AT_str_offsets_base:
-    // FIXME: Use the string offset table with Dwarf 5.
-    return true;
   case dwarf::DW_AT_loclists_base:
     // In case !Update the .debug_addr table is not generated/preserved.
     // Thus instead of DW_FORM_loclistx the DW_FORM_sec_offset is used.
     // Since DW_AT_loclists_base is used for only DW_FORM_loclistx the
     // DW_AT_loclists_base is removed.
     return !Update;
   case dwarf::DW_AT_location:
   case dwarf::DW_AT_frame_base:
DIE *DWARFLinker::DIECloner::cloneDIE(const DWARFDie &InputDIE,
   for (auto Child : InputDIE.children()) {
     unsigned Idx = U.getDIEIndex(Child);
     if (Unit.getInfo(Idx).Keep) {
       HasChildren = true;
       break;
     }
   }
 
+  if (Unit.getOrigUnit().getVersion() >= 5 && !AttrInfo.AttrStrOffsetBaseSeen &&
+      Die->getTag() == dwarf::DW_TAG_compile_unit) {
+    // No DW_AT_str_offsets_base seen, add it to the DIE.
+    Die->addValue(DIEAlloc, dwarf::DW_AT_str_offsets_base,
+                  dwarf::DW_FORM_sec_offset, DIEInteger(8));
+    OutOffset += 4;
+  }
+
   DIEAbbrev NewAbbrev = Die->generateAbbrev();
   if (HasChildren)
     NewAbbrev.setChildrenFlag(dwarf::DW_CHILDREN_yes);
   // Assign a permanent abbrev number
   Linker.assignAbbrev(NewAbbrev);
   Die->setAbbrevNumber(NewAbbrev.getNumber());
 
   // Add the size of the abbreviation number to the output offset.
   OutOffset += getULEB128Size(Die->getAbbrevNumber());
 
   if (!HasChildren) {
     // Update our size.
     Die->setSize(OutOffset - Die->getOffset());
     return Die;
   }
 
   // Recursively clone children.
   for (auto Child : InputDIE.children()) {
     if (DIE *Clone = cloneDIE(Child, File, Unit, PCOffset, OutOffset, Flags,
                               IsLittleEndian)) {
       Die->addChild(Clone);
       OutOffset = Clone->getOffset() + Clone->getSize();
     }
   }
 
   // Account for the end of children marker.
   OutOffset += sizeof(int8_t);
   // Update our size.
   Die->setSize(OutOffset - Die->getOffset());
   return Die;
 }
 
 /// Patch the input object file relevant debug_ranges or debug_rnglists
 /// entries and emit them in the output file. Update the relevant attributes
 /// to point at the new entries.
 void DWARFLinker::generateUnitRanges(CompileUnit &Unit, const DWARFFile &File,
-                                     DebugAddrPool &AddrPool) const {
+                                     DebugDieValuePool &AddrPool) const {
   if (LLVM_UNLIKELY(Options.Update))
     return;
 
   const auto &FunctionRanges = Unit.getFunctionRanges();
 
   // Build set of linked address ranges for unit function ranges.
   AddressRanges LinkedFunctionRanges;
   for (const AddressRangeValuePair &Range : FunctionRanges)
void DWARFLinker::DIECloner::emitDebugAddrSection(
     const uint16_t DwarfVersion) const {
 
   if (LLVM_UNLIKELY(Linker.Options.Update))
     return;
 
   if (DwarfVersion < 5)
     return;
 
-  if (AddrPool.Addrs.empty())
+  if (AddrPool.DieValues.empty())
     return;
 
   MCSymbol *EndLabel = Emitter->emitDwarfDebugAddrsHeader(Unit);
   patchAddrBase(*Unit.getOutputUnitDIE(),
                 DIEInteger(Emitter->getDebugAddrSectionSize()));
-  Emitter->emitDwarfDebugAddrs(AddrPool.Addrs, Unit.getOrigUnit().getAddressByteSize());
+  Emitter->emitDwarfDebugAddrs(AddrPool.DieValues,
+                               Unit.getOrigUnit().getAddressByteSize());
   Emitter->emitDwarfDebugAddrsFooter(Unit, EndLabel);
 }
 
 /// Insert the new line info sequence \p Seq into the current
 /// set of already linked line info \p Rows.
 static void insertLineSequence(std::vector<DWARFDebugLine::Row> &Seq,
                                std::vector<DWARFDebugLine::Row> &Rows) {
   if (Seq.empty())
     return;
 
   if (!Rows.empty() && Rows.back().Address < Seq.front().Address) {
     llvm::append_range(Rows, Seq);
     Seq.clear();
     return;
   }
 
   object::SectionedAddress Front = Seq.front().Address;
   auto InsertPoint = partition_point(
       Rows, [=](const DWARFDebugLine::Row &O) { return O.Address < Front; });
 
   // FIXME: this only removes the unneeded end_sequence if the
   // sequences have been inserted in order. Using a global sort like
uint64_t DWARFLinker::DIECloner::cloneAllCompileUnits(
 
   if (Emitter != nullptr) {
     assert(Emitter);
     // Emit macro tables.
     Emitter->emitMacroTables(File.Dwarf.get(), UnitMacroMap, DebugStrPool);
 
     // Emit all the compile unit's debug information.
     for (auto &CurrentUnit : CompileUnits) {
       CurrentUnit->fixupForwardReferences();
 
       if (!CurrentUnit->getOutputUnitDIE())
         continue;
 
       unsigned DwarfVersion = CurrentUnit->getOrigUnit().getVersion();
 
       assert(Emitter->getDebugInfoSectionSize() ==
              CurrentUnit->getStartOffset());
Error DWARFLinker::link() {
   // parallel loop.
   unsigned NumObjects = ObjectContexts.size();
 
   // This Dwarf string pool which is used for emission. It must be used
   // serially as the order of calling getStringOffset matters for
   // reproducibility.
   OffsetsStringPool DebugStrPool(StringsTranslator, true);
   OffsetsStringPool DebugLineStrPool(StringsTranslator, false);
+  DebugDieValuePool StringOffsetPool;
 
   // ODR Contexts for the optimize.
   DeclContextTree ODRContexts;
 
   for (LinkContext &OptContext : ObjectContexts) {
     if (Options.Verbose) {
       if (DwarfLinkerClientID == DwarfLinkerClient::Dsymutil)
         outs() << "DEBUG MAP OBJECT: " << OptContext.File.FileName << "\n";
for (const auto &CU : OptContext.File.Dwarf->compile_units()) {
         DumpOpts.ChildRecurseDepth = 0;
         DumpOpts.Verbose = Options.Verbose;
         CUDie.dump(outs(), 0, DumpOpts);
       }
     }
 
     for (auto &CU : OptContext.ModuleUnits) {
       if (Error Err = cloneModuleUnit(OptContext, CU, ODRContexts, DebugStrPool,
-                                      DebugLineStrPool))
+                                      DebugLineStrPool, StringOffsetPool))
         reportWarning(toString(std::move(Err)), CU.File);
     }
   }
 
   // At this point we know how much data we have emitted. We use this value to
   // compare canonical DIE offsets in analyzeContextInfo to see if a definition
   // is already emitted, without being affected by canonical die offsets set
   // later. This prevents undeterminism when analyze and clone execute
#endif
     // need to reset the NextValidReloc index to the beginning.
     if (OptContext.File.Addresses->hasValidRelocs() ||
         LLVM_UNLIKELY(Options.Update)) {
       SizeByObject[OptContext.File.FileName].Input =
           getDebugInfoSize(*OptContext.File.Dwarf);
       SizeByObject[OptContext.File.FileName].Output =
           DIECloner(*this, TheDwarfEmitter.get(), OptContext.File, DIEAlloc,
                     OptContext.CompileUnits, Options.Update, DebugStrPool,
-                    DebugLineStrPool)
+                    DebugLineStrPool, StringOffsetPool)
               .cloneAllCompileUnits(*OptContext.File.Dwarf, OptContext.File,
                                     OptContext.File.Dwarf->isLittleEndian());
     }
     if ((TheDwarfEmitter != nullptr) && !OptContext.CompileUnits.empty() &&
         LLVM_LIKELY(!Options.Update))
       patchFrameInfoForObject(OptContext);
 
     // Clean-up before starting working on the next object.
     cleanupAuxiliarryData(OptContext);
   };
 
   auto EmitLambda = [&]() {
     // Emit everything that's global.
     if (TheDwarfEmitter != nullptr) {
       TheDwarfEmitter->emitAbbrevs(Abbreviations, Options.TargetDWARFVersion);
       TheDwarfEmitter->emitStrings(DebugStrPool);
+      TheDwarfEmitter->emitStringOffsets(StringOffsetPool.DieValues,
+                                         Options.TargetDWARFVersion);
       TheDwarfEmitter->emitLineStrings(DebugLineStrPool);
       for (AccelTableKind TableKind : Options.AccelTables) {
         switch (TableKind) {
         case AccelTableKind::Apple:
           TheDwarfEmitter->emitAppleNamespaces(AppleNamespaces);
           TheDwarfEmitter->emitAppleNames(AppleNames);
           TheDwarfEmitter->emitAppleTypes(AppleTypes);
           TheDwarfEmitter->emitAppleObjc(AppleObjc);
auto AnalyzeAll = [&]() {
     }
   };
 
   auto CloneAll = [&]() {
     for (unsigned I = 0, E = NumObjects; I != E; ++I) {
       {
         std::unique_lock<std::mutex> LockGuard(ProcessedFilesMutex);
         if (!ProcessedFiles[I]) {
           ProcessedFilesConditionVariable.wait(
               LockGuard, [&]() { return ProcessedFiles[I]; });
         }
       }
 
       CloneLambda(I);
     }
     EmitLambda();
   };
#endif
 
   return Error::success();
 }
 
 Error DWARFLinker::cloneModuleUnit(LinkContext &Context, RefModuleUnit &Unit,
                                    DeclContextTree &ODRContexts,
                                    OffsetsStringPool &DebugStrPool,
                                    OffsetsStringPool &DebugLineStrPool,
+                                   DebugDieValuePool &StringOffsetPool,
                                    unsigned Indent) {
   assert(Unit.Unit.get() != nullptr);
 
   if (!Unit.Unit->getOrigUnit().getUnitDIE().hasChildren())
     return Error::success();
 
   if (Options.Verbose) {
     outs().indent(Indent);
Error DWARFLinker::cloneModuleUnit(LinkContext &Context, RefModuleUnit &Unit,
   // Keep everything.
   Unit.Unit->markEverythingAsKept();
 
   // Clone unit.
   UnitListTy CompileUnits;
   CompileUnits.emplace_back(std::move(Unit.Unit));
   assert(TheDwarfEmitter);
   DIECloner(*this, TheDwarfEmitter.get(), Unit.File, DIEAlloc, CompileUnits,
-            Options.Update, DebugStrPool, DebugLineStrPool)
+            Options.Update, DebugStrPool, DebugLineStrPool, StringOffsetPool)
       .cloneAllCompileUnits(*Unit.File.Dwarf, Unit.File,
                             Unit.File.Dwarf->isLittleEndian());
   return Error::success();
 }
 
 void DWARFLinker::verifyInput(const DWARFFile &File) {
   assert(File.Dwarf);
 

llvm/lib/DWARFLinker/DWARFStreamer.cpp

void DwarfStreamer::emitStrings(const NonRelocatableStringpool &Pool) {
   for (auto Entry : Entries) {
     // Emit the string itself.
     Asm->OutStreamer->emitBytes(Entry.getString());
     // Emit a null terminator.
     Asm->emitInt8(0);
   }
 }
 
+/// Emit the debug string offset table described by \p StringOffsets into the
+/// .debug_str_offsets table.
+void DwarfStreamer::emitStringOffsets(
+    const SmallVector<uint64_t> &StringOffsets, uint16_t TargetDWARFVersion) {
+
+  if (TargetDWARFVersion < 5 || StringOffsets.empty())
+    return;
+
+  Asm->OutStreamer->switchSection(MOFI->getDwarfStrOffSection());
+
+  MCSymbol *BeginLabel = Asm->createTempSymbol("Bdebugstroff");
+  MCSymbol *EndLabel = Asm->createTempSymbol("Edebugstroff");
+
+  // Length.
+  Asm->emitLabelDifference(EndLabel, BeginLabel, sizeof(uint32_t));
+  Asm->OutStreamer->emitLabel(BeginLabel);
+  StrOffsetSectionSize += sizeof(uint32_t);
+
+  // Version.
+  MS->emitInt16(5);
+  StrOffsetSectionSize += sizeof(uint16_t);
+
+  // Padding.
+  MS->emitInt16(0);
+  StrOffsetSectionSize += sizeof(uint16_t);
+
+  for (auto Off : StringOffsets) {
+    Asm->OutStreamer->emitInt32(Off);
+    StrOffsetSectionSize += sizeof(uint32_t);
+  }
+  Asm->OutStreamer->emitLabel(EndLabel);
+}
+
 /// Emit the debug_line_str section stored in \p Pool.
 void DwarfStreamer::emitLineStrings(const NonRelocatableStringpool &Pool) {
   Asm->OutStreamer->switchSection(MOFI->getDwarfLineStrSection());
   std::vector<DwarfStringPoolEntryRef> Entries = Pool.getEntriesForEmission();
   for (auto Entry : Entries) {
     // Emit the string itself.
     Asm->OutStreamer->emitBytes(Entry.getString());
     // Emit a null terminator.
DwarfStreamer::emitDwarfDebugRangeListHeader(const CompileUnit &Unit) {
   MS->emitInt32(0);
   RngListsSectionSize += sizeof(uint32_t);
 
   return EndLabel;
 }
 
 void DwarfStreamer::emitDwarfDebugRangeListFragment(
     const CompileUnit &Unit, const AddressRanges &LinkedRanges,
-    PatchLocation Patch, DebugAddrPool &AddrPool) {
+    PatchLocation Patch, DebugDieValuePool &AddrPool) {
   if (Unit.getOrigUnit().getVersion() < 5) {
     emitDwarfDebugRangesTableFragment(Unit, LinkedRanges, Patch);
     return;
   }
 
   emitDwarfDebugRngListsTableFragment(Unit, LinkedRanges, Patch, AddrPool);
 }
 
 void DwarfStreamer::emitDwarfDebugRangeListFooter(const CompileUnit &Unit,
                                                   MCSymbol *EndLabel) {
   if (Unit.getOrigUnit().getVersion() < 5)
     return;
 
   // Make .debug_rnglists to be current section.
   MS->switchSection(MC->getObjectFileInfo()->getDwarfRnglistsSection());
 
   if (EndLabel != nullptr)
     Asm->OutStreamer->emitLabel(EndLabel);
 }
 
 void DwarfStreamer::emitDwarfDebugRngListsTableFragment(
     const CompileUnit &Unit, const AddressRanges &LinkedRanges,
-    PatchLocation Patch, DebugAddrPool &AddrPool) {
+    PatchLocation Patch, DebugDieValuePool &AddrPool) {
   Patch.set(RngListsSectionSize);
 
   // Make .debug_rnglists to be current section.
   MS->switchSection(MC->getObjectFileInfo()->getDwarfRnglistsSection());
   std::optional<uint64_t> BaseAddress;
 
   for (const AddressRange &Range : LinkedRanges) {
 
     if (!BaseAddress) {
       BaseAddress = Range.start();
 
       // Emit base address.
       MS->emitInt8(dwarf::DW_RLE_base_addressx);
       RngListsSectionSize += 1;
       RngListsSectionSize +=
-          MS->emitULEB128IntValue(AddrPool.getAddrIndex(*BaseAddress));
+          MS->emitULEB128IntValue(AddrPool.getValueIndex(*BaseAddress));
     }
 
     // Emit type of entry.
     MS->emitInt8(dwarf::DW_RLE_offset_pair);
     RngListsSectionSize += 1;
 
     // Emit start offset relative to base address.
     RngListsSectionSize +=
MCSymbol *DwarfStreamer::emitDwarfDebugLocListHeader(const CompileUnit &Unit) {
 
   return EndLabel;
 }
 
 /// Emit debug locations(.debug_loc, .debug_loclists) fragment.
 void DwarfStreamer::emitDwarfDebugLocListFragment(
     const CompileUnit &Unit,
     const DWARFLocationExpressionsVector &LinkedLocationExpression,
-    PatchLocation Patch, DebugAddrPool &AddrPool) {
+    PatchLocation Patch, DebugDieValuePool &AddrPool) {
   if (Unit.getOrigUnit().getVersion() < 5) {
     emitDwarfDebugLocTableFragment(Unit, LinkedLocationExpression, Patch);
     return;
   }
 
   emitDwarfDebugLocListsTableFragment(Unit, LinkedLocationExpression, Patch,
                                       AddrPool);
 }
void DwarfStreamer::emitDwarfDebugAddrsFooter(const CompileUnit &Unit,
   if (EndLabel != nullptr)
     Asm->OutStreamer->emitLabel(EndLabel);
 }
 
 /// Emit piece of .debug_loclists for \p LinkedLocationExpression.
 void DwarfStreamer::emitDwarfDebugLocListsTableFragment(
     const CompileUnit &Unit,
     const DWARFLocationExpressionsVector &LinkedLocationExpression,
-    PatchLocation Patch, DebugAddrPool &AddrPool) {
+    PatchLocation Patch, DebugDieValuePool &AddrPool) {
   Patch.set(LocListsSectionSize);
 
   // Make .debug_loclists the current section.
   MS->switchSection(MC->getObjectFileInfo()->getDwarfLoclistsSection());
   std::optional<uint64_t> BaseAddress;
 
   for (const DWARFLocationExpression &LocExpression :
        LinkedLocationExpression) {
     if (LocExpression.Range) {
 
       if (!BaseAddress) {
 
         BaseAddress = LocExpression.Range->LowPC;
 
         // Emit base address.
         MS->emitInt8(dwarf::DW_LLE_base_addressx);
         LocListsSectionSize += 1;
         LocListsSectionSize +=
-            MS->emitULEB128IntValue(AddrPool.getAddrIndex(*BaseAddress));
+            MS->emitULEB128IntValue(AddrPool.getValueIndex(*BaseAddress));
       }
 
       // Emit type of entry.
       MS->emitInt8(dwarf::DW_LLE_offset_pair);
       LocListsSectionSize += 1;
 
       // Emit start offset relative to base address.
       LocListsSectionSize +=

llvm/test/tools/dsymutil/ARM/dwarf5-addr-base.test

 ; 
 ; int baz(int x) {
 ;     return x+2;
 ; }
 
 ; clang -g -c -O1 c.cpp -gdwarf-5 -o 3.o
 
 
 RUN: rm -rf %t.dir && mkdir -p %t.dir
-RUN: dsymutil -y %p/dummy-debug-map-amr64.map -oso-prepend-path=%p/../Inputs/DWARF5-addr_base -o %t.dir/dwarf5-addr_base.dSYM
-RUN: llvm-dwarfdump %t.dir/dwarf5-addr_base.dSYM -a --verbose | FileCheck %s
+RUN: dsymutil -y %p/dummy-debug-map-amr64.map -oso-prepend-path=%p/../Inputs/DWARF5-addr-base-str-off-base -o %t.dir/dwarf5-addr-base.dSYM
+RUN: llvm-dwarfdump %t.dir/dwarf5-addr-base.dSYM -a --verbose | FileCheck %s
 
-RUN: dsymutil --update -y %p/dummy-debug-map-amr64.map -oso-prepend-path=%p/../Inputs/DWARF5-addr_base -o %t.dir/dwarf5-addr_base.dSYM
-RUN: llvm-dwarfdump %t.dir/dwarf5-addr_base.dSYM -a --verbose | FileCheck %s --check-prefix=UPD
+RUN: dsymutil --update -y %p/dummy-debug-map-amr64.map -oso-prepend-path=%p/../Inputs/DWARF5-addr-base-str-off-base -o %t.dir/dwarf5-addr-base.dSYM
+RUN: llvm-dwarfdump %t.dir/dwarf5-addr-base.dSYM -a --verbose | FileCheck %s --check-prefix=UPD
 
 CHECK: .debug_info contents:
-CHECK-NEXT: 0x00000000: Compile Unit: length = 0x00000061, format = DWARF32, version = 0x0005, unit_type = DW_UT_compile, abbr_offset = 0x0000, addr_size = 0x08 (next unit at 0x00000065)
+CHECK-NEXT: 0x00000000: Compile Unit: length = 0x0000004a, format = DWARF32, version = 0x0005, unit_type = DW_UT_compile, abbr_offset = 0x0000, addr_size = 0x08
 
 CHECK: 0x0000000c: DW_TAG_compile_unit [1] *
 CHECK:               DW_AT_addr_base [DW_FORM_sec_offset]      (0x00000008)
 
-CHECK: 0x00000037:   DW_TAG_subprogram [2] * (0x0000000c)
+CHECK: 0x0000002c:   DW_TAG_subprogram [2] * (0x0000000c)
 CHECK-NEXT:                DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000000) address = 0x[[ADDR1:[0-9a-f]+]])
 
 
-CHECK: 0x00000065: Compile Unit: length = 0x00000061, format = DWARF32, version = 0x0005, unit_type = DW_UT_compile, abbr_offset = 0x0000, addr_size = 0x08 (next unit at 0x000000ca)
+CHECK: 0x0000004e: Compile Unit: length = 0x0000004a, format = DWARF32, version = 0x0005, unit_type = DW_UT_compile, abbr_offset = 0x0000, addr_size = 0x08
 
-CHECK: 0x00000071: DW_TAG_compile_unit [1] *
+CHECK: 0x0000005a: DW_TAG_compile_unit [1] *
 CHECK:              DW_AT_addr_base [DW_FORM_sec_offset]      (0x00000018)
 
-CHECK: 0x0000009c:   DW_TAG_subprogram [2] * (0x00000071)
+CHECK: 0x0000007a:   DW_TAG_subprogram [2] * (0x0000005a)
 CHECK-NEXT:                 DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000000) address = 0x[[ADDR2:[0-9a-f]+]])
 
-CHECK: 0x000000ca: Compile Unit: length = 0x0000005a, format = DWARF32, version = 0x0005, unit_type = DW_UT_compile, abbr_offset = 0x0000, addr_size = 0x08 (next unit at 0x00000128)
+CHECK: 0x0000009c: Compile Unit: length = 0x00000043, format = DWARF32, version = 0x0005, unit_type = DW_UT_compile, abbr_offset = 0x0000, addr_size = 0x08
 
-CHECK: 0x000000d6: DW_TAG_compile_unit [5] *
+CHECK: 0x000000a8: DW_TAG_compile_unit [5] *
 CHECK: DW_AT_addr_base [DW_FORM_sec_offset]      (0x00000028)
 
-CHECK: 0x000000fa:   DW_TAG_subprogram [2] * (0x000000d6)
+CHECK: 0x000000c1:   DW_TAG_subprogram [2] * (0x000000a8)
 CHECK-NEXT:                 DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000000) address = 0x[[ADDR3:[0-9a-f]+]])
 
 CHECK: .debug_addr contents:
 CHECK-NEXT: 0x00000000: Address table header: length = 0x0000000c, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00
 CHECK-NEXT: Addrs: [
 CHECK-NEXT: 0x[[ADDR1]]
 CHECK-NEXT: ]
 CHECK-NEXT: 0x00000010: Address table header: length = 0x0000000c, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00
 CHECK-NEXT: Addrs: [
 CHECK-NEXT: 0x[[ADDR2]]
 CHECK-NEXT: ]
 CHECK-NEXT: 0x00000020: Address table header: length = 0x0000000c, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00
 CHECK-NEXT: Addrs: [
 CHECK-NEXT: 0x[[ADDR3]]
 CHECK-NEXT: ]
 
 UPD: .debug_info contents:
-UPD-NEXT: 0x00000000: Compile Unit: length = 0x000000aa, format = DWARF32, version = 0x0005, unit_type = DW_UT_compile, abbr_offset = 0x0000, addr_size = 0x08 (next unit at 0x000000ae)
+UPD-NEXT: 0x00000000: Compile Unit: length = 0x00000081, format = DWARF32, version = 0x0005, unit_type = DW_UT_compile, abbr_offset = 0x0000, addr_size = 0x08
 
 UPD: 0x0000000c: DW_TAG_compile_unit [1] *
 UPD:               DW_AT_addr_base [DW_FORM_sec_offset]      (0x00000008)
 
-UPD: 0x0000003c:   DW_TAG_subprogram [2]   (0x0000000c)
+UPD: 0x00000031:   DW_TAG_subprogram [2]   (0x0000000c)
 UPD-NEXT:                DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000000) address = 0x0000000000000018)
 
-UPD: 0x0000004e:   DW_TAG_subprogram [3] * (0x0000000c)
+UPD: 0x0000003d:   DW_TAG_subprogram [3] * (0x0000000c)
 UPD-NEXT:                 DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000001) address = 0x0000000000000000)
 
-UPD: 0x00000071:   DW_TAG_subprogram [3] * (0x0000000c)
+UPD: 0x00000057:   DW_TAG_subprogram [3] * (0x0000000c)
 UPD-NEXT:                 DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000002) address = 0x0000000000000008)
 
-UPD: 0x00000094:   DW_TAG_subprogram [5]   (0x0000000c)
+UPD: 0x00000071:   DW_TAG_subprogram [5]   (0x0000000c)
 UPD-NEXT:                 DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000003) address = 0x0000000000000010)
 
 
-UPD: 0x000000ae: Compile Unit: length = 0x00000098, format = DWARF32, version = 0x0005, unit_type = DW_UT_compile, abbr_offset = 0x0000, addr_size = 0x08 (next unit at 0x0000014a)
+UPD: 0x00000085: Compile Unit: length = 0x00000072, format = DWARF32, version = 0x0005, unit_type = DW_UT_compile, abbr_offset = 0x0000, addr_size = 0x08
 
-UPD: 0x000000ba: DW_TAG_compile_unit [1] *
+UPD: 0x00000091: DW_TAG_compile_unit [1] *
 UPD:              DW_AT_addr_base [DW_FORM_sec_offset]      (0x00000008)
 
-UPD: 0x000000ea:   DW_TAG_subprogram [2]   (0x000000ba)
+UPD: 0x000000b6:   DW_TAG_subprogram [2]   (0x00000091)
 UPD-NEXT:                 DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000000) address = 0x0000000000000018)
 
-UPD: 0x000000fc:   DW_TAG_subprogram [3] * (0x000000ba)
+UPD: 0x000000c2:   DW_TAG_subprogram [3] * (0x00000091)
 UPD-NEXT:                 DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000001) address = 0x0000000000000000)
 
-UPD: 0x0000011f:   DW_TAG_subprogram [3] * (0x000000ba)
+UPD: 0x000000dc:   DW_TAG_subprogram [3] * (0x00000091)
 UPD-NEXT:                 DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000002) address = 0x0000000000000008)
 
-UPD: 0x0000014a: Compile Unit: length = 0x0000005b, format = DWARF32, version = 0x0005, unit_type = DW_UT_compile, abbr_offset = 0x0000, addr_size = 0x08 (next unit at 0x000001a9)
+UPD: 0x000000fb: Compile Unit: length = 0x00000044, format = DWARF32, version = 0x0005, unit_type = DW_UT_compile, abbr_offset = 0x0000, addr_size = 0x08
 
-UPD: 0x00000156: DW_TAG_compile_unit [7] *
+UPD: 0x00000107: DW_TAG_compile_unit [7] *
 UPD: DW_AT_addr_base [DW_FORM_sec_offset]      (0x00000008)
 
-UPD: 0x0000017e:   DW_TAG_subprogram [3] * (0x00000156)
+UPD: 0x00000124:   DW_TAG_subprogram [3] * (0x00000107)
 UPD-NEXT:                 DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000000) address = 0x0000000000000018)
 
 UPD: .debug_addr contents:
 UPD-NEXT: 0x00000000: Address table header: length = 0x00000024, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00
 UPD-NEXT: Addrs: [
 UPD-NEXT: 0x0000000000000018
 UPD-NEXT: 0x0000000000000000
 UPD-NEXT: 0x0000000000000008

llvm/test/tools/dsymutil/ARM/dwarf5-addrx-0x0-last.test

 RUN: llvm-dwarfdump --verbose -debug-info %t.dSYM | FileCheck %s --check-prefix DEBUGINFO
 RUN: llvm-dwarfdump --verbose -debug-line %t.dSYM | FileCheck %s --check-prefix DEBUGLINE
 
 CHECK-NOT: error:
 
 DEBUGINFO:   DW_TAG_subprogram
 DEBUGINFO:     DW_AT_low_pc [DW_FORM_addrx]      (indexed (00000000) address = 0x0000000100003f4c)
 DEBUGINFO:     DW_AT_high_pc [DW_FORM_data4]   (0x00000054)
-DEBUGINFO:     DW_AT_name [DW_FORM_strp]       ( .debug_str[0x0000011c] = "main")
+DEBUGINFO:     DW_AT_name [DW_FORM_strx]       (indexed (00000007) string = "main")
 
 DEBUGLINE:  0x0000000100003f4c   4   0  {{.*}}  is_stmt
 DEBUGLINE:  0x0000000100003f6c   5  17  {{.*}}  is_stmt prologue_end
 DEBUGLINE:  0x0000000100003f70   5  22  {{.*}}
 DEBUGLINE:  0x0000000100003f74   5   7  {{.*}}
 DEBUGLINE:  0x0000000100003f78   6   3  {{.*}}  is_stmt
 DEBUGLINE:  0x0000000100003f84   7   3  {{.*}}  is_stmt
 DEBUGLINE:  0x0000000100003f94   9   3  {{.*}}  is_stmt epilogue_begin
 DEBUGLINE:  0x0000000100003fa0   9   3  {{.*}}  is_stmt end_sequence

llvm/test/tools/dsymutil/ARM/dwarf5-dwarf4-combination-macho.test

 RUN: dsymutil -y %p/dummy-debug-map-amr64.map -oso-prepend-path=%p/../Inputs/DWARF5-DWARF4-combination -o %t.dir/dwarf5-dwarf4-combination-macho.dSYM
 RUN: llvm-dwarfdump %t.dir/dwarf5-dwarf4-combination-macho.dSYM -a --verbose | FileCheck %s
 
 
 CHECK:.debug_abbrev contents:
 CHECK-NEXT: Abbrev table for offset: 0x00000000
 
 CHECK: .debug_info contents:
-CHECK: 0x00000000: Compile Unit: length = 0x00000061, format = DWARF32, version = 0x0005, unit_type = DW_UT_compile, abbr_offset = 0x0000, addr_size = 0x08 
+CHECK: 0x00000000: Compile Unit: length = 0x0000004a, format = DWARF32, version = 0x0005, unit_type = DW_UT_compile, abbr_offset = 0x0000, addr_size = 0x08 
+CHECK: DW_AT_producer [DW_FORM_strx]     (indexed (00000000) string = "Apple clang version 14.0.3 (clang-1403.0.22.14.1)")
+CHECK: DW_AT_name [DW_FORM_strx] (indexed (00000001) string = "a.cpp")
+CHECK: DW_AT_LLVM_sysroot [DW_FORM_strx] (indexed (00000002) string = "/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk")
+CHECK: DW_AT_APPLE_sdk [DW_FORM_strx]    (indexed (00000003) string = "MacOSX.sdk")
+CHECK: DW_AT_str_offsets_base [DW_FORM_sec_offset]       (0x00000008)
+CHECK: DW_AT_comp_dir [DW_FORM_strx]     (indexed (00000004) string = "/Users/shubham/Development/test109275485")
 CHECK: DW_AT_ranges [DW_FORM_sec_offset] (0x[[RANGELIST_OFFSET:[0-9a-f]+]]
 CHECK-NEXT:                  [0x[[RANGELIST_OFFSET_START:[0-9a-f]+]], 0x[[RANGELIST_OFFSET_END:[0-9a-f]+]]))
 CHECK-NEXT: DW_AT_addr_base [DW_FORM_sec_offset]      (0x00000008)
-CHECK: 0x00000037:   DW_TAG_subprogram [2] * (0x0000000c)
+CHECK: 0x0000002c:   DW_TAG_subprogram [2] * (0x0000000c)
 CHECK-NEXT:  DW_AT_low_pc [DW_FORM_addrx]     (indexed (00000000) address = 0x[[#%.16x,LOCLIST_LOWPC:]])
-CHECK: 0x0000004d:     DW_TAG_formal_parameter [3]   (0x00000037)
+CHECK: DW_AT_linkage_name [DW_FORM_strx]       (indexed (00000005) string = "_Z4foo2i")
+CHECK: DW_AT_name [DW_FORM_strx]       (indexed (00000006) string = "foo2")
+CHECK: 0x0000003c:     DW_TAG_formal_parameter [3]   (0x0000002c)
 CHECK-NEXT:                   DW_AT_location [DW_FORM_sec_offset]   (0x[[LOCLIST_OFFSET:[0-9a-f]+]]: 
 CHECK-NEXT:                      [0x[[#%.16x,LOCLIST_PAIR_START:]], 0x[[#%.16x,LOCLIST_PAIR_END:]]): [[LOCLIST_EXPR:.*]]
 CHECK-NEXT:                      [0x[[#%.16x,LOCLIST_PAIR_START2:]], 0x[[#%.16x,LOCLIST_PAIR_END2:]]): [[LOCLIST_EXPR2:.*]])
+CHECK: DW_AT_name [DW_FORM_strx]     (indexed (00000007) string = "a")
 
-CHECK: 0x00000065: Compile Unit: length = 0x00000072, format = DWARF32, version = 0x0004, abbr_offset = 0x0000, addr_size = 0x08 
+CHECK: 0x0000004e: Compile Unit: length = 0x00000072, format = DWARF32, version = 0x0004, abbr_offset = 0x0000, addr_size = 0x08 
+CHECK: DW_AT_producer [DW_FORM_strp]     ( .debug_str[0x00000001] = "Apple clang version 14.0.3 (clang-1403.0.22.14.1)")
+CHECK: DW_AT_name [DW_FORM_strp] ( .debug_str[0x000000e0] = "b.cpp")
+CHECK: DW_AT_LLVM_sysroot [DW_FORM_strp] ( .debug_str[0x00000039] = "/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk")
+CHECK: DW_AT_APPLE_sdk [DW_FORM_strp]    ( .debug_str[0x00000098] = "MacOSX.sdk")
+CHECK-NOT: DW_AT_str_offsets_base
+CHECK: DW_AT_comp_dir [DW_FORM_strp]     ( .debug_str[0x000000a3] = "/Users/shubham/Development/test109275485")
 CHECK:              DW_AT_low_pc [DW_FORM_addr]       (0x[[#%.16x,RANGE_LOWPC:]])
 CHECK-NEXT:              DW_AT_ranges [DW_FORM_sec_offset] (0x00000000
 CHECK-NEXT:                 [0x[[#%.16x,RANGE_START:]], 0x[[#%.16x,RANGE_END:]]))
-CHECK: 0x00000097:   DW_TAG_subprogram [6] * (0x00000070)
+CHECK: 0x00000080:   DW_TAG_subprogram [6] * (0x00000059)
 CHECK-NEXT:                DW_AT_low_pc [DW_FORM_addr]     (0x[[#%.16x,LOC_LOWPC:]])
-CHECK: 0x000000b4:     DW_TAG_formal_parameter [3]   (0x00000097)
+CHECK: DW_AT_linkage_name [DW_FORM_strp]       ( .debug_str[0x000000e6] = "_Z3bari")
+CHECK: DW_AT_name [DW_FORM_strp]       ( .debug_str[0x000000ee] = "bar")
+CHECK: 0x0000009d:     DW_TAG_formal_parameter [7]   (0x00000080)
 CHECK-NEXT:                  DW_AT_location [DW_FORM_sec_offset]   (0x[[LOC_OFFSET:[0-9a-f]+]]: 
 CHECK-NEXT:                     [0x[[#%.16x,LOC_PAIR_START:]], 0x[[#%.16x,LOC_PAIR_END:]]): [[LOC_EXPR:.*]]
 CHECK-NEXT:                     [0x[[#%.16x,LOC_PAIR_START2:]], 0x[[#%.16x,LOC_PAIR_END2:]]): [[LOC_EXPR2:.*]])
+CHECK: DW_AT_name [DW_FORM_strp]     ( .debug_str[0x000000f2] = "x")
 
 CHECK: .debug_loc contents:
 CHECK-NEXT: 0x[[LOC_OFFSET]]:
 CHECK-NEXT:            (0x[[#sub(LOC_PAIR_START,LOC_LOWPC)]], 0x[[#sub(LOC_PAIR_END,LOC_LOWPC)]]): [[LOC_EXPR:.*]]
 CHECK-NEXT:            (0x[[#sub(LOC_PAIR_START2,LOC_LOWPC)]], 0x[[#sub(LOC_PAIR_END2,LOC_LOWPC)]]): [[LOC_EXPR2:.*]]
 
 CHECK: .debug_loclists contents:
 CHECK-NEXT: 0x00000000: locations list header: length = 0x00000018, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000

 CHECK-NEXT: standard_opcode_lengths[DW_LNS_set_isa] = 1
 CHECK-NEXT: file_names[  1]:
 CHECK-NEXT:            name: "b.cpp"
 CHECK-NEXT:       dir_index: 0
 CHECK-NEXT:        mod_time: 0x00000000
 CHECK-NEXT:          length: 0x00000000
 
 CHECK: .debug_str contents:
+CHECK-NEXT: 0x00000000: ""
+CHECK-NEXT: 0x00000001: "Apple clang version 14.0.3 (clang-1403.0.22.14.1)"
+CHECK-NEXT: 0x00000033: "a.cpp"
+CHECK-NEXT: 0x00000039: "/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk"
+CHECK-NEXT: 0x00000098: "MacOSX.sdk"
+CHECK-NEXT: 0x000000a3: "/Users/shubham/Development/test109275485"
+CHECK-NEXT: 0x000000cc: "_Z4foo2i"
+CHECK-NEXT: 0x000000d5: "foo2"
+CHECK-NEXT: 0x000000da: "a"
+CHECK-NEXT: 0x000000dc: "int"
+CHECK-NEXT: 0x000000e0: "b.cpp"
+CHECK-NEXT: 0x000000e6: "_Z3bari"
+CHECK-NEXT: 0x000000ee: "bar"
+CHECK-NEXT: 0x000000f2: "x"
+CHECK-NEXT: 0x000000f4: "y"
 
 CHECK: .debug_line_str contents:
 CHECK-NEXT: 0x00000000: "/Users/shubham/Development/test109275485"
 CHECK-NEXT: 0x00000029: "a.cpp"
 
 CHECK: .debug_ranges contents:
 CHECK-NEXT: 00000000 [[#sub(RANGE_START,RANGE_LOWPC)]] [[#sub(RANGE_END,RANGE_LOWPC)]]
 
 CHECK: .debug_rnglists contents:
 CHECK-NEXT: 0x00000000: range list header: length = 0x0000000e, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
 CHECK-NEXT: ranges:
 CHECK-NEXT: [[RANGELIST_OFFSET]]: [DW_RLE_base_addressx]:  0x0000000000000000
 CHECK-NEXT: 0x0000000e: [DW_RLE_offset_pair  ]: {{.*}}[0x[[RANGELIST_OFFSET_START]], 0x[[RANGELIST_OFFSET_END]])
 CHECK-NEXT: 0x00000011: [DW_RLE_end_of_list  ]
 
+CHECK: .debug_str_offsets contents:
+CHECK-NEXT: 0x00000000: Contribution size = 40, Format = DWARF32, Version = 5
+CHECK-NEXT: 0x00000008: 00000001 "Apple clang version 14.0.3 (clang-1403.0.22.14.1)"
+CHECK-NEXT: 0x0000000c: 00000033 "a.cpp"
+CHECK-NEXT: 0x00000010: 00000039 "/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk"
+CHECK-NEXT: 0x00000014: 00000098 "MacOSX.sdk"
+CHECK-NEXT: 0x00000018: 000000a3 "/Users/shubham/Development/test109275485"
+CHECK-NEXT: 0x0000001c: 000000cc "_Z4foo2i"
+CHECK-NEXT: 0x00000020: 000000d5 "foo2"
+CHECK-NEXT: 0x00000024: 000000da "a"
+CHECK-NEXT: 0x00000028: 000000dc "int"
+
 CHECK: .debug_names contents:
 CHECK-NEXT: Name Index @ 0x0 {
 CHECK-NEXT:   Header {
 CHECK-NEXT:     Length: 0xBC
 CHECK-NEXT:     Format: DWARF32
 CHECK-NEXT:     Version: 5
 CHECK-NEXT:     CU count: 2
 CHECK-NEXT:     Local TU count: 0
 CHECK-NEXT:     Foreign TU count: 0
 CHECK-NEXT:     Bucket count: 5
 CHECK-NEXT:     Name count: 5
 CHECK-NEXT:     Abbreviations table size: 0x11
 CHECK-NEXT:     Augmentation: 'LLVM0700'
 CHECK-NEXT:   }

llvm/test/tools/dsymutil/ARM/dwarf5-macho.test

 RUN: rm -rf %t.dir && mkdir -p %t.dir
 RUN: dsymutil -y %p/dummy-debug-map-amr64.map -oso-prepend-path=%p/../Inputs/DWARF5 -o %t.dir/dwarf5-macho.dSYM
 RUN: llvm-dwarfdump %t.dir/dwarf5-macho.dSYM -a --verbose | FileCheck %s
 
 CHECK:.debug_abbrev contents:
 CHECK-NEXT: Abbrev table for offset: 0x00000000
 
 CHECK: .debug_info contents:
-CHECK-NEXT: Compile Unit: length = 0x00000061, format = DWARF32, version = 0x0005, unit_type = DW_UT_compile, abbr_offset = 0x0000, addr_size = 0x08 
+CHECK-NEXT: Compile Unit: length = 0x0000004a, format = DWARF32, version = 0x0005, unit_type = DW_UT_compile, abbr_offset = 0x0000, addr_size = 0x08 
 CHECK: DW_AT_ranges [DW_FORM_sec_offset] (0x[[RANGELIST_OFFSET:[0-9a-f]+]]
 CHECK-NEXT:                  [0x[[RANGELIST_OFFSET_START:[0-9a-f]+]], 0x[[RANGELIST_OFFSET_END:[0-9a-f]+]]))
 CHECK-NEXT: DW_AT_addr_base [DW_FORM_sec_offset]      (0x00000008)
-CHECK: 0x00000037:   DW_TAG_subprogram [2] * (0x0000000c)
+CHECK: 0x0000002c:   DW_TAG_subprogram [2] * (0x0000000c)
 CHECK-NEXT:  DW_AT_low_pc [DW_FORM_addrx]     (indexed (00000000) address = 0x[[#%.16x,LOCLIST_LOWPC:]])
-CHECK: 0x0000004d:     DW_TAG_formal_parameter [3]   (0x00000037)
+CHECK: 0x0000003c:     DW_TAG_formal_parameter [3]   (0x0000002c)
 CHECK-NEXT:                   DW_AT_location [DW_FORM_sec_offset]   (0x[[LOC_OFFSET:[0-9a-f]+]]: 
 CHECK-NEXT:                      [0x[[#%.16x,LOCLIST_PAIR_START:]], 0x[[#%.16x,LOCLIST_PAIR_END:]]): [[LOCLIST_EXPR:.*]]
 CHECK-NEXT:                      [0x[[#%.16x,LOCLIST_PAIR_START2:]], 0x[[#%.16x,LOCLIST_PAIR_END2:]]): [[LOCLIST_EXPR2:.*]])
 
 CHECK: .debug_loclists contents:
 CHECK-NEXT: 0x00000000: locations list header: length = 0x00000018, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
 CHECK-NEXT: 0x[[LOC_OFFSET]]: 
 CHECK-NEXT:            DW_LLE_base_addressx   (0x0000000000000000)

llvm/test/tools/dsymutil/ARM/dwarf5-str-offsets-base-strx.test

+; This test checks to ensure that if three DWARFv5 object files have correct values for the DW_AT_str_offsets_base and DW_FORM_strx for strings in their compile units.
+
+; 1.o was produced with the source file:
+
+; a.cpp
+; __attribute__((section("1,__text_foo"))) void foo() {}
+; 
+; int foo2(int a) {
+;     return a+5;
+; }
+; 
+; int foo3(int x) {
+;     return x+2;
+; }
+; 
+; int main () {
+;     return 1;
+; }
+
+; clang -g -c -O1 a.cpp -gdwarf-5 -o 1.o
+
+; 2.o was produced with the following source file:
+
+; b.cpp
+; __attribute__((section("1,__text_foo"))) void bar() {}
+; 
+; int bar2(int a) {
+;     return a+5;
+; }
+; 
+; int bar3(int x) {
+;     return x+2;
+; }
+
+; clang -g -c -O1 b.cpp -gdwarf-5 -o 2.o
+
+; 3.o was produced with the following source file:
+
+; c.cpp
+; 
+; int baz(int x) {
+;     return x+2;
+; }
+
+; clang -g -c -O1 c.cpp -gdwarf-5 -o 3.o
+
+
+RUN: rm -rf %t.dir && mkdir -p %t.dir
+RUN: dsymutil -y %p/dummy-debug-map-amr64.map -oso-prepend-path=%p/../Inputs/DWARF5-addr-base-str-off-base -o %t.dir/dwarf5-addr-base.dSYM
+RUN: llvm-dwarfdump %t.dir/dwarf5-addr-base.dSYM -a --verbose | FileCheck %s
+
+RUN: dsymutil --update -y %p/dummy-debug-map-amr64.map -oso-prepend-path=%p/../Inputs/DWARF5-addr-base-str-off-base -o %t.dir/dwarf5-addr-base.dSYM
+RUN: llvm-dwarfdump %t.dir/dwarf5-addr-base.dSYM -a --verbose | FileCheck %s --check-prefix=UPD
+
+CHECK: .debug_info contents:
+CHECK: 0x00000000: Compile Unit: length = 0x0000004a, format = DWARF32, version = 0x0005, unit_type = DW_UT_compile, abbr_offset = 0x0000, addr_size = 0x08 (next unit at 0x0000004e)
+
+CHECK: 0x0000000c: DW_TAG_compile_unit [1] *
+CHECK:               DW_AT_producer [DW_FORM_strx]     (indexed (00000000) string = "Apple clang version 15.0.0 (clang-1500.0.31.1)")
+CHECK:               DW_AT_name [DW_FORM_strx] (indexed (00000001) string = "a.cpp")
+CHECK:               DW_AT_LLVM_sysroot [DW_FORM_strx] (indexed (00000002) string = "/Users/shubham/apple-internal/Xcode-Rainbow/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX14.0.sdk")
+CHECK:               DW_AT_APPLE_sdk [DW_FORM_strx]    (indexed (00000003) string = "MacOSX14.0.sdk")
+CHECK:               DW_AT_str_offsets_base [DW_FORM_sec_offset]       (0x00000008)
+CHECK:               DW_AT_comp_dir [DW_FORM_strx]     (indexed (00000004) string = "/Users/shubham/Development/test109275485")
+
+CHECK: 0x0000002c:   DW_TAG_subprogram [2] * (0x0000000c)
+CHECK:                 DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000000) address = 0x0000000000010000)
+CHECK:                 DW_AT_linkage_name [DW_FORM_strx]       (indexed (00000005) string = "_Z4foo2i")
+CHECK:                 DW_AT_name [DW_FORM_strx]       (indexed (00000006) string = "foo2")
+
+CHECK: 0x0000003c:     DW_TAG_formal_parameter [3]   (0x0000002c)
+CHECK:                   DW_AT_name [DW_FORM_strx]     (indexed (00000007) string = "a")
+
+CHECK: 0x00000048:     NULL
+
+CHECK: 0x00000049:   DW_TAG_base_type [4]   (0x0000000c)
+CHECK:                 DW_AT_name [DW_FORM_strx]       (indexed (00000008) string = "int")
+
+CHECK: 0x0000004d:   NULL
+
+CHECK: 0x0000004e: Compile Unit: length = 0x0000004a, format = DWARF32, version = 0x0005, unit_type = DW_UT_compile, abbr_offset = 0x0000, addr_size = 0x08 (next unit at 0x0000009c)
+
+CHECK: 0x0000005a: DW_TAG_compile_unit [1] *
+CHECK:               DW_AT_producer [DW_FORM_strx]     (indexed (00000000) string = "Apple clang version 15.0.0 (clang-1500.0.31.1)")
+CHECK:               DW_AT_name [DW_FORM_strx] (indexed (00000009) string = "b.cpp")
+CHECK:               DW_AT_LLVM_sysroot [DW_FORM_strx] (indexed (00000002) string = "/Users/shubham/apple-internal/Xcode-Rainbow/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX14.0.sdk")
+CHECK:               DW_AT_APPLE_sdk [DW_FORM_strx]    (indexed (00000003) string = "MacOSX14.0.sdk")
+CHECK:               DW_AT_str_offsets_base [DW_FORM_sec_offset]       (0x00000008)
+CHECK:               DW_AT_comp_dir [DW_FORM_strx]     (indexed (00000004) string = "/Users/shubham/Development/test109275485")
+
+CHECK: 0x0000007a:   DW_TAG_subprogram [2] * (0x0000005a)
+CHECK:                 DW_AT_linkage_name [DW_FORM_strx]       (indexed (0000000a) string = "_Z4bar2i")
+CHECK:                 DW_AT_name [DW_FORM_strx]       (indexed (0000000b) string = "bar2")
+
+CHECK: 0x0000008a:     DW_TAG_formal_parameter [3]   (0x0000007a)
+CHECK:                   DW_AT_name [DW_FORM_strx]     (indexed (00000007) string = "a")
+
+CHECK: 0x00000096:     NULL
+
+CHECK: 0x00000097:   DW_TAG_base_type [4]   (0x0000005a)
+CHECK:                 DW_AT_name [DW_FORM_strx]       (indexed (00000008) string = "int")
+
+CHECK: 0x0000009b:   NULL
+
+CHECK: 0x0000009c: Compile Unit: length = 0x00000043, format = DWARF32, version = 0x0005, unit_type = DW_UT_compile, abbr_offset = 0x0000, addr_size = 0x08 (next unit at 0x000000e3)
+
+CHECK: 0x000000a8: DW_TAG_compile_unit [5] *
+CHECK:               DW_AT_producer [DW_FORM_strx]     (indexed (00000000) string = "Apple clang version 15.0.0 (clang-1500.0.31.1)")
+CHECK:               DW_AT_name [DW_FORM_strx] (indexed (0000000c) string = "c.cpp")
+CHECK:               DW_AT_LLVM_sysroot [DW_FORM_strx] (indexed (00000002) string = "/Users/shubham/apple-internal/Xcode-Rainbow/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX14.0.sdk")
+CHECK:               DW_AT_APPLE_sdk [DW_FORM_strx]    (indexed (00000003) string = "MacOSX14.0.sdk")
+CHECK:               DW_AT_str_offsets_base [DW_FORM_sec_offset]       (0x00000008)
+CHECK:               DW_AT_comp_dir [DW_FORM_strx]     (indexed (00000004) string = "/Users/shubham/Development/test109275485")
+
+CHECK: 0x000000c1:   DW_TAG_subprogram [2] * (0x000000a8)
+CHECK:                 DW_AT_linkage_name [DW_FORM_strx]       (indexed (0000000d) string = "_Z3bazi")
+CHECK:                 DW_AT_name [DW_FORM_strx]       (indexed (0000000e) string = "baz")
+
+CHECK: 0x000000d1:     DW_TAG_formal_parameter [3]   (0x000000c1)
+CHECK:                   DW_AT_name [DW_FORM_strx]     (indexed (0000000f) string = "x")
+
+CHECK: 0x000000dd:     NULL
+
+CHECK: 0x000000de:   DW_TAG_base_type [4]   (0x000000a8)
+CHECK:                 DW_AT_name [DW_FORM_strx]       (indexed (00000008) string = "int")
+
+CHECK: 0x000000e2:   NULL
+
+CHECK: .debug_str contents:
+CHECK-NEXT: 0x00000000: ""
+CHECK-NEXT: 0x00000001: "Apple clang version 15.0.0 (clang-1500.0.31.1)"
+CHECK-NEXT: 0x00000030: "a.cpp"
+CHECK-NEXT: 0x00000036: "/Users/shubham/apple-internal/Xcode-Rainbow/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX14.0.sdk"
+CHECK-NEXT: 0x000000b7: "MacOSX14.0.sdk"
+CHECK-NEXT: 0x000000c6: "/Users/shubham/Development/test109275485"
+CHECK-NEXT: 0x000000ef: "_Z4foo2i"
+CHECK-NEXT: 0x000000f8: "foo2"
+CHECK-NEXT: 0x000000fd: "a"
+CHECK-NEXT: 0x000000ff: "int"
+CHECK-NEXT: 0x00000103: "b.cpp"
+CHECK-NEXT: 0x00000109: "_Z4bar2i"
+CHECK-NEXT: 0x00000112: "bar2"
+CHECK-NEXT: 0x00000117: "c.cpp"
+CHECK-NEXT: 0x0000011d: "_Z3bazi"
+CHECK-NEXT: 0x00000125: "baz"
+CHECK-NEXT: 0x00000129: "x"
+
+CHECK: .debug_str_offsets contents:
+CHECK-NEXT: 0x00000000: Contribution size = 68, Format = DWARF32, Version = 5
+CHECK-NEXT: 0x00000008: 00000001 "Apple clang version 15.0.0 (clang-1500.0.31.1)"
+CHECK-NEXT: 0x0000000c: 00000030 "a.cpp"
+CHECK-NEXT: 0x00000010: 00000036 "/Users/shubham/apple-internal/Xcode-Rainbow/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX14.0.sdk"
+CHECK-NEXT: 0x00000014: 000000b7 "MacOSX14.0.sdk"
+CHECK-NEXT: 0x00000018: 000000c6 "/Users/shubham/Development/test109275485"
+CHECK-NEXT: 0x0000001c: 000000ef "_Z4foo2i"
+CHECK-NEXT: 0x00000020: 000000f8 "foo2"
+CHECK-NEXT: 0x00000024: 000000fd "a"
+CHECK-NEXT: 0x00000028: 000000ff "int"
+CHECK-NEXT: 0x0000002c: 00000103 "b.cpp"
+CHECK-NEXT: 0x00000030: 00000109 "_Z4bar2i"
+CHECK-NEXT: 0x00000034: 00000112 "bar2"
+CHECK-NEXT: 0x00000038: 00000117 "c.cpp"
+CHECK-NEXT: 0x0000003c: 0000011d "_Z3bazi"
+CHECK-NEXT: 0x00000040: 00000125 "baz"
+CHECK-NEXT: 0x00000044: 00000129 "x"
+
+UPD: .debug_info contents:
+UPD: 0x00000000: Compile Unit: length = 0x00000081, format = DWARF32, version = 0x0005, unit_type = DW_UT_compile, abbr_offset = 0x0000, addr_size = 0x08 (next unit at 0x00000085)
+
+UPD: 0x0000000c: DW_TAG_compile_unit [1] *
+UPD:               DW_AT_producer [DW_FORM_strx]     (indexed (00000000) string = "Apple clang version 15.0.0 (clang-1500.0.31.1)")
+UPD:               DW_AT_name [DW_FORM_strx] (indexed (00000001) string = "a.cpp")
+UPD:               DW_AT_LLVM_sysroot [DW_FORM_strx] (indexed (00000002) string = "/Users/shubham/apple-internal/Xcode-Rainbow/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX14.0.sdk")
+UPD:               DW_AT_APPLE_sdk [DW_FORM_strx]    (indexed (00000003) string = "MacOSX14.0.sdk")
+UPD:               DW_AT_str_offsets_base [DW_FORM_sec_offset]       (0x00000008)
+UPD:               DW_AT_comp_dir [DW_FORM_strx]     (indexed (00000004) string = "/Users/shubham/Development/test109275485")
+
+UPD: 0x00000031:   DW_TAG_subprogram [2]   (0x0000000c)
+UPD:                 DW_AT_linkage_name [DW_FORM_strx]       (indexed (00000005) string = "_Z3foov")
+UPD:                 DW_AT_name [DW_FORM_strx]       (indexed (00000006) string = "foo")
+
+UPD: 0x0000003d:   DW_TAG_subprogram [3] * (0x0000000c)
+UPD:                 DW_AT_linkage_name [DW_FORM_strx]       (indexed (00000007) string = "_Z4foo2i")
+UPD:                 DW_AT_name [DW_FORM_strx]       (indexed (00000008) string = "foo2")
+
+UPD: 0x0000004d:     DW_TAG_formal_parameter [4]   (0x0000003d)
+UPD:                   DW_AT_name [DW_FORM_strx]     (indexed (00000009) string = "a")
+
+UPD: 0x00000056:     NULL
+
+UPD: 0x00000057:   DW_TAG_subprogram [3] * (0x0000000c)
+UPD:                 DW_AT_linkage_name [DW_FORM_strx]       (indexed (0000000a) string = "_Z4foo3i")
+UPD:                 DW_AT_name [DW_FORM_strx]       (indexed (0000000b) string = "foo3")
+
+UPD: 0x00000067:     DW_TAG_formal_parameter [4]   (0x00000057)
+UPD:                   DW_AT_name [DW_FORM_strx]     (indexed (0000000c) string = "x")
+
+UPD: 0x00000070:     NULL
+
+UPD: 0x00000071:   DW_TAG_subprogram [5]   (0x0000000c)
+UPD:                 DW_AT_name [DW_FORM_strx]       (indexed (0000000d) string = "main")
+
+UPD: 0x00000080:   DW_TAG_base_type [6]   (0x0000000c)
+UPD:                 DW_AT_name [DW_FORM_strx]       (indexed (0000000e) string = "int")
+
+UPD: 0x00000084:   NULL
+
+UPD: 0x00000085: Compile Unit: length = 0x00000072, format = DWARF32, version = 0x0005, unit_type = DW_UT_compile, abbr_offset = 0x0000, addr_size = 0x08 (next unit at 0x000000fb)
+
+UPD: 0x00000091: DW_TAG_compile_unit [1] *
+UPD:               DW_AT_producer [DW_FORM_strx]     (indexed (00000000) string = "Apple clang version 15.0.0 (clang-1500.0.31.1)")
+UPD:               DW_AT_name [DW_FORM_strx] (indexed (0000000f) string = "b.cpp")
+UPD:               DW_AT_LLVM_sysroot [DW_FORM_strx] (indexed (00000002) string = "/Users/shubham/apple-internal/Xcode-Rainbow/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX14.0.sdk")
+UPD:               DW_AT_APPLE_sdk [DW_FORM_strx]    (indexed (00000003) string = "MacOSX14.0.sdk")
+UPD:               DW_AT_str_offsets_base [DW_FORM_sec_offset]       (0x00000008)
+UPD:               DW_AT_comp_dir [DW_FORM_strx]     (indexed (00000004) string = "/Users/shubham/Development/test109275485")
+
+UPD: 0x000000b6:   DW_TAG_subprogram [2]   (0x00000091)
+UPD:                 DW_AT_linkage_name [DW_FORM_strx]       (indexed (00000010) string = "_Z3barv")
+UPD:                 DW_AT_name [DW_FORM_strx]       (indexed (00000011) string = "bar")
+
+UPD: 0x000000c2:   DW_TAG_subprogram [3] * (0x00000091)
+UPD:                 DW_AT_linkage_name [DW_FORM_strx]       (indexed (00000012) string = "_Z4bar2i")
+UPD:                 DW_AT_name [DW_FORM_strx]       (indexed (00000013) string = "bar2")
+
+UPD: 0x000000d2:     DW_TAG_formal_parameter [4]   (0x000000c2)
+UPD:                   DW_AT_name [DW_FORM_strx]     (indexed (00000009) string = "a")
+
+UPD: 0x000000db:     NULL
+
+UPD: 0x000000dc:   DW_TAG_subprogram [3] * (0x00000091)
+UPD:                 DW_AT_linkage_name [DW_FORM_strx]       (indexed (00000014) string = "_Z4bar3i")
+UPD:                 DW_AT_name [DW_FORM_strx]       (indexed (00000015) string = "bar3")
+
+UPD: 0x000000ec:     DW_TAG_formal_parameter [4]   (0x000000dc)
+UPD:                   DW_AT_name [DW_FORM_strx]     (indexed (0000000c) string = "x")
+
+UPD: 0x000000f5:     NULL
+
+UPD: 0x000000f6:   DW_TAG_base_type [6]   (0x00000091)
+UPD:                 DW_AT_name [DW_FORM_strx]       (indexed (0000000e) string = "int")
+
+UPD: 0x000000fa:   NULL
+
+UPD: 0x000000fb: Compile Unit: length = 0x00000044, format = DWARF32, version = 0x0005, unit_type = DW_UT_compile, abbr_offset = 0x0000, addr_size = 0x08 (next unit at 0x00000143)
+
+UPD: 0x00000107: DW_TAG_compile_unit [7] *
+UPD:               DW_AT_producer [DW_FORM_strx]     (indexed (00000000) string = "Apple clang version 15.0.0 (clang-1500.0.31.1)")
+UPD:               DW_AT_name [DW_FORM_strx] (indexed (00000016) string = "c.cpp")
+UPD:               DW_AT_LLVM_sysroot [DW_FORM_strx] (indexed (00000002) string = "/Users/shubham/apple-internal/Xcode-Rainbow/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX14.0.sdk")
+UPD:               DW_AT_APPLE_sdk [DW_FORM_strx]    (indexed (00000003) string = "MacOSX14.0.sdk")
+UPD:               DW_AT_str_offsets_base [DW_FORM_sec_offset]       (0x00000008)
+UPD:               DW_AT_comp_dir [DW_FORM_strx]     (indexed (00000004) string = "/Users/shubham/Development/test109275485")
+
+UPD: 0x00000124:   DW_TAG_subprogram [3] * (0x00000107)
+UPD:                 DW_AT_linkage_name [DW_FORM_strx]       (indexed (00000017) string = "_Z3bazi")
+UPD:                 DW_AT_name [DW_FORM_strx]       (indexed (00000018) string = "baz")
+
+UPD: 0x00000134:     DW_TAG_formal_parameter [4]   (0x00000124)
+UPD:                   DW_AT_name [DW_FORM_strx]     (indexed (0000000c) string = "x")
+
+UPD: 0x0000013d:     NULL
+
+UPD: 0x0000013e:   DW_TAG_base_type [6]   (0x00000107)
+UPD:                 DW_AT_name [DW_FORM_strx]       (indexed (0000000e) string = "int")
+
+UPD: 0x00000142:   NULL
+
+UPD: .debug_str contents:
+UPD-NEXT: 0x00000000: ""
+UPD-NEXT: 0x00000001: "Apple clang version 15.0.0 (clang-1500.0.31.1)"
+UPD-NEXT: 0x00000030: "a.cpp"
+UPD-NEXT: 0x00000036: "/Users/shubham/apple-internal/Xcode-Rainbow/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX14.0.sdk"
+UPD-NEXT: 0x000000b7: "MacOSX14.0.sdk"
+UPD-NEXT: 0x000000c6: "/Users/shubham/Development/test109275485"
+UPD-NEXT: 0x000000ef: "_Z3foov"
+UPD-NEXT: 0x000000f7: "foo"
+UPD-NEXT: 0x000000fb: "_Z4foo2i"
+UPD-NEXT: 0x00000104: "foo2"
+UPD-NEXT: 0x00000109: "a"
+UPD-NEXT: 0x0000010b: "_Z4foo3i"
+UPD-NEXT: 0x00000114: "foo3"
+UPD-NEXT: 0x00000119: "x"
+UPD-NEXT: 0x0000011b: "main"
+UPD-NEXT: 0x00000120: "int"
+UPD-NEXT: 0x00000124: "b.cpp"
+UPD-NEXT: 0x0000012a: "_Z3barv"
+UPD-NEXT: 0x00000132: "bar"
+UPD-NEXT: 0x00000136: "_Z4bar2i"
+UPD-NEXT: 0x0000013f: "bar2"
+UPD-NEXT: 0x00000144: "_Z4bar3i"
+UPD-NEXT: 0x0000014d: "bar3"
+UPD-NEXT: 0x00000152: "c.cpp"
+UPD-NEXT: 0x00000158: "_Z3bazi"
+UPD-NEXT: 0x00000160: "baz"
+
+UPD: .debug_str_offsets contents:
+UPD-NEXT: 0x00000000: Contribution size = 104, Format = DWARF32, Version = 5
+UPD-NEXT: 0x00000008: 00000001 "Apple clang version 15.0.0 (clang-1500.0.31.1)"
+UPD-NEXT: 0x0000000c: 00000030 "a.cpp"
+UPD-NEXT: 0x00000010: 00000036 "/Users/shubham/apple-internal/Xcode-Rainbow/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX14.0.sdk"
+UPD-NEXT: 0x00000014: 000000b7 "MacOSX14.0.sdk"
+UPD-NEXT: 0x00000018: 000000c6 "/Users/shubham/Development/test109275485"
+UPD-NEXT: 0x0000001c: 000000ef "_Z3foov"
+UPD-NEXT: 0x00000020: 000000f7 "foo"
+UPD-NEXT: 0x00000024: 000000fb "_Z4foo2i"
+UPD-NEXT: 0x00000028: 00000104 "foo2"
+UPD-NEXT: 0x0000002c: 00000109 "a"
+UPD-NEXT: 0x00000030: 0000010b "_Z4foo3i"
+UPD-NEXT: 0x00000034: 00000114 "foo3"
+UPD-NEXT: 0x00000038: 00000119 "x"
+UPD-NEXT: 0x0000003c: 0000011b "main"
+UPD-NEXT: 0x00000040: 00000120 "int"
+UPD-NEXT: 0x00000044: 00000124 "b.cpp"
+UPD-NEXT: 0x00000048: 0000012a "_Z3barv"
+UPD-NEXT: 0x0000004c: 00000132 "bar"
+UPD-NEXT: 0x00000050: 00000136 "_Z4bar2i"
+UPD-NEXT: 0x00000054: 0000013f "bar2"
+UPD-NEXT: 0x00000058: 00000144 "_Z4bar3i"
+UPD-NEXT: 0x0000005c: 0000014d "bar3"
+UPD-NEXT: 0x00000060: 00000152 "c.cpp"
+UPD-NEXT: 0x00000064: 00000158 "_Z3bazi"
+UPD-NEXT: 0x00000068: 00000160 "baz"

llvm/test/tools/dsymutil/X86/dwarf5-addrbase-broken.test

 # CHECK: DW_TAG_compile_unit
 # CHECK: DW_AT_name{{.*}}"GoodCU"
 # CHECK: DW_AT_low_pc
 # CHECK: DW_TAG_subprogram
 # CHECK: DW_AT_name{{.*}}"foo"
 # CHECK: DW_TAG_variable
 # CHECK: DW_AT_name{{.*}}"var1"
 # CHECK: DW_AT_location        (DW_OP_addr
-# CHECK: 0x0000004e:   NULL
+# CHECK: 0x00000043:   NULL
 # CHECK: Compile Unit:
 # CHECK: DW_TAG_compile_unit
 # CHECK-NOT: DW_AT_low_pc
 # CHECK: DW_AT_name{{.*}}"BadCU"
 # CHECK-NOT: DW_TAG_subprogram
 # CHECK-NOT: DW_TAG_variable
-# CHECK: 0x0000006b:   NULL
+# CHECK: 0x0000005b:   NULL
 
 --- !mach-o
 FileHeader:
   magic:      0xFEEDFACF
   cputype:    0x01000007
   cpusubtype: 0x00000003
   filetype:   0x00000001
   ncmds:      2

llvm/test/tools/dsymutil/X86/dwarf5-addrx.test

 RUN: dsymutil --update -oso-prepend-path %p/../Inputs %p/../Inputs/private/tmp/dwarf5/dwarf5-addrx.out -o %t.dSYM 2>&1 | FileCheck %s --allow-empty
 RUN: llvm-dwarfdump --verify %t.dSYM 2>&1 | FileCheck %s
 
 RUN: llvm-dwarfdump --verbose %t.dSYM | FileCheck %s --check-prefix UPDATE-DWARF
 
 CHECK-NOT: error:
 
 DWARF: DW_TAG_compile_unit
-DWARF:   DW_AT_name [DW_FORM_strp]  {{.*}}     "dwarf5-addrx.c"
+DWARF:   DW_AT_name [DW_FORM_strx]  {{.*}}     "dwarf5-addrx.c"
 DWARF:   DW_AT_low_pc [DW_FORM_addrx]      (indexed (00000000) address = 0x0000000100000eb0)
 DWARF:   DW_AT_high_pc [DW_FORM_data4]   (0x00000103)
 DWARF:   DW_AT_addr_base [DW_FORM_sec_offset]      (0x00000008)
 DWARF:   DW_TAG_subprogram
 DWARF:     DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000000) address = 0x0000000100000eb0)
 DWARF:     DW_AT_high_pc [DW_FORM_data4]   (0x00000010)
-DWARF:     DW_AT_name  [DW_FORM_strp] {{.*}}   "foo1"
+DWARF:     DW_AT_name  [DW_FORM_strx] {{.*}}   "foo1"
 DWARF:   DW_TAG_subprogram
 DWARF:     DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000001) address = 0x0000000100000ec0)
 DWARF:     DW_AT_high_pc [DW_FORM_data4]   (0x00000010)
-DWARF:     DW_AT_name  [DW_FORM_strp] {{.*}}   "foo2"
+DWARF:     DW_AT_name  [DW_FORM_strx] {{.*}}   "foo2"
 DWARF:   DW_TAG_subprogram
 DWARF:     DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000002) address = 0x0000000100000ed0)
 DWARF:     DW_AT_high_pc [DW_FORM_data4]   (0x00000010)
-DWARF:     DW_AT_name  [DW_FORM_strp] {{.*}}   "foo3"
+DWARF:     DW_AT_name  [DW_FORM_strx] {{.*}}   "foo3"
 DWARF:   DW_TAG_subprogram
 DWARF:     DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000003) address = 0x0000000100000ee0)
 DWARF:     DW_AT_high_pc [DW_FORM_data4]   (0x00000010)
-DWARF:     DW_AT_name  [DW_FORM_strp] {{.*}}   "foo4"
+DWARF:     DW_AT_name  [DW_FORM_strx] {{.*}}   "foo4"
 DWARF:   DW_TAG_subprogram
 DWARF:     DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000004) address = 0x0000000100000ef0)
 DWARF:     DW_AT_high_pc  [DW_FORM_data4]  (0x00000010)
-DWARF:     DW_AT_name  [DW_FORM_strp] {{.*}}   "foo5"
+DWARF:     DW_AT_name  [DW_FORM_strx] {{.*}}   "foo5"
 DWARF:   DW_TAG_subprogram
 DWARF:     DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000005) address = 0x0000000100000f00)
 DWARF:     DW_AT_high_pc [DW_FORM_data4]   (0x00000010)
-DWARF:     DW_AT_name  [DW_FORM_strp] {{.*}}   "foo6"
+DWARF:     DW_AT_name  [DW_FORM_strx] {{.*}}   "foo6"
 DWARF:   DW_TAG_subprogram
 DWARF:     DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000006) address = 0x0000000100000f10)
 DWARF:     DW_AT_high_pc [DW_FORM_data4]   (0x00000010)
-DWARF:     DW_AT_name  [DW_FORM_strp] {{.*}}   "foo7"
+DWARF:     DW_AT_name  [DW_FORM_strx] {{.*}}   "foo7"
 DWARF:   DW_TAG_subprogram
 DWARF:     DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000007) address = 0x0000000100000f20)
 DWARF:     DW_AT_high_pc [DW_FORM_data4]   (0x00000010)
-DWARF:     DW_AT_name  [DW_FORM_strp] {{.*}}   "foo8"
+DWARF:     DW_AT_name  [DW_FORM_strx] {{.*}}   "foo8"
 DWARF:   DW_TAG_subprogram
 DWARF:     DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000008) address = 0x0000000100000f30)
 DWARF:     DW_AT_high_pc [DW_FORM_data4]   (0x00000083)
-DWARF:     DW_AT_name  [DW_FORM_strp] {{.*}}   "main"
+DWARF:     DW_AT_name  [DW_FORM_strx] {{.*}}   "main"
 
 UPDATE-DWARF: DW_TAG_compile_unit
-UPDATE-DWARF:   DW_AT_name [DW_FORM_strp]  {{.*}}     "dwarf5-addrx.c"
+UPDATE-DWARF:   DW_AT_name [DW_FORM_strx]  {{.*}}     "dwarf5-addrx.c"
 UPDATE-DWARF:   DW_AT_low_pc [DW_FORM_addrx]  (indexed (00000000) address = 0x0000000000000000)
 UPDATE-DWARF:   DW_AT_high_pc [DW_FORM_data4]   (0x00000103)
 UPDATE-DWARF:   DW_TAG_subprogram
 UPDATE-DWARF:     DW_AT_low_pc [DW_FORM_addrx] (indexed (00000000) address = 0x0000000000000000)
 UPDATE-DWARF:     DW_AT_high_pc [DW_FORM_data4]   (0x00000010)
-UPDATE-DWARF:     DW_AT_name  [DW_FORM_strp] {{.*}}   "foo1"
+UPDATE-DWARF:     DW_AT_name  [DW_FORM_strx] {{.*}}   "foo1"
 UPDATE-DWARF:   DW_TAG_subprogram
 UPDATE-DWARF:     DW_AT_low_pc [DW_FORM_addrx] (indexed (00000001) address = 0x0000000000000010)
 UPDATE-DWARF:     DW_AT_high_pc [DW_FORM_data4]   (0x00000010)
-UPDATE-DWARF:     DW_AT_name  [DW_FORM_strp] {{.*}}   "foo2"
+UPDATE-DWARF:     DW_AT_name  [DW_FORM_strx] {{.*}}   "foo2"
 UPDATE-DWARF:   DW_TAG_subprogram
 UPDATE-DWARF:     DW_AT_low_pc [DW_FORM_addrx]  (indexed (00000002) address = 0x0000000000000020)
 UPDATE-DWARF:     DW_AT_high_pc [DW_FORM_data4]   (0x00000010)
-UPDATE-DWARF:     DW_AT_name  [DW_FORM_strp] {{.*}}   "foo3"
+UPDATE-DWARF:     DW_AT_name  [DW_FORM_strx] {{.*}}   "foo3"
 UPDATE-DWARF:   DW_TAG_subprogram
 UPDATE-DWARF:     DW_AT_low_pc  [DW_FORM_addrx] (indexed (00000003) address = 0x0000000000000030)
 UPDATE-DWARF:     DW_AT_high_pc [DW_FORM_data4]   (0x00000010)
-UPDATE-DWARF:     DW_AT_name  [DW_FORM_strp] {{.*}}   "foo4"
+UPDATE-DWARF:     DW_AT_name  [DW_FORM_strx] {{.*}}   "foo4"
 UPDATE-DWARF:   DW_TAG_subprogram
 UPDATE-DWARF:     DW_AT_low_pc [DW_FORM_addrx]  (indexed (00000004) address = 0x0000000000000040)
 UPDATE-DWARF:     DW_AT_high_pc  [DW_FORM_data4]  (0x00000010)
-UPDATE-DWARF:     DW_AT_name  [DW_FORM_strp] {{.*}}   "foo5"
+UPDATE-DWARF:     DW_AT_name  [DW_FORM_strx] {{.*}}   "foo5"
 UPDATE-DWARF:   DW_TAG_subprogram
 UPDATE-DWARF:     DW_AT_low_pc  [DW_FORM_addrx] (indexed (00000005) address = 0x0000000000000050)
 UPDATE-DWARF:     DW_AT_high_pc [DW_FORM_data4]   (0x00000010)
-UPDATE-DWARF:     DW_AT_name  [DW_FORM_strp] {{.*}}   "foo6"
+UPDATE-DWARF:     DW_AT_name  [DW_FORM_strx] {{.*}}   "foo6"
 UPDATE-DWARF:   DW_TAG_subprogram
 UPDATE-DWARF:     DW_AT_low_pc  [DW_FORM_addrx] (indexed (00000006) address = 0x0000000000000060)
 UPDATE-DWARF:     DW_AT_high_pc [DW_FORM_data4]   (0x00000010)
-UPDATE-DWARF:     DW_AT_name  [DW_FORM_strp] {{.*}}   "foo7"
+UPDATE-DWARF:     DW_AT_name  [DW_FORM_strx] {{.*}}   "foo7"
 UPDATE-DWARF:   DW_TAG_subprogram
 UPDATE-DWARF:     DW_AT_low_pc  [DW_FORM_addrx] (indexed (00000007) address = 0x0000000000000070)
 UPDATE-DWARF:     DW_AT_high_pc [DW_FORM_data4]   (0x00000010)
-UPDATE-DWARF:     DW_AT_name  [DW_FORM_strp] {{.*}}   "foo8"
+UPDATE-DWARF:     DW_AT_name  [DW_FORM_strx] {{.*}}   "foo8"
 UPDATE-DWARF:   DW_TAG_subprogram
 UPDATE-DWARF:     DW_AT_low_pc  [DW_FORM_addrx] (indexed (00000008) address = 0x0000000000000080)
 UPDATE-DWARF:     DW_AT_high_pc [DW_FORM_data4]   (0x00000083)
-UPDATE-DWARF:     DW_AT_name  [DW_FORM_strp] {{.*}}   "main"
+UPDATE-DWARF:     DW_AT_name  [DW_FORM_strx] {{.*}}   "main"
 UPDATE-DWARF:  .debug_addr contents:
 UPDATE-DWARF:  0x00000000: Address table header: length = 0x0000004c, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00
 UPDATE-DWARF: Addrs: [
 UPDATE-DWARF: 0x0000000000000000
 UPDATE-DWARF: 0x0000000000000010
 UPDATE-DWARF: 0x0000000000000020
 UPDATE-DWARF: 0x0000000000000030
 UPDATE-DWARF: 0x0000000000000040
 UPDATE-DWARF: 0x0000000000000050
 UPDATE-DWARF: 0x0000000000000060
 UPDATE-DWARF: 0x0000000000000070
 UPDATE-DWARF: 0x0000000000000080
 UPDATE-DWARF: ]

llvm/test/tools/dsymutil/X86/dwarf5-loclists.test

 
 
 
 
 
 #UPD-DWARF-CHECK: DW_TAG_compile_unit
 #UPD-DWARF-CHECK: DW_AT_name {{.*}} "dwarf5-loclists.c"
 #UPD-DWARF-CHECK: DW_AT_loclists_base [DW_FORM_sec_offset]  (0x0000000c)
-#UPD-DWARF-CHECK: DW_TAG_formal_parameter [8]   (0x00000058)
+#UPD-DWARF-CHECK: DW_TAG_formal_parameter [8]   (0x00000047)
 #UPD-DWARF-CHECK:   DW_AT_location [DW_FORM_loclistx]     (indexed (0x0) loclist = 0x00000014:
 #UPD-DWARF-CHECK:    [0x0000000000000000, 0x0000000000000017): DW_OP_reg5 RDI
 #UPD-DWARF-CHECK:    [0x0000000000000017, 0x0000000000000023): DW_OP_reg3 RBX
 #UPD-DWARF-CHECK:    [0x0000000000000023, 0x000000000000002d): DW_OP_reg4 RSI
 #UPD-DWARF-CHECK:    [0x0000000000000030, 0x0000000000000033): DW_OP_reg3 RBX
 #UPD-DWARF-CHECK:    [0x0000000000000033, 0x000000000000004c): DW_OP_breg6 RBP-20)
 #UPD-DWARF-CHECK:   DW_AT_name {{.*}} "argv"
-#UPD-DWARF-CHECK: DW_TAG_formal_parameter [8]   (0x00000058)
+#UPD-DWARF-CHECK: DW_TAG_formal_parameter [8]   (0x00000047)
 #UPD-DWARF-CHECK:   DW_AT_location [DW_FORM_loclistx]     (indexed (0x1) loclist = 0x0000002f:
 #UPD-DWARF-CHECK:    [0x0000000000000000, 0x0000000000000019): DW_OP_reg4 RSI
 #UPD-DWARF-CHECK:    [0x0000000000000019, 0x000000000000004c): DW_OP_entry_value(DW_OP_reg4 RSI), DW_OP_stack_value)
 #UPD-DWARF-CHECK:   DW_AT_name {{.*}} "argc"
 #UPD-DWARF-CHECK: .debug_loclists contents:
 #UPD-DWARF-CHECK: 0x00000000: locations list header: length = 0x00000039, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000002
 #UPD-DWARF-CHECK: offsets: [
 #UPD-DWARF-CHECK: 0x00000008 => 0x00000014

llvm/test/tools/dsymutil/X86/op-convert-offset.test

 OBJ:                 DW_AT_encoding  (DW_ATE_unsigned)
 OBJ:                 DW_AT_byte_size (0x01)
 
 OBJ: 0x00000094:     DW_TAG_formal_parameter
 OBJ:                   DW_AT_location        (DW_OP_breg2 RCX+0, DW_OP_constu 0xff, DW_OP_and, DW_OP_convert (0x0000007d) "DW_ATE_unsigned_1", DW_OP_convert (0x00000081) "DW_ATE_unsigned_8", DW_OP_stack_value)
 OBJ:                   DW_AT_name    ("b")
 OBJ:                   DW_AT_type    (0x000000af "_Bool")
 
-DSYM: 0x0000009a:   DW_TAG_base_type
+DSYM: 0x00000084:   DW_TAG_base_type
 DSYM:                 DW_AT_name      ("DW_ATE_unsigned_1")
 DSYM:                 DW_AT_encoding  (DW_ATE_unsigned)
 DSYM:                 DW_AT_byte_size (0x01)
 
-DSYM: 0x000000ba:     DW_TAG_formal_parameter
-DSYM:                   DW_AT_location        (DW_OP_breg2 RCX+0, DW_OP_constu 0xff, DW_OP_and, DW_OP_convert (0x0000009a) "DW_ATE_unsigned_1", DW_OP_convert (0x000000a1) "DW_ATE_unsigned_8", DW_OP_stack_value)
+DSYM: 0x0000009b:     DW_TAG_formal_parameter
+DSYM:                   DW_AT_location        (DW_OP_breg2 RCX+0, DW_OP_constu 0xff, DW_OP_and, DW_OP_convert (0x00000084) "DW_ATE_unsigned_1", DW_OP_convert (0x00000088) "DW_ATE_unsigned_8", DW_OP_stack_value)
 DSYM:                   DW_AT_name    ("b")
-DSYM:                   DW_AT_type    (0x000000d8 "_Bool")
+DSYM:                   DW_AT_type    (0x000000b6 "_Bool")

llvm/test/tools/llvm-dwarfutil/ELF/X86/dwarf5-addresses.test

 #
 # RUN: llvm-dwarfutil --no-garbage-collection --build-accelerator=DWARF %t.o %t1
 # RUN: llvm-dwarfdump -verify %t1 | FileCheck %s
 # RUN: llvm-dwarfdump -a --verbose %t1 | FileCheck %s --check-prefix UPD-DWARF-CHECK
 
 #CHECK: No errors.
 
 #DWARF-CHECK: DW_TAG_compile_unit
-#DWARF-CHECK:   DW_AT_name [DW_FORM_strp]  {{.*}}     "CU1"
+#DWARF-CHECK:   DW_AT_name [DW_FORM_strx]  {{.*}}     "CU1"
 #DWARF-CHECK:   DW_AT_low_pc [DW_FORM_addrx]      (indexed (00000000) address = 0x0000000000001130)
 #DWARF-CHECK:   DW_AT_high_pc [DW_FORM_data8]   (0x0000000000000060)
+#DWARF-CHECK:   DW_AT_str_offsets_base [DW_FORM_sec_offset]       (0x00000008)
 #DWARF-CHECK:   DW_TAG_subprogram
-#DWARF-CHECK:     DW_AT_name  [DW_FORM_strp] {{.*}}   "foo1"
+#DWARF-CHECK:     DW_AT_name  [DW_FORM_strx] {{.*}}   "foo1"
 #DWARF-CHECK:     DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000000) address = 0x0000000000001130)
 #DWARF-CHECK:     DW_AT_high_pc [DW_FORM_data8]   (0x0000000000000010)
 #DWARF-CHECK:   DW_TAG_subprogram
-#DWARF-CHECK:     DW_AT_name  [DW_FORM_strp] {{.*}}   "foo2"
+#DWARF-CHECK:     DW_AT_name  [DW_FORM_strx] {{.*}}   "foo2"
 #DWARF-CHECK:     DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000001) address = 0x0000000000001140)
 #DWARF-CHECK:     DW_AT_high_pc [DW_FORM_data8]   (0x0000000000000010)
 #DWARF-CHECK:   DW_TAG_subprogram
-#DWARF-CHECK:     DW_AT_name  [DW_FORM_strp] {{.*}}   "foo3"
+#DWARF-CHECK:     DW_AT_name  [DW_FORM_strx] {{.*}}   "foo3"
 #DWARF-CHECK:     DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000002) address = 0x0000000000001150)
 #DWARF-CHECK:     DW_AT_high_pc [DW_FORM_data8]   (0x0000000000000010)
 #DWARF-CHECK:   DW_TAG_subprogram
-#DWARF-CHECK:     DW_AT_name  [DW_FORM_strp] {{.*}}   "foo4"
+#DWARF-CHECK:     DW_AT_name  [DW_FORM_strx] {{.*}}   "foo4"
 #DWARF-CHECK:     DW_AT_low_pc [DW_FORM_addrx]   (indexed (00000003) address = 0x0000000000001160)
 #DWARF-CHECK:     DW_AT_high_pc [DW_FORM_data8]   (0x0000000000000010)
 #DWARF-CHECK:   DW_TAG_subprogram
-#DWARF-CHECK:     DW_AT_name  [DW_FORM_strp] {{.*}}   "foo5"
+#DWARF-CHECK:     DW_AT_name  [DW_FORM_strx] {{.*}}   "foo5"
 #DWARF-CHECK:     DW_AT_low_pc [DW_FORM_addrx]   (indexed (00000004) address = 0x0000000000001170)
 #DWARF-CHECK:     DW_AT_high_pc [DW_FORM_data8]   (0x0000000000000010)
 #DWARF-CHECK:   DW_TAG_subprogram
-#DWARF-CHECK:     DW_AT_name  [DW_FORM_strp] {{.*}}   "foo6"
+#DWARF-CHECK:     DW_AT_name  [DW_FORM_strx] {{.*}}   "foo6"
 #DWARF-CHECK:     DW_AT_low_pc [DW_FORM_addrx]   (indexed (00000005) address = 0x0000000000001180)
 #DWARF-CHECK:     DW_AT_high_pc [DW_FORM_data8]   (0x0000000000000010)
 #DWARF-CHECK:   DW_TAG_variable
-#DWARF-CHECK:     DW_AT_name  [DW_FORM_strp] {{.*}}   "var1"
+#DWARF-CHECK:     DW_AT_name  [DW_FORM_strx] {{.*}}   "var1"
 #DWARF-CHECK:     DW_AT_location [DW_FORM_exprloc] (DW_OP_addr 0x2000)
 #DWARF-CHECK:   DW_TAG_variable
-#DWARF-CHECK:     DW_AT_name  [DW_FORM_strp] {{.*}}   "var2"
+#DWARF-CHECK:     DW_AT_name  [DW_FORM_strx] {{.*}}   "var2"
 #DWARF-CHECK:     DW_AT_location [DW_FORM_exprloc] (DW_OP_addr 0x2000)
 #DWARF-CHECK:   DW_TAG_variable
-#DWARF-CHECK:     DW_AT_name [DW_FORM_strp]  {{.*}}   "var3"
+#DWARF-CHECK:     DW_AT_name [DW_FORM_strx]  {{.*}}   "var3"
 #DWARF-CHECK:     DW_AT_location [DW_FORM_exprloc] (DW_OP_const8u 0x2000, DW_OP_form_tls_address)
 #DWARF-CHECK:   DW_TAG_variable
-#DWARF-CHECK:     DW_AT_name [DW_FORM_strp]  {{.*}}   "var4"
+#DWARF-CHECK:     DW_AT_name [DW_FORM_strx]  {{.*}}   "var4"
 #DWARF-CHECK:     DW_AT_location [DW_FORM_exprloc] (DW_OP_const8u 0x2000, DW_OP_form_tls_address)
 #DWARF-CHECK=NOT: .debug_addr contents:
 
 #UPD-DWARF-CHECK: DW_TAG_compile_unit
 #UPD-DWARF-CHECK:   DW_AT_name {{.*}}"CU1"
 #UPD-DWARF-CHECK:   DW_AT_low_pc [DW_FORM_addrx]   (indexed (00000000) address = 0x0000000000001130)
 #UPD-DWARF-CHECK:   DW_AT_high_pc [DW_FORM_data8]   (0x0000000000000060)
 #UPD-DWARF-CHECK:   DW_TAG_subprogram

llvm/test/tools/llvm-dwarfutil/ELF/X86/dwarf5-rnglists.test

 
 # RUN: llvm-dwarfutil --no-garbage-collection --build-accelerator=DWARF %t.o %t1
 # RUN: llvm-dwarfdump -verify %t1 | FileCheck %s
 # RUN: llvm-dwarfdump -a --verbose %t1 | FileCheck %s --check-prefix UPD-DWARF-CHECK
 
 #CHECK: No errors.
 
 #DWARF-CHECK: DW_TAG_compile_unit
-#DWARF-CHECK:   DW_AT_name [DW_FORM_strp]  {{.*}}     "CU1"
+#DWARF-CHECK:   DW_AT_name [DW_FORM_strx]  {{.*}}     "CU1"
 #DWARF-CHECK:   DW_AT_low_pc [DW_FORM_addrx]      (indexed (00000000) address = 0x0000000000001130)
 #DWARF-CHECK:   DW_AT_ranges [DW_FORM_sec_offset] (0x[[CURANGE_OFF:[0-9a-f]*]]
 #DWARF-CHECK:   [0x0000000000001130, 0x0000000000001170))
+#DWARF-CHECK:   DW_AT_str_offsets_base [DW_FORM_sec_offset]       (0x00000008)
 #DWARF-CHECK:   DW_TAG_subprogram
-#DWARF-CHECK:     DW_AT_name  [DW_FORM_strp] {{.*}}   "foo1"
+#DWARF-CHECK:     DW_AT_name  [DW_FORM_strx] {{.*}}   "foo1"
 #DWARF-CHECK:     DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000000) address = 0x0000000000001130)
 #DWARF-CHECK:     DW_AT_high_pc [DW_FORM_data8]   (0x0000000000000010)
 #DWARF-CHECK:     DW_TAG_lexical_block
 #DWARF-CHECK:       DW_AT_ranges [DW_FORM_sec_offset]     (0x[[F1RANGE_OFF:[0-9a-f]*]]
 #DWARF-CHECK:       [0x0000000000001130, 0x0000000000001140))
 #DWARF-CHECK:   DW_TAG_subprogram
-#DWARF-CHECK:     DW_AT_name  [DW_FORM_strp] {{.*}}   "foo2"
+#DWARF-CHECK:     DW_AT_name  [DW_FORM_strx] {{.*}}   "foo2"
 #DWARF-CHECK:     DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000001) address = 0x0000000000001140)
 #DWARF-CHECK:     DW_AT_high_pc [DW_FORM_data8]   (0x0000000000000010)
 #DWARF-CHECK:     DW_TAG_lexical_block
 #DWARF-CHECK:       DW_AT_ranges [DW_FORM_sec_offset]     (0x[[F2RANGE_OFF:[0-9a-f]*]]
 #DWARF-CHECK:            [0x0000000000001140, 0x0000000000001150))
 #DWARF-CHECK:   DW_TAG_subprogram
-#DWARF-CHECK:     DW_AT_name  [DW_FORM_strp] {{.*}}   "foo3"
+#DWARF-CHECK:     DW_AT_name  [DW_FORM_strx] {{.*}}   "foo3"
 #DWARF-CHECK:     DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000002) address = 0x0000000000001150)
 #DWARF-CHECK:     DW_AT_high_pc [DW_FORM_data8]   (0x0000000000000010)
 #DWARF-CHECK:     DW_TAG_lexical_block
 #DWARF-CHECK:       DW_AT_ranges [DW_FORM_sec_offset]     (0x[[F3RANGE_OFF:[0-9a-f]*]]
 #DWARF-CHECK:          [0x0000000000001150, 0x0000000000001160))
 #DWARF-CHECK:   DW_TAG_subprogram
-#DWARF-CHECK:     DW_AT_name  [DW_FORM_strp] {{.*}}   "foo4"
+#DWARF-CHECK:     DW_AT_name  [DW_FORM_strx] {{.*}}   "foo4"
 #DWARF-CHECK:     DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000003) address = 0x0000000000001160)
 #DWARF-CHECK:     DW_AT_high_pc [DW_FORM_data8]   (0x0000000000000010)
 #DWARF-CHECK:     DW_TAG_lexical_block
 #DWARF-CHECK:       DW_AT_ranges [DW_FORM_sec_offset]     (0x[[F4RANGE_OFF:[0-9a-f]*]]
 #DWARF-CHECK:          [0x0000000000001160, 0x0000000000001170))
 #DWARF-CHECK: .debug_aranges contents:
 #DWARF-CHECK: Address Range Header: length = 0x0000002c, format = DWARF32, version = 0x0002, cu_offset = 0x00000000, addr_size = 0x08, seg_size = 0x00
 #DWARF-CHECK: [0x0000000000001130, 0x0000000000001170)