[dsymutil] Add preliminary support for DWARF 5.

[JDevlieghere]

Summary

Currently dsymutil will silently fail when processing binaries with
Dwarf 5 debug info. This patch adds rudimentary support for Dwarf 5 in
dsymutil.

• Recognize relocations in the debug_addr section.
• Recognize (a subset of) Dwarf 5 form values.
• Emits valid Dwarf 5 compile unit header chains.

To simplify things (and avoid having to emit indexed sections) I decided
to emit the relocated addresses directly in the debug info section.

• DW_FORM_strx gets relocated and rewritten to DW_FORM_strp
• DW_FORM_addrx gets relocated and rewritten to DW_FORM_addr

Obviously there's a lot of work left, but this should be a step in the
right direction.

rdar://62345491

[avl]

If I understood correctly, It looks like this change is not enough to work properly for DWARF5.
Currently, relocation is checked using offsets to the attribute:

bool DwarfLinkerForBinary::AddressManager::hasLiveAddressRange(
    const DWARFDie &DIE, CompileUnit::DIEInfo &MyInfo) {
  const auto *Abbrev = DIE.getAbbreviationDeclarationPtr();

  Optional<uint32_t> LowPcIdx = Abbrev->findAttributeIndex(dwarf::DW_AT_low_pc);
  if (!LowPcIdx)
    return false;

  uint64_t Offset = DIE.getOffset() + getULEB128Size(Abbrev->getCode());
  uint64_t LowPcOffset, LowPcEndOffset;
  std::tie(LowPcOffset, LowPcEndOffset) =
      getAttributeOffsets(Abbrev, *LowPcIdx, Offset, *DIE.getDwarfUnit());

  return hasValidRelocationAt(LowPcOffset, LowPcEndOffset, MyInfo);   <<<< check relocation inside debug_info
}

i.e. we check whether relocation exists between LowPcOffset, LowPcEndOffset of dwarf::DW_AT_low_pc inside debug_info table.

If we would read relocations for "debug_addr" table instead of the "debug_info" table then we would check the wrong relocations. To work properly we would need to recognize offset inside "debug_addr". Something like this(I did not check whether it could be compiled or whether it is full enough):

Optional<uint32_t> LowPcIdx = Abbrev->findAttributeIndex(dwarf::DW_AT_low_pc);
if (!LowPcIdx)
  return false;

if ( Abbrev->getFormByIndex(*LowPcIdx) == DW_FORM_addr ) {
  uint64_t Offset = DIE.getOffset() + getULEB128Size(Abbrev->getCode());
  uint64_t LowPcOffset, LowPcEndOffset;
  std::tie(LowPcOffset, LowPcEndOffset) =
    getAttributeOffsets(Abbrev, *LowPcIdx, Offset, *DIE.getDwarfUnit());

  return hasValidRelocationAt(LowPcOffset, LowPcEndOffset, MyInfo); <<<< check relocations inside debug_info
} else ( Abbrev->getFormByIndex(*LowPcIdx) == DW_FORM_addrx) {
  Optional<DWARFFormValue> OffsetValue = DIE.find(dwarf::DW_AT_low_pc);
  if (OffsetValue) {
    uint64_t LowPcOffset = OffsetValue->getRawUValue();
    uint64_t LowPcEndOffset = LowPcOffset + 4;
    return hasValidRelocationAt(LowPcOffset, LowPcEndOffset, MyInfo); <<<< check relocations inside debug_addr
  }
}

i.e. in case when we do "findValidRelocs(Section, Obj, DMO)" for "debug_addr" then we need to use other offsets(LowPcOffset/LowPcEndOffset) inside hasLiveMemoryLocation/hasLiveAddressRange.

[JDevlieghere]

In D94323#2487899, @avl wrote:

If I understood correctly, It looks like this change is not enough to work properly for DWARF5.

Yeah, I knew that when I uploaded the patch but I was planning to put up a series of smaller patches but then I changed my mind. I went with a slightly different approach than what you suggested, but the idea is the essentially the same. At first I tried to shoehorn them into the ValidRelocs list but the separate vector simplifies things a lot.

[JDevlieghere]

llvm/lib/DWARFLinker/DWARFStreamer.cpp

231

Note to self: remove this when updating the diff.

[avl]

llvm/include/llvm/DWARFLinker/DWARFLinker.h

88–89

llvm/tools/dsymutil/DwarfLinkerForBinary.cpp

694–696

it is also necessary to update how dwarf::DW_AT_location is handled for debug_addr. It looks like we need to parse location expression, extract addresses, and check whether it points to live code. I think it needs comment in this review if it is supposed to be done in some follow-up review.

712

I would propose to use single unified searching function here. i.e. to use the same AddressManager::hasValidRelocationAt() for both tables(debug_info and debug_abbrev). Like in this review - D93106 .

[avl]

llvm/tools/dsymutil/DwarfLinkerForBinary.h

173

nit: probably it would be better to name argument not Addr, but DebugAddrOffset or something like that. To make it clear that specified operand is not an address but offset in the debug_addr table.

[avl]

llvm/tools/dsymutil/DwarfLinkerForBinary.cpp

613

hasValidDebugAddrRelocationAt() and hasValidDebugInfoRelocationAt() have different implementations - first uses binary search and second sequentially searches from the first till last. My previous comment was about using one implementation for both cases. But, let it would be done with D93106.

775

it looks like we need to add ValidReloc.Addend here, the same as in applyValidRelocs():

return It->Mapping->getValue().BinaryAddress + It->Addend;

Also, not for this review, but as a general thing: probably it would be better to make relocateIndexedAddr() to be more general(since it appears in AddressManager interface). i.e. make relocateIndexedAddr to be able to relocate any address, not only one from debug_addr section:

class AddressManager {
public:

uint64_t relocateAddr(const DWARFFormValue&);
}

llvm/tools/dsymutil/DwarfLinkerForBinary.h

154

The comment is about debug_addr section but the function works with debug_info section.

163

/// This function must be called with offsets in strictly ascending order
/// because it never looks back at relocations it already 'went past'.

