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.

878

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

1853

It should be added to only DW_TAG_compile_unit DIEs.

2016

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())
}
...

2947

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

2016

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

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

59

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

2016

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_string_offset table.
+  virtual void
+  emitStringOffsets(const SmallVector<uint64_t> &StringOffsets, bool AttrStrOffsetBaseSeen) = 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;
+    bool StrxFoundInCU;
 
     /// 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.
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:
   /// data serves a the key to this StringMap, this takes care of comparing the
   /// semantics of CIEs defined in different object files.
   StringMap<uint32_t> EmittedCIEs;
 
   /// Offset of the last CIE that has been emitted in the output
   /// .debug_frame section.
   uint32_t LastCIEOffset = 0;
 
+  bool AttrStrOffsetBaseSeen = false;
+
   /// 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;

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_string_offset table.
+  void emitStringOffsets(const SmallVector<uint64_t> &StringOffset, bool AttrStrOffsetBaseSeen) 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

     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 (AttrSpec.Form == dwarf::DW_FORM_strx ||
+        (AttrSpec.Form >= dwarf::DW_FORM_strx1 &&
+         AttrSpec.Form <= dwarf::DW_FORM_strx4)) {
+      auto StringOffsetIndex =
+          StringOffsetPool.getValueIndex(StringEntry.getOffset());
+      // Mark StrxFoundInCU as true if a DW_FORM_strx* is found in any Die of a
+      // CU, use it to throw an error if a DW_AT_str_offsets_base is not found
+      // in the CU.
+      StrxFoundInCU = true;
+      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();

   }
 
   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(

   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:

       continue;
     }
 
     DWARFFormValue Val = AttrSpec.getFormValue();
     uint64_t AttrSize = Offset;
     Val.extractValue(Data, &Offset, U.getFormParams(), &U);
     AttrSize = Offset - AttrSize;
 
+    // Mark AttrStrOffsetBaseSeen as true, if any CU has an
+    // DW_AT_str_offsets_base, so a .debug_str_offsets section header is
+    // emitted.
+    if (AttrSpec.Attr ==  dwarf::DW_AT_str_offsets_base)
+      Linker.AttrStrOffsetBaseSeen = true;
+
     OutOffset += cloneAttribute(*Die, InputDIE, File, Unit, Val, AttrSpec,
                                 AttrSize, AttrInfo, IsLittleEndian);
   }
 
   // Look for accelerator entries.
   uint16_t Tag = InputDIE.getTag();
   // FIXME: This is slightly wrong. An inline_subroutine without a
   // low_pc, but with AT_ranges might be interesting to get into the

     }
   }
 
   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;

   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)

     if (V.getAttribute() == dwarf::DW_AT_addr_base) {
       V = DIEValue(V.getAttribute(), V.getForm(), Offset);
       return;
     }
 
   llvm_unreachable("Didn't find a DW_AT_addr_base in cloned DIE!");
 }
 
+static void patchStrOffsetsBase(DIE &Die, DIEInteger Offset, bool StrxFoundInCU) {
+  for (auto &V : Die.values())
+    if (V.getAttribute() == dwarf::DW_AT_str_offsets_base) {
+      V = DIEValue(V.getAttribute(), V.getForm(), Offset);
+      return;
+    }
+  // If there are no DW_FORM_strx* in the Compile Unit, do not expect to find a
+  // DW_AT_str_offsets_base.
+  if (StrxFoundInCU)
+    llvm_unreachable("Didn't find a DW_AT_str_offsets_base in cloned DIE!");
+}
+
 void DWARFLinker::DIECloner::emitDebugAddrSection(
     CompileUnit &Unit,
     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())

 
 uint64_t DWARFLinker::DIECloner::cloneAllCompileUnits(
     DWARFContext &DwarfContext, const DWARFFile &File, bool IsLittleEndian) {
   uint64_t OutputDebugInfoSize =
       (Emitter == nullptr) ? 0 : Emitter->getDebugInfoSectionSize();
   const uint64_t StartOutputDebugInfoSize = OutputDebugInfoSize;
 
   for (auto &CurrentUnit : CompileUnits) {
+    StrxFoundInCU = false;
     const uint16_t DwarfVersion = CurrentUnit->getOrigUnit().getVersion();
     const uint32_t UnitHeaderSize = DwarfVersion >= 5 ? 12 : 11;
     auto InputDIE = CurrentUnit->getOrigUnit().getUnitDIE();
     CurrentUnit->setStartOffset(OutputDebugInfoSize);
     if (!InputDIE) {
       OutputDebugInfoSize = CurrentUnit->computeNextUnitOffset(DwarfVersion);
       continue;
     }
     if (CurrentUnit->getInfo(0).Keep) {
       // Clone the InputDIE into your Unit DIE in our compile unit since it
       // already has a DIE inside of it.
       CurrentUnit->createOutputDIE();
       rememberUnitForMacroOffset(*CurrentUnit);
       cloneDIE(InputDIE, File, *CurrentUnit, 0 /* PC offset */, UnitHeaderSize,
                0, IsLittleEndian, CurrentUnit->getOutputUnitDIE());
+      // dsymutil will emit only one .debug_str_offset contribution for all
+      // compile units, therefore the DW_AT_str_offsets_base for all CUs needs
+      // to be patched up to be the start of the section after the header, which
+      // will be 8 bytes.
+      if (DwarfVersion >= 5)
+        patchStrOffsetsBase(*CurrentUnit->getOutputUnitDIE(), DIEInteger(8), StrxFoundInCU);
     }
 
     OutputDebugInfoSize = CurrentUnit->computeNextUnitOffset(DwarfVersion);
 
     if (Emitter != nullptr) {
 
       generateLineTableForUnit(*CurrentUnit);
 

   // 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";

         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

     // 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, AttrStrOffsetBaseSeen);
       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);

 
   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);

   // 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_string_offset table.
+void DwarfStreamer::emitStringOffsets(
+    const SmallVector<uint64_t> &StringOffsets, bool AttrStrOffsetBaseSeen) {
+
+  if (StringOffsets.empty() && !AttrStrOffsetBaseSeen)
+    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 --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
 
 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_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[[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: 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_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: 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: .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:.*]]

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/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")