above comment is old. This function could not be called with offsets in strictly ascending order. DIEs from debug_info are evaluated in strictly ascending order, but addresses which they are referred may be in any order. The implementation of hasValidDebugAddrRelocationAt uses lower_bound search function and does not relate on order of offsets.

it looks like comments for hasValidDebugAddrRelocationAt and hasValidDebugInfoRelocationAt somehow mixed up.

[avl]

llvm/tools/dsymutil/DwarfLinkerForBinary.cpp

774

It looks incorrect to return offset in debug_addr section as the value of relocated address. It might be better to make return value Expected and return Error in case offset is not found.

[JDevlieghere]

Address @avl's review comments.

[JDevlieghere]

llvm/tools/dsymutil/DwarfLinkerForBinary.cpp

613

Ah, I misunderstood. Yeah I figured we could unify this after that patch lands.

[avl]

LGTM with small comment inside.

llvm/tools/dsymutil/DwarfLinkerForBinary.h

152–163

llvm/include/llvm/DWARFLinker/DWARFLinker.h

public:
   /// account that Data is at \p BaseOffset in the debug_info section.
   ///
   /// This function must be called with monotonic \p BaseOffset values.
   ///
   /// \returns true whether any reloc has been applied.
   virtual bool applyValidRelocs(MutableArrayRef<char> Data, uint64_t BaseOffset,
                                 bool IsLittleEndian) = 0;
 
+  /// Relocate the given address offset if a valid relocation exists.
+  virtual uint64_t relocateIndexedAddr(uint64_t Offset) = 0;
+
   /// Returns all valid functions address ranges(i.e., those ranges
   /// which points to sections with code).
   virtual RangesTy &getValidAddressRanges() = 0;
 
   /// Erases all data.
   virtual void clear() = 0;
 };
 
virtual void emitLocationsForUnit(
       std::function<void(StringRef, SmallVectorImpl<uint8_t> &)>
           ProcessExpr) = 0;
 
   /// Emit the compilation unit header for \p Unit in the
   /// debug_info section.
   ///
   /// As a side effect, this also switches the current Dwarf version
   /// of the MC layer to the one of U.getOrigUnit().
-  virtual void emitCompileUnitHeader(CompileUnit &Unit) = 0;
+  virtual void emitCompileUnitHeader(CompileUnit &Unit,
+                                     unsigned DwarfVersion) = 0;
 
   /// Recursively emit the DIE tree rooted at \p Die.
   virtual void emitDIE(DIE &Die) = 0;
 
   /// Returns size of generated .debug_line section.
   virtual uint64_t getLineSectionSize() const = 0;
 
   /// Returns size of generated .debug_frame section.

llvm/include/llvm/DWARFLinker/DWARFLinkerCompileUnit.h

public:
   /// Mark every DIE in this unit as kept. This function also
   /// marks variables as InDebugMap so that they appear in the
   /// reconstructed accelerator tables.
   void markEverythingAsKept();
 
   /// Compute the end offset for this unit. Must be called after the CU's DIEs
   /// have been cloned.  \returns the next unit offset (which is also the
   /// current debug_info section size).
-  uint64_t computeNextUnitOffset();
+  uint64_t computeNextUnitOffset(uint16_t DwarfVersion);
 
   /// Keep track of a forward reference to DIE \p Die in \p RefUnit by \p
   /// Attr. The attribute should be fixed up later to point to the absolute
   /// offset of \p Die in the debug_info section or to the canonical offset of
   /// \p Ctxt if it is non-null.
   void noteForwardReference(DIE *Die, const CompileUnit *RefUnit,
                             DeclContext *Ctxt, PatchLocation Attr);
 

llvm/include/llvm/DWARFLinker/DWARFStreamer.h

public:
   /// the MC Dwarf version to \p DwarfVersion.
   void switchToDebugInfoSection(unsigned DwarfVersion);
 
   /// Emit the compilation unit header for \p Unit in the
   /// debug_info section.
   ///
   /// As a side effect, this also switches the current Dwarf version
   /// of the MC layer to the one of U.getOrigUnit().
-  void emitCompileUnitHeader(CompileUnit &Unit) override;
+  void emitCompileUnitHeader(CompileUnit &Unit, unsigned DwarfVersion) override;
 
   /// Recursively emit the DIE tree rooted at \p Die.
   void emitDIE(DIE &Die) override;
 
   /// Emit the abbreviation table \p Abbrevs to the debug_abbrev section.
   void emitAbbrevs(const std::vector<std::unique_ptr<DIEAbbrev>> &Abbrevs,
                    unsigned DwarfVersion) override;
 

llvm/lib/DWARFLinker/DWARFLinker.cpp

void DWARFLinker::cleanupAuxiliarryData(LinkContext &Context) {
   for (auto I = DIELocs.begin(), E = DIELocs.end(); I != E; ++I)
     (*I)->~DIELoc();
 
   DIEBlocks.clear();
   DIELocs.clear();
   DIEAlloc.Reset();
 }
 
-
 /// Check if a variable describing DIE should be kept.
 /// \returns updated TraversalFlags.
 unsigned DWARFLinker::shouldKeepVariableDIE(AddressesMap &RelocMgr,
                                             const DWARFDie &DIE,
                                             CompileUnit::DIEInfo &MyInfo,
                                             unsigned Flags) {
   const auto *Abbrev = DIE.getAbbreviationDeclarationPtr();
 
if (InSet) {
     Abbrev.setNumber(Abbreviations.size());
     Abbreviations.back()->setNumber(Abbreviations.size());
   }
 }
 
 unsigned DWARFLinker::DIECloner::cloneStringAttribute(
     DIE &Die, AttributeSpec AttrSpec, const DWARFFormValue &Val,
     const DWARFUnit &U, OffsetsStringPool &StringPool, AttributesInfo &Info) {
+  Optional<const char *> String = Val.getAsCString();
+  if (!String)
+    return 0;
+
   // Switch everything to out of line strings.
-  const char *String = *Val.getAsCString();
-  auto StringEntry = StringPool.getEntry(String);
+  auto StringEntry = StringPool.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;
 
unsigned DWARFLinker::DIECloner::cloneBlockAttribute(
 
   Die.addValue(DIEAlloc, Value);
   return AttrSize;
 }
 
 unsigned DWARFLinker::DIECloner::cloneAddressAttribute(
     DIE &Die, AttributeSpec AttrSpec, const DWARFFormValue &Val,
     const CompileUnit &Unit, AttributesInfo &Info) {
+  dwarf::Form Form = AttrSpec.Form;
   uint64_t Addr = *Val.getAsAddress();
 
   if (LLVM_UNLIKELY(Linker.Options.Update)) {
     if (AttrSpec.Attr == dwarf::DW_AT_low_pc)
       Info.HasLowPc = true;
     Die.addValue(DIEAlloc, dwarf::Attribute(AttrSpec.Attr),
                  dwarf::Form(AttrSpec.Form), DIEInteger(Addr));
     return Unit.getOrigUnit().getAddressByteSize();
if (Die.getTag() == dwarf::DW_TAG_call_site)
       Addr = (Info.OrigCallReturnPc ? Info.OrigCallReturnPc : Addr) +
              Info.PCOffset;
   } else if (AttrSpec.Attr == dwarf::DW_AT_call_pc) {
     // Relocate the address of a branch instruction within a call site entry.
     if (Die.getTag() == dwarf::DW_TAG_call_site)
       Addr = (Info.OrigCallPc ? Info.OrigCallPc : Addr) + Info.PCOffset;
   }
 
+  // If this is an indexed address emit the relocated address.
+  if (Form == dwarf::DW_FORM_addrx) {
+    Addr = ObjFile.Addresses->relocateIndexedAddr(Addr);
+    Form = dwarf::DW_FORM_addr;
+  }
+
   Die.addValue(DIEAlloc, static_cast<dwarf::Attribute>(AttrSpec.Attr),
-               static_cast<dwarf::Form>(AttrSpec.Form), DIEInteger(Addr));
+               static_cast<dwarf::Form>(Form), DIEInteger(Addr));
   return Unit.getOrigUnit().getAddressByteSize();
 }
 
 unsigned DWARFLinker::DIECloner::cloneScalarAttribute(
     DIE &Die, const DWARFDie &InputDIE, const DWARFFile &File,
     CompileUnit &Unit, AttributeSpec AttrSpec, const DWARFFormValue &Val,
     unsigned AttrSize, AttributesInfo &Info) {
   uint64_t Value;
unsigned DWARFLinker::DIECloner::cloneAttribute(
     CompileUnit &Unit, OffsetsStringPool &StringPool, const DWARFFormValue &Val,
     const AttributeSpec AttrSpec, unsigned AttrSize, AttributesInfo &Info,
     bool IsLittleEndian) {
   const DWARFUnit &U = Unit.getOrigUnit();
 
   switch (AttrSpec.Form) {
   case dwarf::DW_FORM_strp:
   case dwarf::DW_FORM_string:
+  case dwarf::DW_FORM_strx:
+  case dwarf::DW_FORM_strx1:
+  case dwarf::DW_FORM_strx2:
+  case dwarf::DW_FORM_strx3:
+  case dwarf::DW_FORM_strx4:
     return cloneStringAttribute(Die, AttrSpec, Val, U, StringPool, Info);
   case dwarf::DW_FORM_ref_addr:
   case dwarf::DW_FORM_ref1:
   case dwarf::DW_FORM_ref2:
   case dwarf::DW_FORM_ref4:
   case dwarf::DW_FORM_ref8:
     return cloneDieReferenceAttribute(Die, InputDIE, AttrSpec, AttrSize, Val,
                                       File, Unit);
   case dwarf::DW_FORM_block:
   case dwarf::DW_FORM_block1:
   case dwarf::DW_FORM_block2:
   case dwarf::DW_FORM_block4:
   case dwarf::DW_FORM_exprloc:
     return cloneBlockAttribute(Die, File, Unit, AttrSpec, Val, AttrSize,
                                IsLittleEndian);
   case dwarf::DW_FORM_addr:
+  case dwarf::DW_FORM_addrx:
     return cloneAddressAttribute(Die, AttrSpec, Val, Unit, Info);
   case dwarf::DW_FORM_data1:
   case dwarf::DW_FORM_data2:
   case dwarf::DW_FORM_data4:
   case dwarf::DW_FORM_data8:
   case dwarf::DW_FORM_udata:
   case dwarf::DW_FORM_sdata:
   case dwarf::DW_FORM_sec_offset:
shouldSkipAttribute(DWARFAbbreviationDeclaration::AttributeSpec AttrSpec,
                     bool InFunctionScope) {
   switch (AttrSpec.Attr) {
   default:
     return false;
   case dwarf::DW_AT_low_pc:
   case dwarf::DW_AT_high_pc:
   case dwarf::DW_AT_ranges:
     return SkipPC;
+  case dwarf::DW_AT_str_offsets_base:
+    // FIXME: Use the string offset table with Dwarf 5.
+    return true;
   case dwarf::DW_AT_location:
   case dwarf::DW_AT_frame_base:
     // FIXME: for some reason dsymutil-classic keeps the location attributes
     // when they are of block type (i.e. not location lists). This is totally
     // wrong for globals where we will keep a wrong address. It is mostly
     // harmless for locals, but there is no point in keeping these anyway when
     // the function wasn't linked.
     return (SkipPC || (!InFunctionScope && Tag == dwarf::DW_TAG_variable &&

 uint64_t DWARFLinker::DIECloner::cloneAllCompileUnits(
     DWARFContext &DwarfContext, const DWARFFile &File,
     OffsetsStringPool &StringPool, bool IsLittleEndian) {
   uint64_t OutputDebugInfoSize =
       Linker.Options.NoOutput ? 0 : Emitter->getDebugInfoSectionSize();
   const uint64_t StartOutputDebugInfoSize = OutputDebugInfoSize;
 
   for (auto &CurrentUnit : CompileUnits) {
+    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();
+      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();
       cloneDIE(InputDIE, File, *CurrentUnit, StringPool, 0 /* PC offset */,
-               11 /* Unit Header size */, 0, IsLittleEndian,
+               UnitHeaderSize, 0, IsLittleEndian,
                CurrentUnit->getOutputUnitDIE());
     }
 
-    OutputDebugInfoSize = CurrentUnit->computeNextUnitOffset();
+    OutputDebugInfoSize = CurrentUnit->computeNextUnitOffset(DwarfVersion);
 
     if (!Linker.Options.NoOutput) {
       assert(Emitter);
 
       if (LLVM_LIKELY(!Linker.Options.Update) ||
           Linker.needToTranslateStrings())
         Linker.patchLineTableForUnit(*CurrentUnit, DwarfContext, File);
 
for (auto &CurrentUnit : CompileUnits) {
       if (LLVM_LIKELY(!Linker.Options.Update))
         Linker.generateUnitRanges(*CurrentUnit);
 
       CurrentUnit->fixupForwardReferences();
 
       if (!CurrentUnit->getOutputUnitDIE())
         continue;
 
+      unsigned DwarfVersion = CurrentUnit->getOrigUnit().getVersion();
+
       assert(Emitter->getDebugInfoSectionSize() ==
              CurrentUnit->getStartOffset());
-      Emitter->emitCompileUnitHeader(*CurrentUnit);
+      Emitter->emitCompileUnitHeader(*CurrentUnit, DwarfVersion);
       Emitter->emitDIE(*CurrentUnit->getOutputUnitDIE());
       assert(Emitter->getDebugInfoSectionSize() ==
-             CurrentUnit->computeNextUnitOffset());
+             CurrentUnit->computeNextUnitOffset(DwarfVersion));
     }
   }
 
   return OutputDebugInfoSize - StartOutputDebugInfoSize;
 }
 
 void DWARFLinker::updateAccelKind(DWARFContext &Dwarf) {
   if (Options.TheAccelTableKind != AccelTableKind::Default)

llvm/lib/DWARFLinker/DWARFLinkerCompileUnit.cpp

 
 StringRef CompileUnit::getSysRoot() {
   if (SysRoot.empty()) {
     DWARFDie CU = getOrigUnit().getUnitDIE();
     SysRoot = dwarf::toStringRef(CU.find(dwarf::DW_AT_LLVM_sysroot)).str();
   }
   return SysRoot;
 }
- 
 void CompileUnit::markEverythingAsKept() {
   unsigned Idx = 0;
 
   setHasInterestingContent();
 
   for (auto &I : Info) {
     // Mark everything that wasn't explicit marked for pruning.
     I.Keep = !I.Prune;
for (auto &I : Info) {
     if (auto Block = Value->getAsBlock()) {
       if (Block->size() > OrigUnit.getAddressByteSize() &&
           (*Block)[0] == dwarf::DW_OP_addr)
         I.InDebugMap = true;
     }
   }
 }
 
-uint64_t CompileUnit::computeNextUnitOffset() {
+uint64_t CompileUnit::computeNextUnitOffset(uint16_t DwarfVersion) {
   NextUnitOffset = StartOffset;
   if (NewUnit) {
-    NextUnitOffset += 11 /* Header size */;
+    NextUnitOffset += (DwarfVersion >= 5) ? 12 : 11; // Header size
     NextUnitOffset += NewUnit->getUnitDie().getSize();
   }
   return NextUnitOffset;
 }
 
 /// Keep track of a forward cross-cu reference from this unit
 /// to \p Die that lives in \p RefUnit.
 void CompileUnit::noteForwardReference(DIE *Die, const CompileUnit *RefUnit,

llvm/lib/DWARFLinker/DWARFStreamer.cpp

 
 void DwarfStreamer::switchToDebugInfoSection(unsigned DwarfVersion) {
   MS->SwitchSection(MOFI->getDwarfInfoSection());
   MC->setDwarfVersion(DwarfVersion);
 }
 
 /// Emit the compilation unit header for \p Unit in the debug_info section.
 ///
-/// A Dwarf section header is encoded as:
+/// A Dwarf 4 section header is encoded as:
 ///  uint32_t   Unit length (omitting this field)
 ///  uint16_t   Version
 ///  uint32_t   Abbreviation table offset
 ///  uint8_t    Address size
-///
 /// Leading to a total of 11 bytes.
-void DwarfStreamer::emitCompileUnitHeader(CompileUnit &Unit) {
-  unsigned Version = Unit.getOrigUnit().getVersion();
-  switchToDebugInfoSection(Version);
+///
+/// A Dwarf 5 section header is encoded as:
+///  uint32_t   Unit length (omitting this field)
+///  uint16_t   Version
+///  uint8_t    Unit type
+///  uint8_t    Address size
+///  uint32_t   Abbreviation table offset
+/// Leading to a total of 12 bytes.
+void DwarfStreamer::emitCompileUnitHeader(CompileUnit &Unit,
+                                          unsigned DwarfVersion) {
+  switchToDebugInfoSection(DwarfVersion);
 
   /// The start of the unit within its section.
   Unit.setLabelBegin(Asm->createTempSymbol("cu_begin"));
   Asm->OutStreamer->emitLabel(Unit.getLabelBegin());
 
   // Emit size of content not including length itself. The size has already
   // been computed in CompileUnit::computeOffsets(). Subtract 4 to that size to
   // account for the length field.
   Asm->emitInt32(Unit.getNextUnitOffset() - Unit.getStartOffset() - 4);
-  Asm->emitInt16(Version);
+  Asm->emitInt16(DwarfVersion);
 
+  if (DwarfVersion >= 5) {
+    Asm->emitInt8(dwarf::DW_UT_compile);
+    Asm->emitInt8(Unit.getOrigUnit().getAddressByteSize());
+    // We share one abbreviations table across all units so it's always at the
+    // start of the section.
+    Asm->emitInt32(0);
+    DebugInfoSectionSize += 12;
+  } else {
     // We share one abbreviations table across all units so it's always at the
     // start of the section.
     Asm->emitInt32(0);
     Asm->emitInt8(Unit.getOrigUnit().getAddressByteSize());
     DebugInfoSectionSize += 11;
+  }
 
   // Remember this CU.
   EmittedUnits.push_back({Unit.getUniqueID(), Unit.getLabelBegin()});
 }
 
 /// Emit the \p Abbrevs array as the shared abbreviation table
 /// for the linked Dwarf file.
 void DwarfStreamer::emitAbbrevs(
void DwarfStreamer::emitStrings(const NonRelocatableStringpool &Pool) {
   Asm->OutStreamer->SwitchSection(MOFI->getDwarfStrSection());
   std::vector<DwarfStringPoolEntryRef> Entries = Pool.getEntriesForEmission();
   for (auto Entry : Entries) {
     // Emit the string itself.
     Asm->OutStreamer->emitBytes(Entry.getString());
     // Emit a null terminator.
     Asm->emitInt8(0);
   }
+
+#if 0
+  if (DwarfVersion >= 5) {
+    // Emit an empty string offset section.
+    Asm->OutStreamer->SwitchSection(MOFI->getDwarfStrOffSection());
+    Asm->emitDwarfUnitLength(4, "Length of String Offsets Set");
+    Asm->emitInt16(DwarfVersion);
+    Asm->emitInt16(0);
+  }
+#endif
 }
 
 void DwarfStreamer::emitDebugNames(
     AccelTable<DWARF5AccelTableStaticData> &Table) {
   if (EmittedUnits.empty())
     return;
 
   // Build up data structures needed to emit this section.

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

+Test DWARF5 support in dsymutil. Currently this still generates an empty dSYM.
+
+$ cat dwarf5.c
+__attribute__ ((optnone))
+int foo() {
+  volatile i;
+  return i;
+}
+
+int main(int argc, char** argv) {
+  return foo();
+}
+
+$ clang -gdwarf-5 dwarf5.c -c -o dwarf5.o
+$ clang dwarf5.o -o dwarf5.out
+
+RUN: dsymutil -oso-prepend-path %p/../Inputs %p/../Inputs/private/tmp/dwarf5/dwarf5.out -o %t.dSYM 2>&1 | FileCheck %s --allow-empty
+RUN: dwarfdump --verify %t.dSYM 2>&1 | FileCheck %s
+CHECK-NOT: warning:
+CHECK-NOT: error:
+
+RUN: dwarfdump %t.dSYM | FileCheck %s --check-prefix DWARF
+DWARF: DW_TAG_compile_unit
+DWARF:   DW_AT_producer    ("clang version 12.0.0
+DWARF:   DW_AT_language    (DW_LANG_C99)
+DWARF:   DW_AT_name        ("dwarf5.c")
+DWARF:   DW_AT_LLVM_sysroot        ("/")
+DWARF:   DW_AT_stmt_list   (0x00000000)
+DWARF:   DW_AT_comp_dir    ("/private/tmp/dwarf5")
+DWARF:   DW_AT_low_pc      (0x0000000100003f80)
+DWARF:   DW_AT_high_pc     (0x0000000100003fb1)
+DWARF:   DW_AT_addr_base   (0x00000008)
+DWARF:   DW_TAG_subprogram
+DWARF:     DW_AT_name      ("foo")
+DWARF:     DW_AT_decl_file (0x00)
+DWARF:     DW_AT_decl_line (2)
+DWARF:     DW_AT_type      (0x0000006c "int")
+DWARF:     DW_AT_external  (true)
+DWARF:     DW_TAG_variable
+DWARF:       DW_AT_name    ("i")
+DWARF:       DW_AT_decl_file       (0x00)
+DWARF:       DW_AT_decl_line       (3)
+DWARF:       DW_AT_type    (0x00000073 "volatile int")
+DWARF:   DW_TAG_subprogram
+DWARF:     DW_AT_name      ("main")
+DWARF:     DW_AT_decl_file (0x00)
+DWARF:     DW_AT_decl_line (7)
+DWARF:     DW_AT_prototyped        (true)
+DWARF:     DW_AT_type      (0x0000006c "int")
+DWARF:     DW_AT_external  (true)
+DWARF:     DW_TAG_formal_parameter
+DWARF:       DW_AT_name    ("argc")
+DWARF:       DW_AT_decl_file       (0x00)
+DWARF:       DW_AT_decl_line       (7)
+DWARF:       DW_AT_type    (0x0000006c "int")
+DWARF:     DW_TAG_formal_parameter
+DWARF:       DW_AT_name    ("argv")
+DWARF:       DW_AT_decl_file       (0x00)
+DWARF:       DW_AT_decl_line       (7)
+DWARF:       DW_AT_type    (0x00000078 "char**")

llvm/tools/dsymutil/DwarfLinkerForBinary.h

struct ValidReloc {
 
       ValidReloc(uint64_t Offset, uint32_t Size, uint64_t Addend,
                  const DebugMapObject::DebugMapEntry *Mapping)
           : Offset(Offset), Size(Size), Addend(Addend), Mapping(Mapping) {}
 
       bool operator<(const ValidReloc &RHS) const {
         return Offset < RHS.Offset;
       }
+      bool operator<(uint64_t RHS) const { return Offset < RHS; }
     };
 
     const DwarfLinkerForBinary &Linker;
 
     /// The valid relocations for the current DebugMapObject.
     /// This vector is sorted by relocation offset.
-    std::vector<ValidReloc> ValidRelocs;
+    /// {
+    std::vector<ValidReloc> ValidDebugInfoRelocs;
+    std::vector<ValidReloc> ValidDebugAddrRelocs;
+    /// }
 
     /// Index into ValidRelocs of the next relocation to consider. As we walk
     /// the DIEs in acsending file offset and as ValidRelocs is sorted by file
     /// offset, keeping this index up to date is all we have to do to have a
     /// cheap lookup during the root DIE selection and during DIE cloning.
     unsigned NextValidReloc = 0;
 
     RangesTy AddressRanges;
 
   public:
     AddressManager(DwarfLinkerForBinary &Linker, const object::ObjectFile &Obj,
                    const DebugMapObject &DMO)
         : Linker(Linker) {
-      findValidRelocsInDebugInfo(Obj, DMO);
+      findValidRelocsInDebugSections(Obj, DMO);
 
       // Iterate over the debug map entries and put all the ones that are
       // functions (because they have a size) into the Ranges map. This map is
       // very similar to the FunctionRanges that are stored in each unit, with 2
       // notable differences:
       //
       //  1. Obviously this one is global, while the other ones are per-unit.
       //
public:
     }
     virtual ~AddressManager() override { clear(); }
 
     virtual bool areRelocationsResolved() const override { return true; }
 
     bool hasValidRelocs(bool ResetRelocsPtr = true) override {
       if (ResetRelocsPtr)
         NextValidReloc = 0;
-      return !ValidRelocs.empty();
+      return !ValidDebugInfoRelocs.empty() || !ValidDebugAddrRelocs.empty();
     }
 
     /// \defgroup FindValidRelocations Translate debug map into a list
     /// of relevant relocations
     ///
     /// @{
-    bool findValidRelocsInDebugInfo(const object::ObjectFile &Obj,
+    bool findValidRelocsInDebugSections(const object::ObjectFile &Obj,
                                         const DebugMapObject &DMO);
 
     bool findValidRelocs(const object::SectionRef &Section,
                          const object::ObjectFile &Obj,
-                         const DebugMapObject &DMO);
+                         const DebugMapObject &DMO,
+                         std::vector<ValidReloc> &ValidRelocs);
 
     void findValidRelocsMachO(const object::SectionRef &Section,
                               const object::MachOObjectFile &Obj,
-                              const DebugMapObject &DMO);
+                              const DebugMapObject &DMO,
+                              std::vector<ValidReloc> &ValidRelocs);
     /// @}
 
-    bool hasValidRelocationAt(uint64_t StartOffset, uint64_t EndOffset,
+    /// Checks that there is a relocation in the debug_addr section  against a
+    /// debug map entry between \p StartOffset and \p NextOffset.
+    bool hasValidDebugInfoRelocationAt(uint64_t StartOffset, uint64_t EndOffset,
                                        CompileUnit::DIEInfo &Info);
 
+    /// Checks that there is a relocation in the debug_addr section against a
+    /// debug map entry at the given offset.
+    ///
+    /// This function must be called with offsets in strictly ascending order
+    /// because it never looks back at relocations it already 'went past'.
+    /// \returns true and sets Info.InDebugMap if it is the case.
+    bool hasValidDebugAddrRelocationAt(uint64_t Offset);
+
     bool hasLiveMemoryLocation(const DWARFDie &DIE,
                                CompileUnit::DIEInfo &Info) override;
     bool hasLiveAddressRange(const DWARFDie &DIE,
                              CompileUnit::DIEInfo &Info) override;
 
     bool applyValidRelocs(MutableArrayRef<char> Data, uint64_t BaseOffset,
                           bool IsLittleEndian) override;
 
+    uint64_t relocateIndexedAddr(uint64_t Offset) override;
+
     RangesTy &getValidAddressRanges() override { return AddressRanges; }
 
     void clear() override {
       AddressRanges.clear();
-      ValidRelocs.clear();
+      ValidDebugInfoRelocs.clear();
+      ValidDebugAddrRelocs.clear();
       NextValidReloc = 0;
     }
   };
 
 private:
   /// \defgroup Helpers Various helper methods.
   ///
   /// @{

llvm/tools/dsymutil/DwarfLinkerForBinary.cpp

static bool isMachOPairedReloc(uint64_t RelocType, uint64_t Arch) {
   }
 }
 
 /// Iterate over the relocations of the given \p Section and
 /// store the ones that correspond to debug map entries into the
 /// ValidRelocs array.
 void DwarfLinkerForBinary::AddressManager::findValidRelocsMachO(
     const object::SectionRef &Section, const object::MachOObjectFile &Obj,
-    const DebugMapObject &DMO) {
+    const DebugMapObject &DMO, std::vector<ValidReloc> &ValidRelocs) {
   Expected<StringRef> ContentsOrErr = Section.getContents();
   if (!ContentsOrErr) {
     consumeError(ContentsOrErr.takeError());
     Linker.reportWarning("error reading section", DMO.getObjectFilename());
     return;
   }
   DataExtractor Data(*ContentsOrErr, Obj.isLittleEndian(), 0);
   bool SkipNext = false;
 
   for (const object::RelocationRef &Reloc : Section.relocations()) {
     if (SkipNext) {
       SkipNext = false;
       continue;
     }
 
     object::DataRefImpl RelocDataRef = Reloc.getRawDataRefImpl();
     MachO::any_relocation_info MachOReloc = Obj.getRelocation(RelocDataRef);
 
     if (isMachOPairedReloc(Obj.getAnyRelocationType(MachOReloc),
                            Obj.getArch())) {
       SkipNext = true;
-      Linker.reportWarning("unsupported relocation in debug_info section.",
+      Linker.reportWarning("unsupported relocation in " + *Section.getName() +
+                               " section.",
                            DMO.getObjectFilename());
       continue;
     }
 
     unsigned RelocSize = 1 << Obj.getAnyRelocationLength(MachOReloc);
     uint64_t Offset64 = Reloc.getOffset();
     if ((RelocSize != 4 && RelocSize != 8)) {
-      Linker.reportWarning("unsupported relocation in debug_info section.",
+      Linker.reportWarning("unsupported relocation in " + *Section.getName() +
+                               " section.",
                            DMO.getObjectFilename());
       continue;
     }
     uint64_t OffsetCopy = Offset64;
     // Mach-o uses REL relocations, the addend is at the relocation offset.
     uint64_t Addend = Data.getUnsigned(&OffsetCopy, RelocSize);
     uint64_t SymAddress;
     int64_t SymOffset;
for (const object::RelocationRef &Reloc : Section.relocations()) {
     }
   }
 }
 
 /// Dispatch the valid relocation finding logic to the
 /// appropriate handler depending on the object file format.
 bool DwarfLinkerForBinary::AddressManager::findValidRelocs(
     const object::SectionRef &Section, const object::ObjectFile &Obj,
-    const DebugMapObject &DMO) {
+    const DebugMapObject &DMO, std::vector<ValidReloc> &Relocs) {
   // Dispatch to the right handler depending on the file type.
   if (auto *MachOObj = dyn_cast<object::MachOObjectFile>(&Obj))
-    findValidRelocsMachO(Section, *MachOObj, DMO);
+    findValidRelocsMachO(Section, *MachOObj, DMO, Relocs);
   else
     Linker.reportWarning(Twine("unsupported object file type: ") +
                              Obj.getFileName(),
                          DMO.getObjectFilename());
-  if (ValidRelocs.empty())
+  if (Relocs.empty())
     return false;
 
   // Sort the relocations by offset. We will walk the DIEs linearly in
   // the file, this allows us to just keep an index in the relocation
   // array that we advance during our walk, rather than resorting to
   // some associative container. See DwarfLinkerForBinary::NextValidReloc.
-  llvm::sort(ValidRelocs);
+  llvm::sort(Relocs);
   return true;
 }
 
-/// Look for relocations in the debug_info section that match
-/// entries in the debug map. These relocations will drive the Dwarf
-/// link by indicating which DIEs refer to symbols present in the
-/// linked binary.
+/// Look for relocations in the debug_info and debug_addr section that match
+/// entries in the debug map. These relocations will drive the Dwarf link by
+/// indicating which DIEs refer to symbols present in the linked binary.
 /// \returns whether there are any valid relocations in the debug info.
-bool DwarfLinkerForBinary::AddressManager::findValidRelocsInDebugInfo(
+bool DwarfLinkerForBinary::AddressManager::findValidRelocsInDebugSections(
     const object::ObjectFile &Obj, const DebugMapObject &DMO) {
   // Find the debug_info section.
+  bool FoundValidRelocs = false;
   for (const object::SectionRef &Section : Obj.sections()) {
     StringRef SectionName;
     if (Expected<StringRef> NameOrErr = Section.getName())
       SectionName = *NameOrErr;
     else
       consumeError(NameOrErr.takeError());
 
     SectionName = SectionName.substr(SectionName.find_first_not_of("._"));
-    if (SectionName != "debug_info")
-      continue;
-    return findValidRelocs(Section, Obj, DMO);
+    if (SectionName == "debug_info")
+      FoundValidRelocs |=
+          findValidRelocs(Section, Obj, DMO, ValidDebugInfoRelocs);
+    if (SectionName == "debug_addr")
+      FoundValidRelocs |=
+          findValidRelocs(Section, Obj, DMO, ValidDebugAddrRelocs);
   }
-  return false;
+  return FoundValidRelocs;
 }
 
-/// Checks that there is a relocation against an actual debug
-/// map entry between \p StartOffset and \p NextOffset.
-///
-/// This function must be called with offsets in strictly ascending
-/// order because it never looks back at relocations it already 'went past'.
-/// \returns true and sets Info.InDebugMap if it is the case.
-bool DwarfLinkerForBinary::AddressManager::hasValidRelocationAt(
+bool DwarfLinkerForBinary::AddressManager::hasValidDebugAddrRelocationAt(
+    uint64_t Offset) {
+  auto It = std::lower_bound(ValidDebugAddrRelocs.begin(),
+                             ValidDebugAddrRelocs.end(), Offset);
+  return It != ValidDebugAddrRelocs.end();
+}
+
+bool DwarfLinkerForBinary::AddressManager::hasValidDebugInfoRelocationAt(
     uint64_t StartOffset, uint64_t EndOffset, CompileUnit::DIEInfo &Info) {
   assert(NextValidReloc == 0 ||
-         StartOffset > ValidRelocs[NextValidReloc - 1].Offset);
-  if (NextValidReloc >= ValidRelocs.size())
+         StartOffset > ValidDebugInfoRelocs[NextValidReloc - 1].Offset);
+  if (NextValidReloc >= ValidDebugInfoRelocs.size())
     return false;
 
-  uint64_t RelocOffset = ValidRelocs[NextValidReloc].Offset;
+  uint64_t RelocOffset = ValidDebugInfoRelocs[NextValidReloc].Offset;
 
   // We might need to skip some relocs that we didn't consider. For
   // example the high_pc of a discarded DIE might contain a reloc that
   // is in the list because it actually corresponds to the start of a
   // function that is in the debug map.
-  while (RelocOffset < StartOffset && NextValidReloc < ValidRelocs.size() - 1)
-    RelocOffset = ValidRelocs[++NextValidReloc].Offset;
+  while (RelocOffset < StartOffset &&
+         NextValidReloc < ValidDebugInfoRelocs.size() - 1)
+    RelocOffset = ValidDebugInfoRelocs[++NextValidReloc].Offset;
 
   if (RelocOffset < StartOffset || RelocOffset >= EndOffset)
     return false;
 
-  const auto &ValidReloc = ValidRelocs[NextValidReloc++];
+  const auto &ValidReloc = ValidDebugInfoRelocs[NextValidReloc++];
   const auto &Mapping = ValidReloc.Mapping->getValue();
   const uint64_t BinaryAddress = Mapping.BinaryAddress;
   const uint64_t ObjectAddress = Mapping.ObjectAddress
                                      ? uint64_t(*Mapping.ObjectAddress)
                                      : std::numeric_limits<uint64_t>::max();
   if (Linker.Options.Verbose)
     outs() << "Found valid debug map entry: " << ValidReloc.Mapping->getKey()
            << "\t"
getAttributeOffsets(const DWARFAbbreviationDeclaration *Abbrev, unsigned Idx,
   DWARFFormValue::skipValue(Abbrev->getFormByIndex(Idx), Data, &End,
                             Unit.getFormParams());
 
   return std::make_pair(Offset, End);
 }
 
 bool DwarfLinkerForBinary::AddressManager::hasLiveMemoryLocation(
     const DWARFDie &DIE, CompileUnit::DIEInfo &MyInfo) {
-
   const auto *Abbrev = DIE.getAbbreviationDeclarationPtr();
 
   Optional<uint32_t> LocationIdx =
       Abbrev->findAttributeIndex(dwarf::DW_AT_location);
   if (!LocationIdx)
     return false;
 
   uint64_t Offset = DIE.getOffset() + getULEB128Size(Abbrev->getCode());
   uint64_t LocationOffset, LocationEndOffset;
   std::tie(LocationOffset, LocationEndOffset) =
       getAttributeOffsets(Abbrev, *LocationIdx, Offset, *DIE.getDwarfUnit());
 
-  return hasValidRelocationAt(LocationOffset, LocationEndOffset, MyInfo);
+  // FIXME: Support relocations debug_addr.
+  return hasValidDebugInfoRelocationAt(LocationOffset, LocationEndOffset,
+                                       MyInfo);
 }
 
 bool DwarfLinkerForBinary::AddressManager::hasLiveAddressRange(
     const DWARFDie &DIE, CompileUnit::DIEInfo &MyInfo) {
   const auto *Abbrev = DIE.getAbbreviationDeclarationPtr();
 
   Optional<uint32_t> LowPcIdx = Abbrev->findAttributeIndex(dwarf::DW_AT_low_pc);
   if (!LowPcIdx)
     return false;
 
+  dwarf::Form Form = Abbrev->getFormByIndex(*LowPcIdx);
+
+  if (Form == dwarf::DW_FORM_addr) {
     uint64_t Offset = DIE.getOffset() + getULEB128Size(Abbrev->getCode());
     uint64_t LowPcOffset, LowPcEndOffset;
     std::tie(LowPcOffset, LowPcEndOffset) =
         getAttributeOffsets(Abbrev, *LowPcIdx, Offset, *DIE.getDwarfUnit());
+    return hasValidDebugInfoRelocationAt(LowPcOffset, LowPcEndOffset, MyInfo);
+  }
+
+  if (Form == dwarf::DW_FORM_addrx) {
+    Optional<DWARFFormValue> AddrValue = DIE.find(dwarf::DW_AT_low_pc);
+    return hasValidDebugAddrRelocationAt(*AddrValue->getAsAddress());
+  }
 
-  return hasValidRelocationAt(LowPcOffset, LowPcEndOffset, MyInfo);
+  return false;
 }
 /// Apply the valid relocations found by findValidRelocs() to
 /// the buffer \p Data, taking into account that Data is at \p BaseOffset
 /// in the debug_info section.
 ///
 /// Like for findValidRelocs(), this function must be called with
 /// monotonic \p BaseOffset values.
 ///
 /// \returns whether any reloc has been applied.
 bool DwarfLinkerForBinary::AddressManager::applyValidRelocs(
     MutableArrayRef<char> Data, uint64_t BaseOffset, bool IsLittleEndian) {
   assert(areRelocationsResolved());
   assert((NextValidReloc == 0 ||
-          BaseOffset > ValidRelocs[NextValidReloc - 1].Offset) &&
+          BaseOffset > ValidDebugInfoRelocs[NextValidReloc - 1].Offset) &&
          "BaseOffset should only be increasing.");
-  if (NextValidReloc >= ValidRelocs.size())
+  if (NextValidReloc >= ValidDebugInfoRelocs.size())
     return false;
 
   // Skip relocs that haven't been applied.
-  while (NextValidReloc < ValidRelocs.size() &&
-         ValidRelocs[NextValidReloc].Offset < BaseOffset)
+  while (NextValidReloc < ValidDebugInfoRelocs.size() &&
+         ValidDebugInfoRelocs[NextValidReloc].Offset < BaseOffset)
     ++NextValidReloc;
 
   bool Applied = false;
   uint64_t EndOffset = BaseOffset + Data.size();
-  while (NextValidReloc < ValidRelocs.size() &&
-         ValidRelocs[NextValidReloc].Offset >= BaseOffset &&
-         ValidRelocs[NextValidReloc].Offset < EndOffset) {
-    const auto &ValidReloc = ValidRelocs[NextValidReloc++];
+  while (NextValidReloc < ValidDebugInfoRelocs.size() &&
+         ValidDebugInfoRelocs[NextValidReloc].Offset >= BaseOffset &&
+         ValidDebugInfoRelocs[NextValidReloc].Offset < EndOffset) {
+    const auto &ValidReloc = ValidDebugInfoRelocs[NextValidReloc++];
     assert(ValidReloc.Offset - BaseOffset < Data.size());
     assert(ValidReloc.Offset - BaseOffset + ValidReloc.Size <= Data.size());
     char Buf[8];
     uint64_t Value = ValidReloc.Mapping->getValue().BinaryAddress;
     Value += ValidReloc.Addend;
     for (unsigned I = 0; I != ValidReloc.Size; ++I) {
       unsigned Index = IsLittleEndian ? I : (ValidReloc.Size - I - 1);
       Buf[I] = uint8_t(Value >> (Index * 8));
     }
     assert(ValidReloc.Size <= sizeof(Buf));
     memcpy(&Data[ValidReloc.Offset - BaseOffset], Buf, ValidReloc.Size);
     Applied = true;
   }
 
   return Applied;
 }
 
+uint64_t
+DwarfLinkerForBinary::AddressManager::relocateIndexedAddr(uint64_t Offset) {
+  auto It = std::lower_bound(ValidDebugAddrRelocs.begin(),
+                             ValidDebugAddrRelocs.end(), Offset);
+  if (It == ValidDebugAddrRelocs.end())
+    return Offset;
+  return It->Mapping->getValue().BinaryAddress;
+}
+
 bool linkDwarf(raw_fd_ostream &OutFile, BinaryHolder &BinHolder,
                const DebugMap &DM, LinkOptions Options) {
   DwarfLinkerForBinary Linker(OutFile, BinHolder, std::move(Options));
   return Linker.link(DM);
 }
 
 } // namespace dsymutil
 } // namespace llvm