[Dsymutil][Debuginfo][NFC] Reland: Refactor dsymutil to separate DWARF optimizing part. #2.

[avl]

Summary

This patch relands D71271. The problem with D71271 is that it has cyclic dependency:
CodeGen->AsmPrinter->DebugInfoDWARF->CodeGen. To avoid cyclic dependency this patch
puts implementation for DWARFOptimizer into separate library: lib/DWARFLinker.

Thus the difference between this patch and D71271 is in that DWARFOptimizer renamed into
DWARFLinker and it`s files are put into lib/DWARFLinker.

[dblaikie]

Not sure if this is better/worse off as a subdirectory of lib/CodeGen, rather than as a top level library on its own (lib/DWARFOptimizer). Figured I'd mention it, but mostly leave it up to the other dsymutil folks to make the choices here.

[avl]

Not sure if this is better/worse off as a subdirectory of lib/CodeGen, rather than as a top level library on its own (lib/DWARFOptimizer). Figured I'd mention it, but mostly leave it up to the other dsymutil folks to make the choices here.

My idea was that DWARFOptimizer does generation task. F.e. AsmPrinter - generates asm and it is under CodeGen. DWARFOptimizer generates optimized DWARF. That is why I put it under CodeGen.
Though if it is better to put it on top level - lib/DWARFOptimizer - I am OK to do this.

[avl]

ping.

[dblaikie]

In D71839#1795483, @avl wrote:

Not sure if this is better/worse off as a subdirectory of lib/CodeGen, rather than as a top level library on its own (lib/DWARFOptimizer). Figured I'd mention it, but mostly leave it up to the other dsymutil folks to make the choices here.

My idea was that DWARFOptimizer does generation task. F.e. AsmPrinter - generates asm and it is under CodeGen. DWARFOptimizer generates optimized DWARF. That is why I put it under CodeGen.
Though if it is better to put it on top level - lib/DWARFOptimizer - I am OK to do this.

@aprantl @JDevlieghere @probinson any preferences here? If I've got to make the call I'll probably pick lib/DWARFOptimizer or lib/DWARFLinker (probably the latter)

(totally random aside: I Imagine we could have a mode where LLVM's debug info is aware it will be linked with a DWARF aware linker, so it doesn't need to use relocations in some cases (even with DWARFv5, the string relocations (in str_offsets) are still pretty significant & would be nice to skip (as split DWARF manages to skip))

[JDevlieghere]

In D71839#1799149, @dblaikie wrote:

In D71839#1795483, @avl wrote:

Not sure if this is better/worse off as a subdirectory of lib/CodeGen, rather than as a top level library on its own (lib/DWARFOptimizer). Figured I'd mention it, but mostly leave it up to the other dsymutil folks to make the choices here.

My idea was that DWARFOptimizer does generation task. F.e. AsmPrinter - generates asm and it is under CodeGen. DWARFOptimizer generates optimized DWARF. That is why I put it under CodeGen.
Though if it is better to put it on top level - lib/DWARFOptimizer - I am OK to do this.

@aprantl @JDevlieghere @probinson any preferences here? If I've got to make the call I'll probably pick lib/DWARFOptimizer or lib/DWARFLinker (probably the latter)

My personal preference goes to lib/DWARFLinker.

(totally random aside: I Imagine we could have a mode where LLVM's debug info is aware it will be linked with a DWARF aware linker, so it doesn't need to use relocations in some cases (even with DWARFv5, the string relocations (in str_offsets) are still pretty significant & would be nice to skip (as split DWARF manages to skip))

That sounds like an interesting idea indeed!

[dblaikie]

In D71839#1801654, @JDevlieghere wrote:

In D71839#1799149, @dblaikie wrote:

In D71839#1795483, @avl wrote:

Not sure if this is better/worse off as a subdirectory of lib/CodeGen, rather than as a top level library on its own (lib/DWARFOptimizer). Figured I'd mention it, but mostly leave it up to the other dsymutil folks to make the choices here.

My idea was that DWARFOptimizer does generation task. F.e. AsmPrinter - generates asm and it is under CodeGen. DWARFOptimizer generates optimized DWARF. That is why I put it under CodeGen.
Though if it is better to put it on top level - lib/DWARFOptimizer - I am OK to do this.

@aprantl @JDevlieghere @probinson any preferences here? If I've got to make the call I'll probably pick lib/DWARFOptimizer or lib/DWARFLinker (probably the latter)

My personal preference goes to lib/DWARFLinker.

Let's go with that then - thanks for weighing in!

(totally random aside: I Imagine we could have a mode where LLVM's debug info is aware it will be linked with a DWARF aware linker, so it doesn't need to use relocations in some cases (even with DWARFv5, the string relocations (in str_offsets) are still pretty significant & would be nice to skip (as split DWARF manages to skip))

That sounds like an interesting idea indeed!

(realizing I'm not sure who might implement this - it's not a problem for the Apple/MachO debug info distribution model, which is always DWARF aware and I think already avoids/skips using relocations - and it's not going to be a super high priority for Google, I think, since we use Split DWARF a lot (though switching to DWARFv5 accelerator tables which separate strings from the tables (unlike (gnu_)pubnames/pubtypes) it might be valuable to be able to skip those relocations))

[avl]

My personal preference goes to lib/DWARFLinker.

Let's go with that then - thanks for weighing in!

Ok. I would make it lib/DWARFLinker. Thanks.

That sounds like an interesting idea indeed!

(realizing I'm not sure who might implement this - it's not a problem for the Apple/MachO debug info distribution model, which is always DWARF aware and I think already avoids/skips using relocations - >and it's not going to be a super high priority for Google, I think, since we use Split DWARF a lot (though switching to DWARFv5 accelerator tables which separate strings from the tables (unlike >(gnu_)pubnames/pubtypes) it might be valuable to be able to skip those relocations))

I could try to implement it when DWARF aware linker would be done.

[avl]

addressed comments:

renamed DWARFOptimizer into DWARFLinker.
put DWARFLinker into separate library llvm/lib/DWARFLinker.
renamed tools/dsymutil/DwarfLinker into tools/dsymutil/DwarfLinkerForBinary.

[merge_guards_bot]

Unit tests: pass. 61256 tests passed, 0 failed and 736 were skipped.

clang-tidy: fail. Please fix clang-tidy findings.

clang-format: fail. Please format your changes with clang-format by running git-clang-format HEAD^ or applying this patch.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

[avl]

llvm/lib/DWARFLinker/LLVMBuild.txt

20

already changed it to:

parent = Libraries

[avl]

apply clang-tidy/clang-format changes.

[merge_guards_bot]

Unit tests: pass. 61291 tests passed, 0 failed and 736 were skipped.

clang-tidy: fail. Please fix clang-tidy findings.

clang-format: pass.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

llvm/include/llvm/CodeGen/NonRelocatableStringpool.h

-//===- llvm/CodeGen/NonRelocatableStringpool.h - A simple stringpool  -----===//
+//===- NonRelocatableStringpool.h -------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CODEGEN_NONRELOCATABLESTRINGPOOL_H

llvm/include/llvm/DWARFLinker/DWARFLinker.h

+//===- DWARFLinker.h --------------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DWARFLINKER_DWARFLINKER_H
+#define LLVM_DWARFLINKER_DWARFLINKER_H
+
+#include "llvm/CodeGen/NonRelocatableStringpool.h"
+#include "llvm/DWARFLinker/DWARFLinkerDeclContext.h"
+#include "llvm/DebugInfo/DWARF/DWARFCompileUnit.h"
+#include "llvm/DebugInfo/DWARF/DWARFContext.h"
+#include <map>
+
+namespace llvm {
+
+enum class DwarfLinkerClient { Dsymutil, LLD, General };
+
+/// Partial address range. Besides an offset, only the
+/// HighPC is stored. The structure is stored in a map where the LowPC is the
+/// key.
+struct ObjFileAddressRange {
+  /// Function HighPC.
+  uint64_t HighPC;
+  /// Offset to apply to the linked address.
+  /// should be 0 for not-linked object file.
+  int64_t Offset;
+
+  ObjFileAddressRange(uint64_t EndPC, int64_t Offset)
+      : HighPC(EndPC), Offset(Offset) {}
+
+  ObjFileAddressRange() : HighPC(0), Offset(0) {}
+};
+
+/// Map LowPC to ObjFileAddressRange.
+using RangesTy = std::map<uint64_t, ObjFileAddressRange>;
+
+/// AddressesMap represents information about valid addresses used
+/// by debug information. Valid addresses are those which points to
+/// live code sections. i.e. relocations for these addresses point
+/// into sections which would be/are placed into resulting binary.
+class AddressesMap {
+public:
+  virtual ~AddressesMap();
+
+  /// Returns true if represented addresses are from linked file.
+  /// Returns false if represented addresses are from not-linked
+  /// object file.
+  virtual bool areRelocationsResolved() const = 0;
+
+  /// Checks that there are valid relocations against a .debug_info
+  /// section. Reset current relocation pointer if neccessary.
+  virtual bool hasValidRelocs(bool ResetRelocsPtr = true) = 0;
+
+  /// Checks that there is a relocation against .debug_info
+  /// table 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.
+  virtual bool hasValidRelocationAt(uint64_t StartOffset, uint64_t EndOffset,
+                                    CompileUnit::DIEInfo &Info) = 0;
+
+  /// Apply the valid relocations to the buffer \p Data, taking into
+  /// 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;
+
+  /// 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;
+};
+
+} // end namespace llvm
+
+#endif // LLVM_DWARFLINKER_DWARFLINKER_H

llvm/include/llvm/DWARFLinker/DWARFLinkerCompileUnit.h

-//===- tools/dsymutil/CompileUnit.h - Dwarf debug info linker ---*- C++ -*-===//
+//===- DWARFLinkerCompileUnit.h ---------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_TOOLS_DSYMUTIL_COMPILEUNIT_H
-#define LLVM_TOOLS_DSYMUTIL_COMPILEUNIT_H
+#ifndef LLVM_DWARFLINKER_DWARFLINKERCOMPILEUNIT_H
+#define LLVM_DWARFLINKER_DWARFLINKERCOMPILEUNIT_H
 
 #include "llvm/ADT/IntervalMap.h"
 #include "llvm/CodeGen/DIE.h"
 #include "llvm/DebugInfo/DWARF/DWARFUnit.h"
+#include "llvm/Support/DataExtractor.h"
 
 namespace llvm {
-namespace dsymutil {
 
 class DeclContext;
 
 template <typename KeyT, typename ValT>
 using HalfOpenIntervalMap =
     IntervalMap<KeyT, ValT, IntervalMapImpl::NodeSizer<KeyT, ValT>::LeafSize,
                 IntervalMapHalfOpenInfo<KeyT>>;
 
struct PatchLocation {
 
   uint64_t get() const {
     assert(I);
     return I->getDIEInteger().getValue();
   }
 };
 
 /// Stores all information relating to a compile unit, be it in its original
-/// instance in the object file to its brand new cloned and linked DIE tree.
+/// instance in the object file to its brand new cloned and generated DIE tree.
 class CompileUnit {
 public:
   /// Information gathered about a DIE in the object file.
   struct DIEInfo {
     /// Address offset to apply to the described entity.
     int64_t AddrAdjust;
 
     /// ODR Declaration context.
private:
 
   /// The DW_AT_language of this unit.
   uint16_t Language = 0;
 
   /// If this is a Clang module, this holds the module's name.
   std::string ClangModuleName;
 };
 
-} // end namespace dsymutil
 } // end namespace llvm
 
-#endif // LLVM_TOOLS_DSYMUTIL_COMPILEUNIT_H
+#endif // LLVM_DWARFLINKER_DWARFLINKERCOMPILEUNIT_H

llvm/include/llvm/DWARFLinker/DWARFLinkerDeclContext.h

-//===- tools/dsymutil/DeclContext.h - Dwarf debug info linker ---*- C++ -*-===//
+//===- DWARFLinkerDeclContext.h ---------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_TOOLS_DSYMUTIL_DECLCONTEXT_H
-#define LLVM_TOOLS_DSYMUTIL_DECLCONTEXT_H
+#ifndef LLVM_DWARFLINKER_DWARFLINKERDECLCONTEXT_H
+#define LLVM_DWARFLINKER_DWARFLINKERDECLCONTEXT_H
 
-#include "CompileUnit.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseMapInfo.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/CodeGen/NonRelocatableStringpool.h"
+#include "llvm/DWARFLinker/DWARFLinkerCompileUnit.h"
 #include "llvm/DebugInfo/DWARF/DWARFDie.h"
 #include "llvm/Support/Path.h"
 
 namespace llvm {
-namespace dsymutil {
 
 struct DeclMapInfo;
 
 /// Small helper that resolves and caches file paths. This helps reduce the
 /// number of calls to realpath which is expensive. We assume the input are
 /// files, and cache the realpath of their parent. This way we can quickly
 /// resolve different files under the same path.
 class CachedPathResolver {
static bool isEqual(const DeclContext *LHS, const DeclContext *RHS) {
     return LHS->QualifiedNameHash == RHS->QualifiedNameHash &&
            LHS->Line == RHS->Line && LHS->ByteSize == RHS->ByteSize &&
            LHS->Name.data() == RHS->Name.data() &&
            LHS->File.data() == RHS->File.data() &&
            LHS->Parent.QualifiedNameHash == RHS->Parent.QualifiedNameHash;
   }
 };
 
-} // end namespace dsymutil
 } // end namespace llvm
 
-#endif // LLVM_TOOLS_DSYMUTIL_DECLCONTEXT_H
+#endif // LLVM_DWARFLINKER_DWARFLINKERDECLCONTEXT_H

llvm/lib/CMakeLists.txt

 # `Demangle', `Support' and `TableGen' libraries are added on the top-level
 # CMakeLists.txt
 
 add_subdirectory(IR)
 add_subdirectory(FuzzMutate)
 add_subdirectory(IRReader)
 add_subdirectory(CodeGen)
 add_subdirectory(BinaryFormat)
 add_subdirectory(Bitcode)
 add_subdirectory(Bitstream)
+add_subdirectory(DWARFLinker)
 add_subdirectory(Frontend)
 add_subdirectory(Transforms)
 add_subdirectory(Linker)
 add_subdirectory(Analysis)
 add_subdirectory(LTO)
 add_subdirectory(MC)
 add_subdirectory(MCA)
 add_subdirectory(Object)

llvm/lib/CodeGen/NonRelocatableStringpool.cpp

-//===-- llvm/CodeGen/NonRelocatableStringpool.cpp - A simple stringpool  --===//
+//===-- NonRelocatableStringpool.cpp --------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/CodeGen/NonRelocatableStringpool.h"

llvm/lib/DWARFLinker/CMakeLists.txt

+add_llvm_component_library(LLVMDWARFLinker
+  DWARFLinkerCompileUnit.cpp
+  DWARFLinkerDeclContext.cpp
+  DWARFLinker.cpp
+
+  )

llvm/lib/DWARFLinker/DWARFLinker.cpp

+//=== DWARFLinker.cpp -----------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/DWARFLinker/DWARFLinker.h"
+
+namespace llvm {
+
+AddressesMap::~AddressesMap() {}
+
+} // namespace llvm

llvm/lib/DWARFLinker/DWARFLinkerCompileUnit.cpp

-//===- tools/dsymutil/CompileUnit.h - Dwarf compile unit ------------------===//
+//===- DWARFLinkerCompileUnit.cpp -----------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#include "CompileUnit.h"
-#include "DeclContext.h"
+#include "llvm/DWARFLinker/DWARFLinkerCompileUnit.h"
+#include "llvm/DWARFLinker/DWARFLinkerDeclContext.h"
 
 namespace llvm {
-namespace dsymutil {
 
 /// Check if the DIE at \p Idx is in the scope of a function.
 static bool inFunctionScope(CompileUnit &U, unsigned Idx) {
   while (Idx) {
     if (U.getOrigUnit().getDIEAtIndex(Idx).getTag() == dwarf::DW_TAG_subprogram)
       return true;
     Idx = U.getInfo(Idx).ParentIdx;
   }

 
 void CompileUnit::addTypeAccelerator(const DIE *Die,
                                      DwarfStringPoolEntryRef Name,
                                      bool ObjcClassImplementation,
                                      uint32_t QualifiedNameHash) {
   Pubtypes.emplace_back(Name, Die, QualifiedNameHash, ObjcClassImplementation);
 }
 
-} // namespace dsymutil
 } // namespace llvm

llvm/lib/DWARFLinker/DWARFLinkerDeclContext.cpp

-//===- tools/dsymutil/DeclContext.cpp - Declaration context ---------------===//
+//===- DWARFLinkerDeclContext.cpp -----------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#include "DeclContext.h"
+#include "llvm/DWARFLinker/DWARFLinkerDeclContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFDie.h"
 #include "llvm/DebugInfo/DWARF/DWARFUnit.h"
 
 namespace llvm {
-namespace dsymutil {
 
 /// Set the last DIE/CU a context was seen in and, possibly invalidate the
 /// context if it is ambiguous.
 ///
 /// In the current implementation, we don't handle overloaded functions well,
 /// because the argument types are not taken into account when computing the
 /// DeclContext tree.
 ///
PointerIntPair<DeclContext *, 1> DeclContextTree::getChildDeclContext(
   if ((Tag == dwarf::DW_TAG_subprogram &&
        Context.getTag() != dwarf::DW_TAG_structure_type &&
        Context.getTag() != dwarf::DW_TAG_class_type) ||
       (Tag == dwarf::DW_TAG_union_type))
     return PointerIntPair<DeclContext *, 1>(*ContextIter, /* Invalid= */ 1);
 
   return PointerIntPair<DeclContext *, 1>(*ContextIter);
 }
-} // namespace dsymutil
+
 } // namespace llvm

llvm/lib/DWARFLinker/LLVMBuild.txt

-;===- ./tools/dsymutil/LLVMBuild.txt ---------------------*- Conf -*--===;
+;===- ./lib/DWARFLinker/LLVMBuild.txt ---------------*- Conf -*--===;
 ;
 ; Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 ; See https://llvm.org/LICENSE.txt for license information.
 ; SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 ;
 ;===------------------------------------------------------------------------===;
 ;
 ; This is an LLVMBuild description file for the components in this subdirectory.
 ;
 ; For more information on the LLVMBuild system, please see:
 ;
 ;   http://llvm.org/docs/LLVMBuild.html
 ;
 ;===------------------------------------------------------------------------===;
 
 [component_0]
-type = Tool
-name = dsymutil
-parent = Tools
-required_libraries = AsmPrinter DebugInfoDWARF MC Object CodeGen Support all-targets
+type = Library
+name = DWARFLinker
+parent = Libraries
+required_libraries = DebugInfoDWARF AsmPrinter CodeGen MC Object Support

llvm/lib/LLVMBuild.txt

 subdirectories =
  Analysis
  AsmParser
  Bitcode
  Bitstream
  CodeGen
  DebugInfo
  Demangle
+ DWARFLinker
  ExecutionEngine
  Frontend
  FuzzMutate
  LineEditor
  Linker
  IR
  IRReader
  LTO

llvm/tools/dsymutil/CMakeLists.txt

 set(LLVM_TARGET_DEFINITIONS Options.td)
 tablegen(LLVM Options.inc -gen-opt-parser-defs)
 add_public_tablegen_target(DsymutilTableGen)
 
 set(LLVM_LINK_COMPONENTS
   AllTargetsAsmPrinters
   AllTargetsCodeGens
   AllTargetsDescs
   AllTargetsInfos
   AsmPrinter
   DebugInfoDWARF
+  DWARFLinker
   MC
   Object
   CodeGen
   Option
   Remarks
   Support
   Target
   )
 
 add_llvm_tool(dsymutil
   dsymutil.cpp
   BinaryHolder.cpp
   CFBundle.cpp
-  CompileUnit.cpp
   DebugMap.cpp
-  DeclContext.cpp
-  DwarfLinker.cpp
+  DwarfLinkerForBinary.cpp
   DwarfStreamer.cpp
   MachODebugMapParser.cpp
   MachOUtils.cpp
   SymbolMap.cpp
 
   DEPENDS
   intrinsics_gen
   ${tablegen_deps}
   )
 
 if(APPLE)
   target_link_libraries(dsymutil PRIVATE "-framework CoreFoundation")
 endif(APPLE)

llvm/tools/dsymutil/DwarfLinkerForBinary.h

-//===- tools/dsymutil/DwarfLinker.h - Dwarf debug info linker ---*- C++ -*-===//
+//===- tools/dsymutil/DwarfLinkerForBinary.h --------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_DSYMUTIL_DWARFLINKER_H
 #define LLVM_TOOLS_DSYMUTIL_DWARFLINKER_H
 
 #include "BinaryHolder.h"
-#include "CompileUnit.h"
 #include "DebugMap.h"
-#include "DeclContext.h"
 #include "DwarfStreamer.h"
 #include "LinkUtils.h"
+#include "llvm/DWARFLinker/DWARFLinker.h"
+#include "llvm/DWARFLinker/DWARFLinkerCompileUnit.h"
+#include "llvm/DWARFLinker/DWARFLinkerDeclContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
 
 namespace llvm {
 namespace dsymutil {
 
-/// Partial address range for debug map objects. Besides an offset, only the
-/// HighPC is stored. The structure is stored in a map where the LowPC is the
-/// key.
-struct DebugMapObjectRange {
-  /// Function HighPC.
-  uint64_t HighPC;
-  /// Offset to apply to the linked address.
-  int64_t Offset;
-
-  DebugMapObjectRange(uint64_t EndPC, int64_t Offset)
-      : HighPC(EndPC), Offset(Offset) {}
-
-  DebugMapObjectRange() : HighPC(0), Offset(0) {}
-};
-
-/// Map LowPC to DebugMapObjectRange.
-using RangesTy = std::map<uint64_t, DebugMapObjectRange>;
 using UnitListTy = std::vector<std::unique_ptr<CompileUnit>>;
 
 /// The core of the Dwarf linking logic.
 ///
 /// The link of the dwarf information from the object files will be
 /// driven by the selection of 'root DIEs', which are DIEs that
 /// describe variables or functions that are present in the linked
 /// binary (and thus have entries in the debug map). All the debug
 /// information that will be linked (the DIEs, but also the line
 /// tables, ranges, ...) is derived from that set of root DIEs.
 ///
 /// The root DIEs are identified because they contain relocations that
 /// correspond to a debug map entry at specific places (the low_pc for
 /// a function, the location for a variable). These relocations are
 /// called ValidRelocs in the DwarfLinker and are gathered as a very
 /// first step when we start processing a DebugMapObject.
-class DwarfLinker {
+class DwarfLinkerForBinary {
 public:
-  DwarfLinker(raw_fd_ostream &OutFile, BinaryHolder &BinHolder,
+  DwarfLinkerForBinary(raw_fd_ostream &OutFile, BinaryHolder &BinHolder,
                        LinkOptions Options)
       : OutFile(OutFile), BinHolder(BinHolder), Options(std::move(Options)) {}
 
   /// Link the contents of the DebugMap.
   bool link(const DebugMap &);
 
   void reportWarning(const Twine &Warning, const DebugMapObject &DMO,
                      const DWARFDie *DIE = nullptr) const;
 
   /// Flags passed to DwarfLinker::lookForDIEsToKeep
   enum TraversalFlags {
     TF_Keep = 1 << 0,            ///< Mark the traversed DIEs as kept.
     TF_InFunctionScope = 1 << 1, ///< Current scope is a function scope.
     TF_DependencyWalk = 1 << 2,  ///< Walking the dependencies of a kept DIE.
     TF_ParentWalk = 1 << 3,      ///< Walking up the parents of a kept DIE.
     TF_ODR = 1 << 4,             ///< Use the ODR while keeping dependents.
     TF_SkipPC = 1 << 5,          ///< Skip all location attributes.
   };
+
 private:
   /// Remembers the oldest and newest DWARF version we've seen in a unit.
   void updateDwarfVersion(unsigned Version) {
     MaxDwarfVersion = std::max(MaxDwarfVersion, Version);
     MinDwarfVersion = std::min(MinDwarfVersion, Version);
   }
 
   /// Remembers the kinds of accelerator tables we've seen in a unit.
   void updateAccelKind(DWARFContext &Dwarf);
 
   /// Emit warnings as Dwarf compile units to leave a trail after linking.
   bool emitPaperTrailWarnings(const DebugMapObject &DMO, const DebugMap &Map,
                               OffsetsStringPool &StringPool);
 
   /// Keeps track of relocations.
-  class RelocationManager {
+  class RelocationManager : public AddressesMap {
     struct ValidReloc {
       uint64_t Offset;
       uint32_t Size;
       uint64_t Addend;
       const DebugMapObject::DebugMapEntry *Mapping;
 
       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;
       }
     };
 
-    const DwarfLinker &Linker;
+    const DwarfLinkerForBinary &Linker;
 
     /// The valid relocations for the current DebugMapObject.
     /// This vector is sorted by relocation offset.
     std::vector<ValidReloc> ValidRelocs;
 
     /// 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:
-    RelocationManager(DwarfLinker &Linker) : Linker(Linker) {}
+    RelocationManager(DwarfLinkerForBinary &Linker,
+                      const object::ObjectFile &Obj, const DebugMapObject &DMO)
+        : Linker(Linker) {
+      findValidRelocsInDebugInfo(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.
+      //
+      //  2. This one contains not only the functions described in the DIE
+      //     tree, but also the ones that are only in the debug map.
+      //
+      // The latter information is required to reproduce dsymutil's logic while
+      // linking line tables. The cases where this information matters look like
+      // bugs that need to be investigated, but for now we need to reproduce
+      // dsymutil's behavior.
+      // FIXME: Once we understood exactly if that information is needed,
+      // maybe totally remove this (or try to use it to do a real
+      // -gline-tables-only on Darwin.
+      for (const auto &Entry : DMO.symbols()) {
+        const auto &Mapping = Entry.getValue();
+        if (Mapping.Size && Mapping.ObjectAddress)
+          AddressRanges[*Mapping.ObjectAddress] = ObjFileAddressRange(
+              *Mapping.ObjectAddress + Mapping.Size,
+              int64_t(Mapping.BinaryAddress) - *Mapping.ObjectAddress);
+      }
+    }
+    virtual ~RelocationManager() override { clear(); }
 
-    bool hasValidRelocs() const { return !ValidRelocs.empty(); }
+    virtual bool areRelocationsResolved() const override { return true; }
 
-    /// Reset the NextValidReloc counter.
-    void resetValidRelocs() { NextValidReloc = 0; }
+    bool hasValidRelocs(bool ResetRelocsPtr = true) override {
+      if (ResetRelocsPtr)
+        NextValidReloc = 0;
+      return !ValidRelocs.empty();
+    }
 
     /// \defgroup FindValidRelocations Translate debug map into a list
     /// of relevant relocations
     ///
     /// @{
     bool findValidRelocsInDebugInfo(const object::ObjectFile &Obj,
                                     const DebugMapObject &DMO);
 
     bool findValidRelocs(const object::SectionRef &Section,
                          const object::ObjectFile &Obj,
                          const DebugMapObject &DMO);
 
     void findValidRelocsMachO(const object::SectionRef &Section,
                               const object::MachOObjectFile &Obj,
                               const DebugMapObject &DMO);
     /// @}
 
-    bool hasValidRelocation(uint64_t StartOffset, uint64_t EndOffset,
-                            CompileUnit::DIEInfo &Info);
+    bool hasValidRelocationAt(uint64_t StartOffset, uint64_t EndOffset,
+                              CompileUnit::DIEInfo &Info) override;
 
     bool applyValidRelocs(MutableArrayRef<char> Data, uint64_t BaseOffset,
-                          bool IsLittleEndian);
+                          bool IsLittleEndian) override;
+
+    RangesTy &getValidAddressRanges() override { return AddressRanges; }
+
+    void clear() override {
+      AddressRanges.clear();
+      ValidRelocs.clear();
+      NextValidReloc = 0;
+    }
   };
 
   /// Keeps track of data associated with one object during linking.
   struct LinkContext {
+    DwarfLinkerForBinary &Linker;
     DebugMapObject &DMO;
-    const object::ObjectFile *ObjectFile;
-    RelocationManager RelocMgr;
+    const object::ObjectFile *ObjectFile = nullptr;
+    std::unique_ptr<RelocationManager> RelocMgr;
     std::unique_ptr<DWARFContext> DwarfContext;
     RangesTy Ranges;
     UnitListTy CompileUnits;
 
-    LinkContext(const DebugMap &Map, DwarfLinker &Linker, DebugMapObject &DMO)
-        : DMO(DMO), RelocMgr(Linker) {
+    LinkContext(const DebugMap &Map, DwarfLinkerForBinary &Linker,
+                DebugMapObject &DMO)
+        : Linker(Linker), DMO(DMO) {
       // Swift ASTs are not object files.
       if (DMO.getType() == MachO::N_AST) {
         ObjectFile = nullptr;
         return;
       }
-      auto ErrOrObj = Linker.loadObject(DMO, Map);
-      ObjectFile = ErrOrObj ? &*ErrOrObj : nullptr;
-      DwarfContext = ObjectFile ? DWARFContext::create(*ObjectFile) : nullptr;
+      if (auto ErrOrObj = Linker.loadObject(DMO, Map)) {
+        ObjectFile = &*ErrOrObj;
+        DwarfContext = DWARFContext::create(*ObjectFile);
+        RelocMgr.reset(new RelocationManager(Linker, *ObjectFile, DMO));
+      }
     }
 
     /// Clear part of the context that's no longer needed when we're done with
     /// the debug object.
     void Clear() {
       DwarfContext.reset(nullptr);
       CompileUnits.clear();
       Ranges.clear();
+      RelocMgr->clear();
     }
   };
 
   /// Called at the start of a debug object link.
   void startDebugObject(LinkContext &Context);
 
   /// Called at the end of a debug object link.
   void endDebugObject(LinkContext &Context);
Error loadClangModule(DWARFDie CUDie, StringRef FilePath,
                         StringRef ModuleName, uint64_t DwoId,
                         DebugMap &ModuleMap, const DebugMapObject &DMO,
                         RangesTy &Ranges, OffsetsStringPool &OffsetsStringPool,
                         UniquingStringPool &UniquingStringPool,
                         DeclContextTree &ODRContexts, uint64_t ModulesEndOffset,
                         unsigned &UnitID, bool IsLittleEndian,
                         unsigned Indent = 0, bool Quiet = false);
 
-
   /// Mark the passed DIE as well as all the ones it depends on as kept.
   void keepDIEAndDependencies(RelocationManager &RelocMgr, RangesTy &Ranges,
                               const UnitListTy &Units, const DWARFDie &DIE,
                               CompileUnit::DIEInfo &MyInfo,
                               const DebugMapObject &DMO, CompileUnit &CU,
                               bool UseODR);
 
   unsigned shouldKeepDIE(RelocationManager &RelocMgr, RangesTy &Ranges,
bool hasValidRelocation(uint32_t StartOffset, uint32_t EndOffset,
                           CompileUnit::DIEInfo &Info);
   /// @}
 
   /// \defgroup Linking Methods used to link the debug information
   ///
   /// @{
 
   class DIECloner {
-    DwarfLinker &Linker;
+    DwarfLinkerForBinary &Linker;
     RelocationManager &RelocMgr;
 
     /// Allocator used for all the DIEValue objects.
     BumpPtrAllocator &DIEAlloc;
 
     std::vector<std::unique_ptr<CompileUnit>> &CompileUnits;
     LinkOptions Options;
 
   public:
-    DIECloner(DwarfLinker &Linker, RelocationManager &RelocMgr,
+    DIECloner(DwarfLinkerForBinary &Linker, RelocationManager &RelocMgr,
               BumpPtrAllocator &DIEAlloc,
               std::vector<std::unique_ptr<CompileUnit>> &CompileUnits,
               LinkOptions &Options)
         : Linker(Linker), RelocMgr(RelocMgr), DIEAlloc(DIEAlloc),
           CompileUnits(CompileUnits), Options(Options) {}
 
     /// Recursively clone \p InputDIE into an tree of DIE objects
     /// where useless (as decided by lookForDIEsToKeep()) bits have been
private:
 
     /// Helper for cloneDIE.
     void addObjCAccelerator(CompileUnit &Unit, const DIE *Die,
                             DwarfStringPoolEntryRef Name,
                             OffsetsStringPool &StringPool, bool SkipPubSection);
   };
 
   /// Assign an abbreviation number to \p Abbrev
-  void AssignAbbrev(DIEAbbrev &Abbrev);
+  void assignAbbrev(DIEAbbrev &Abbrev);
 
   /// Compute and emit debug_ranges section for \p Unit, and
   /// patch the attributes referencing it.
   void patchRangesForUnit(const CompileUnit &Unit, DWARFContext &Dwarf,
                           const DebugMapObject &DMO) const;
 
   /// Generate and emit the DW_AT_ranges attribute for a compile_unit if it had
   /// one.

llvm/tools/dsymutil/DwarfLinkerForBinary.cpp

-//===- tools/dsymutil/DwarfLinker.cpp - Dwarf debug info linker -----------===//
+//===- tools/dsymutil/DwarfLinkerForBinary.cpp ----------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#include "DwarfLinker.h"
+#include "DwarfLinkerForBinary.h"
 #include "BinaryHolder.h"
 #include "DebugMap.h"
-#include "DeclContext.h"
 #include "DwarfStreamer.h"
 #include "MachOUtils.h"
 #include "dsymutil.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/BitVector.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseMapInfo.h"
 #include "llvm/ADT/DenseSet.h"

 #include "llvm/ADT/Twine.h"
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/BinaryFormat/MachO.h"
 #include "llvm/CodeGen/AccelTable.h"
 #include "llvm/CodeGen/AsmPrinter.h"
 #include "llvm/CodeGen/DIE.h"
 #include "llvm/CodeGen/NonRelocatableStringpool.h"
 #include "llvm/Config/config.h"
+#include "llvm/DWARFLinker/DWARFLinkerDeclContext.h"
 #include "llvm/DebugInfo/DIContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFAbbreviationDeclaration.h"
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFDataExtractor.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugLine.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugRangeList.h"
 #include "llvm/DebugInfo/DWARF/DWARFDie.h"
 #include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
auto CU = std::upper_bound(
         return LHS < RHS->getOrigUnit().getNextUnitOffset();
       });
   return CU != Units.end() ? CU->get() : nullptr;
 }
 
 /// Resolve the DIE attribute reference that has been extracted in \p RefValue.
 /// The resulting DIE might be in another CompileUnit which is stored into \p
 /// ReferencedCU. \returns null if resolving fails for any reason.
-static DWARFDie resolveDIEReference(const DwarfLinker &Linker,
+static DWARFDie resolveDIEReference(const DwarfLinkerForBinary &Linker,
                                     const DebugMapObject &DMO,
                                     const UnitListTy &Units,
                                     const DWARFFormValue &RefValue,
                                     const DWARFDie &DIE, CompileUnit *&RefCU) {
   assert(RefValue.isFormClass(DWARFFormValue::FC_Reference));
   uint64_t RefOffset = *RefValue.getAsReference();
   if ((RefCU = getUnitForOffset(Units, RefOffset)))
     if (const auto RefDie = RefCU->getOrigUnit().getDIEForOffset(RefOffset)) {
static bool isTypeTag(uint16_t Tag) {
   case dwarf::DW_TAG_shared_type:
     return true;
   default:
     break;
   }
   return false;
 }
 
-static Error remarksErrorHandler(const DebugMapObject &DMO, DwarfLinker &Linker,
+static Error remarksErrorHandler(const DebugMapObject &DMO,
+                                 DwarfLinkerForBinary &Linker,
                                  std::unique_ptr<FileError> FE) {
   bool IsArchive = DMO.getObjectFilename().endswith(")");
   // Don't report errors for missing remark files from static
   // archives.
   if (!IsArchive)
     return Error(std::move(FE));
 
   std::string Message = FE->message();
   Error E = FE->takeError();
   Error NewE = handleErrors(std::move(E), [&](std::unique_ptr<ECError> EC) {
     if (EC->convertToErrorCode() != std::errc::no_such_file_or_directory)
       return Error(std::move(EC));
 
     Linker.reportWarning(Message, DMO);
     return Error(Error::success());
   });
 
   if (!NewE)
     return Error::success();
 
   return createFileError(FE->getFileName(), std::move(NewE));
 }
 
-bool DwarfLinker::DIECloner::getDIENames(const DWARFDie &Die,
+bool DwarfLinkerForBinary::DIECloner::getDIENames(const DWARFDie &Die,
                                                   AttributesInfo &Info,
                                                   OffsetsStringPool &StringPool,
                                                   bool StripTemplate) {
   // This function will be called on DIEs having low_pcs and
   // ranges. As getting the name might be more expansive, filter out
   // blocks directly.
   if (Die.getTag() == dwarf::DW_TAG_lexical_block)
     return false;
 
   // FIXME: a bit wasteful as the first getName might return the
   // short name.
if (!Split.second.empty())
       Info.NameWithoutTemplate = StringPool.getEntry(Split.first);
   }
 
   return Info.Name || Info.MangledName;
 }
 
 /// Report a warning to the user, optionally including information about a
 /// specific \p DIE related to the warning.
-void DwarfLinker::reportWarning(const Twine &Warning, const DebugMapObject &DMO,
+void DwarfLinkerForBinary::reportWarning(const Twine &Warning,
+                                         const DebugMapObject &DMO,
                                          const DWARFDie *DIE) const {
   StringRef Context = DMO.getObjectFilename();
   warn(Warning, Context);
 
   if (!Options.Verbose || !DIE)
     return;
 
   DIDumpOptions DumpOpts;
   DumpOpts.ChildRecurseDepth = 0;
   DumpOpts.Verbose = Options.Verbose;
 
   WithColor::note() << "    in DIE:\n";
   DIE->dump(errs(), 6 /* Indent */, DumpOpts);
 }
 
-bool DwarfLinker::createStreamer(const Triple &TheTriple,
+bool DwarfLinkerForBinary::createStreamer(const Triple &TheTriple,
                                           raw_fd_ostream &OutFile) {
   if (Options.NoOutput)
     return true;
 
   Streamer = std::make_unique<DwarfStreamer>(OutFile, Options);
   return Streamer->init(TheTriple);
 }
 
 /// Resolve the relative path to a build artifact referenced by DWARF by
static bool dieNeedsChildrenToBeMeaningful(uint32_t Tag) {
   case dwarf::DW_TAG_subprogram:
   case dwarf::DW_TAG_subroutine_type:
   case dwarf::DW_TAG_union_type:
     return true;
   }
   llvm_unreachable("Invalid Tag");
 }
 
-void DwarfLinker::startDebugObject(LinkContext &Context) {
-  // 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.
-  //
-  //  2. This one contains not only the functions described in the DIE
-  //     tree, but also the ones that are only in the debug map.
-  //
-  // The latter information is required to reproduce dsymutil's logic while
-  // linking line tables. The cases where this information matters look like
-  // bugs that need to be investigated, but for now we need to reproduce
-  // dsymutil's behavior.
-  // FIXME: Once we understood exactly if that information is needed,
-  // maybe totally remove this (or try to use it to do a real
-  // -gline-tables-only on Darwin.
-  for (const auto &Entry : Context.DMO.symbols()) {
-    const auto &Mapping = Entry.getValue();
-    if (Mapping.Size && Mapping.ObjectAddress)
-      Context.Ranges[*Mapping.ObjectAddress] = DebugMapObjectRange(
-          *Mapping.ObjectAddress + Mapping.Size,
-          int64_t(Mapping.BinaryAddress) - *Mapping.ObjectAddress);
-  }
-}
+void DwarfLinkerForBinary::startDebugObject(LinkContext &Context) {}
 
-void DwarfLinker::endDebugObject(LinkContext &Context) {
+void DwarfLinkerForBinary::endDebugObject(LinkContext &Context) {
   Context.Clear();
 
   for (auto I = DIEBlocks.begin(), E = DIEBlocks.end(); I != E; ++I)
     (*I)->~DIEBlock();
   for (auto I = DIELocs.begin(), E = DIELocs.end(); I != E; ++I)
     (*I)->~DIELoc();
 
   DIEBlocks.clear();
static bool isMachOPairedReloc(uint64_t RelocType, uint64_t Arch) {
   default:
     return false;
   }
 }
 
 /// Iterate over the relocations of the given \p Section and
 /// store the ones that correspond to debug map entries into the
 /// ValidRelocs array.
-void DwarfLinker::RelocationManager::findValidRelocsMachO(
+void DwarfLinkerForBinary::RelocationManager::findValidRelocsMachO(
     const object::SectionRef &Section, const object::MachOObjectFile &Obj,
     const DebugMapObject &DMO) {
   Expected<StringRef> ContentsOrErr = Section.getContents();
   if (!ContentsOrErr) {
     consumeError(ContentsOrErr.takeError());
     Linker.reportWarning("error reading section", DMO);
     return;
   }
if (Sym != Obj.symbol_end()) {
       // map doesn't need to be offset.
       ValidRelocs.emplace_back(Offset64, RelocSize, SymOffset, Mapping);
     }
   }
 }
 
 /// Dispatch the valid relocation finding logic to the
 /// appropriate handler depending on the object file format.
-bool DwarfLinker::RelocationManager::findValidRelocs(
+bool DwarfLinkerForBinary::RelocationManager::findValidRelocs(
     const object::SectionRef &Section, const object::ObjectFile &Obj,
     const DebugMapObject &DMO) {
   // Dispatch to the right handler depending on the file type.
   if (auto *MachOObj = dyn_cast<object::MachOObjectFile>(&Obj))
     findValidRelocsMachO(Section, *MachOObj, DMO);
   else
     Linker.reportWarning(
         Twine("unsupported object file type: ") + Obj.getFileName(), DMO);
bool DwarfLinkerForBinary::RelocationManager::findValidRelocs(
   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.
 /// \returns whether there are any valid relocations in the debug info.
-bool DwarfLinker::RelocationManager::findValidRelocsInDebugInfo(
+bool DwarfLinkerForBinary::RelocationManager::findValidRelocsInDebugInfo(
     const object::ObjectFile &Obj, const DebugMapObject &DMO) {
   // Find the debug_info section.
   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);
   }
   return false;
 }
 
 /// 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 DwarfLinker::RelocationManager::hasValidRelocation(
+bool DwarfLinkerForBinary::RelocationManager::hasValidRelocationAt(
     uint64_t StartOffset, uint64_t EndOffset, CompileUnit::DIEInfo &Info) {
   assert(NextValidReloc == 0 ||
          StartOffset > ValidRelocs[NextValidReloc - 1].Offset);
   if (NextValidReloc >= ValidRelocs.size())
     return false;
 
   uint64_t RelocOffset = ValidRelocs[NextValidReloc].Offset;
 
getAttributeOffsets(const DWARFAbbreviationDeclaration *Abbrev, unsigned Idx,
   DWARFFormValue::skipValue(Abbrev->getFormByIndex(Idx), Data, &End,
                             Unit.getFormParams());
 
   return std::make_pair(Offset, End);
 }
 
 /// Check if a variable describing DIE should be kept.
 /// \returns updated TraversalFlags.
-unsigned DwarfLinker::shouldKeepVariableDIE(RelocationManager &RelocMgr,
-                                            const DWARFDie &DIE,
-                                            CompileUnit &Unit,
-                                            CompileUnit::DIEInfo &MyInfo,
-                                            unsigned Flags) {
+unsigned DwarfLinkerForBinary::shouldKeepVariableDIE(
+    RelocationManager &RelocMgr, const DWARFDie &DIE, CompileUnit &Unit,
+    CompileUnit::DIEInfo &MyInfo, unsigned Flags) {
   const auto *Abbrev = DIE.getAbbreviationDeclarationPtr();
 
   // Global variables with constant value can always be kept.
   if (!(Flags & TF_InFunctionScope) &&
       Abbrev->findAttributeIndex(dwarf::DW_AT_const_value)) {
     MyInfo.InDebugMap = true;
     return Flags | TF_Keep;
   }
unsigned DwarfLinkerForBinary::shouldKeepVariableDIE(
   std::tie(LocationOffset, LocationEndOffset) =
       getAttributeOffsets(Abbrev, *LocationIdx, Offset, OrigUnit);
 
   // See if there is a relocation to a valid debug map entry inside
   // this variable's location. The order is important here. We want to
   // always check if the variable has a valid relocation, so that the
   // DIEInfo is filled. However, we don't want a static variable in a
   // function to force us to keep the enclosing function.
-  if (!RelocMgr.hasValidRelocation(LocationOffset, LocationEndOffset, MyInfo) ||
+  if (!RelocMgr.hasValidRelocationAt(LocationOffset, LocationEndOffset,
+                                     MyInfo) ||
       (Flags & TF_InFunctionScope))
     return Flags;
 
   if (Options.Verbose) {
     outs() << "Keeping variable DIE:";
     DIDumpOptions DumpOpts;
     DumpOpts.ChildRecurseDepth = 0;
     DumpOpts.Verbose = Options.Verbose;
     DIE.dump(outs(), 8 /* Indent */, DumpOpts);
   }
 
   return Flags | TF_Keep;
 }
 
 /// Check if a function describing DIE should be kept.
 /// \returns updated TraversalFlags.
-unsigned DwarfLinker::shouldKeepSubprogramDIE(
+unsigned DwarfLinkerForBinary::shouldKeepSubprogramDIE(
     RelocationManager &RelocMgr, RangesTy &Ranges, const DWARFDie &DIE,
     const DebugMapObject &DMO, CompileUnit &Unit, CompileUnit::DIEInfo &MyInfo,
     unsigned Flags) {
   const auto *Abbrev = DIE.getAbbreviationDeclarationPtr();
 
   Flags |= TF_InFunctionScope;
 
   Optional<uint32_t> LowPcIdx = Abbrev->findAttributeIndex(dwarf::DW_AT_low_pc);
   if (!LowPcIdx)
     return Flags;
 
   uint64_t Offset = DIE.getOffset() + getULEB128Size(Abbrev->getCode());
   DWARFUnit &OrigUnit = Unit.getOrigUnit();
   uint64_t LowPcOffset, LowPcEndOffset;
   std::tie(LowPcOffset, LowPcEndOffset) =
       getAttributeOffsets(Abbrev, *LowPcIdx, Offset, OrigUnit);
 
   auto LowPc = dwarf::toAddress(DIE.find(dwarf::DW_AT_low_pc));
   assert(LowPc.hasValue() && "low_pc attribute is not an address.");
   if (!LowPc ||
-      !RelocMgr.hasValidRelocation(LowPcOffset, LowPcEndOffset, MyInfo))
+      !RelocMgr.hasValidRelocationAt(LowPcOffset, LowPcEndOffset, MyInfo))
     return Flags;
 
   if (Options.Verbose) {
     outs() << "Keeping subprogram DIE:";
     DIDumpOptions DumpOpts;
     DumpOpts.ChildRecurseDepth = 0;
     DumpOpts.Verbose = Options.Verbose;
     DIE.dump(outs(), 8 /* Indent */, DumpOpts);
unsigned DwarfLinkerForBinary::shouldKeepSubprogramDIE(
   Optional<uint64_t> HighPc = DIE.getHighPC(*LowPc);
   if (!HighPc) {
     reportWarning("Function without high_pc. Range will be discarded.\n", DMO,
                   &DIE);
     return Flags;
   }
 
   // Replace the debug map range with a more accurate one.
-  Ranges[*LowPc] = DebugMapObjectRange(*HighPc, MyInfo.AddrAdjust);
+  Ranges[*LowPc] = ObjFileAddressRange(*HighPc, MyInfo.AddrAdjust);
   Unit.addFunctionRange(*LowPc, *HighPc, MyInfo.AddrAdjust);
   return Flags;
 }
 
 /// Check if a DIE should be kept.
 /// \returns updated TraversalFlags.
-unsigned DwarfLinker::shouldKeepDIE(RelocationManager &RelocMgr,
-                                    RangesTy &Ranges, const DWARFDie &DIE,
-                                    const DebugMapObject &DMO,
-                                    CompileUnit &Unit,
-                                    CompileUnit::DIEInfo &MyInfo,
-                                    unsigned Flags) {
+unsigned DwarfLinkerForBinary::shouldKeepDIE(
+    RelocationManager &RelocMgr, RangesTy &Ranges, const DWARFDie &DIE,
+    const DebugMapObject &DMO, CompileUnit &Unit, CompileUnit::DIEInfo &MyInfo,
   switch (DIE.getTag()) {
   case dwarf::DW_TAG_constant:
   case dwarf::DW_TAG_variable:
     return shouldKeepVariableDIE(RelocMgr, DIE, Unit, MyInfo, Flags);
   case dwarf::DW_TAG_subprogram:
   case dwarf::DW_TAG_label:
     return shouldKeepSubprogramDIE(RelocMgr, Ranges, DIE, DMO, Unit, MyInfo,
                                    Flags);
static void lookForChildDIEsToKeep(const DWARFDie &Die, CompileUnit &CU,
                                    unsigned Flags,
                                    SmallVectorImpl<WorklistItem> &Worklist) {
   // The TF_ParentWalk flag tells us that we are currently walking up the
   // parent chain of a required DIE, and we don't want to mark all the children
   // of the parents as kept (consider for example a DW_TAG_namespace node in
   // the parent chain). There are however a set of DIE types for which we want
   // to ignore that directive and still walk their children.
   if (dieNeedsChildrenToBeMeaningful(Die.getTag()))
-    Flags &= ~DwarfLinker::TF_ParentWalk;
+    Flags &= ~DwarfLinkerForBinary::TF_ParentWalk;
 
   // We're finished if this DIE has no children or we're walking the parent
   // chain.
-  if (!Die.hasChildren() || (Flags & DwarfLinker::TF_ParentWalk))
+  if (!Die.hasChildren() || (Flags & DwarfLinkerForBinary::TF_ParentWalk))
     return;
 
   // Add children in reverse order to the worklist to effectively process them
   // in order.
   for (auto Child : reverse(Die.children())) {
     // Add a worklist item before every child to calculate incompleteness right
     // after the current child is processed.
     unsigned Idx = CU.getOrigUnit().getDIEIndex(Child);
     CompileUnit::DIEInfo &ChildInfo = CU.getInfo(Idx);
     Worklist.emplace_back(Die, CU, WorklistItemType::UpdateChildIncompleteness,
                           &ChildInfo);
     Worklist.emplace_back(Child, CU, Flags);
   }
 }
 
 /// Look at DIEs referenced by the given DIE and decide whether they should be
 /// kept. All DIEs referenced though attributes should be kept.
 static void lookForRefDIEsToKeep(const DWARFDie &Die, CompileUnit &CU,
-                                 unsigned Flags, DwarfLinker &Linker,
+                                 unsigned Flags, DwarfLinkerForBinary &Linker,
                                  const UnitListTy &Units,
                                  const DebugMapObject &DMO,
                                  SmallVectorImpl<WorklistItem> &Worklist) {
-  bool UseOdr = (Flags & DwarfLinker::TF_DependencyWalk)
-                    ? (Flags & DwarfLinker::TF_ODR)
+  bool UseOdr = (Flags & DwarfLinkerForBinary::TF_DependencyWalk)
+                    ? (Flags & DwarfLinkerForBinary::TF_ODR)
                     : CU.hasODR();
   DWARFUnit &Unit = CU.getOrigUnit();
   DWARFDataExtractor Data = Unit.getDebugInfoExtractor();
   const auto *Abbrev = Die.getAbbreviationDeclarationPtr();
   uint64_t Offset = Die.getOffset() + getULEB128Size(Abbrev->getCode());
 
   SmallVector<std::pair<DWARFDie, CompileUnit &>, 4> ReferencedDIEs;
   for (const auto &AttrSpec : Abbrev->attributes()) {
if (auto RefDie =
       // Keep a module forward declaration if there is no definition.
       if (!(isODRAttribute(AttrSpec.Attr) && Info.Ctxt &&
             Info.Ctxt->getCanonicalDIEOffset()))
         Info.Prune = false;
       ReferencedDIEs.emplace_back(RefDie, *ReferencedCU);
     }
   }
 
-  unsigned ODRFlag = UseOdr ? DwarfLinker::TF_ODR : 0;
+  unsigned ODRFlag = UseOdr ? DwarfLinkerForBinary::TF_ODR : 0;
 
   // Add referenced DIEs in reverse order to the worklist to effectively
   // process them in order.
   for (auto &P : reverse(ReferencedDIEs)) {
     // Add a worklist item before every child to calculate incompleteness right
     // after the current child is processed.
     uint32_t RefIdx = P.second.getOrigUnit().getDIEIndex(P.first);
     CompileUnit::DIEInfo &Info = P.second.getInfo(RefIdx);
     Worklist.emplace_back(Die, CU, WorklistItemType::UpdateRefIncompleteness,
                           &Info);
     Worklist.emplace_back(P.first, P.second,
-                          DwarfLinker::TF_Keep |
-                              DwarfLinker::TF_DependencyWalk | ODRFlag);
+                          DwarfLinkerForBinary::TF_Keep |
+                              DwarfLinkerForBinary::TF_DependencyWalk |
+                              ODRFlag);
   }
 }
 
 /// Look at the parent of the given DIE and decide whether they should be kept.
 static void lookForParentDIEsToKeep(unsigned AncestorIdx, CompileUnit &CU,
                                     unsigned Flags,
                                     SmallVectorImpl<WorklistItem> &Worklist) {
   // Stop if we encounter an ancestor that's already marked as kept.

 ///
 /// The recursive nature of the algorithm is simulated by running the "main"
 /// algorithm (LookForDIEsToKeep) followed by either looking at more DIEs
 /// (LookForChildDIEsToKeep, LookForRefDIEsToKeep, LookForParentDIEsToKeep) or
 /// fixing up a computed property (UpdateChildIncompleteness,
 /// UpdateRefIncompleteness).
 ///
 /// The return value indicates whether the DIE is incomplete.
-void DwarfLinker::lookForDIEsToKeep(RelocationManager &RelocMgr,
-                                    RangesTy &Ranges, const UnitListTy &Units,
+void DwarfLinkerForBinary::lookForDIEsToKeep(RelocationManager &RelocMgr,
+                                             RangesTy &Ranges,
+                                             const UnitListTy &Units,
                                              const DWARFDie &Die,
-                                    const DebugMapObject &DMO, CompileUnit &Cu,
-                                    unsigned Flags) {
+                                             const DebugMapObject &DMO,
+                                             CompileUnit &Cu, unsigned Flags) {
   // LIFO work list.
   SmallVector<WorklistItem, 4> Worklist;
   Worklist.emplace_back(Die, Cu, Flags);
 
   while (!Worklist.empty()) {
     WorklistItem Current = Worklist.back();
     Worklist.pop_back();
 

 }
 
 /// Assign an abbreviation number to \p Abbrev.
 ///
 /// Our DIEs get freed after every DebugMapObject has been processed,
 /// thus the FoldingSet we use to unique DIEAbbrevs cannot refer to
 /// the instances hold by the DIEs. When we encounter an abbreviation
 /// that we don't know, we create a permanent copy of it.
-void DwarfLinker::AssignAbbrev(DIEAbbrev &Abbrev) {
+void DwarfLinkerForBinary::assignAbbrev(DIEAbbrev &Abbrev) {
   // Check the set for priors.
   FoldingSetNodeID ID;
   Abbrev.Profile(ID);
   void *InsertToken;
   DIEAbbrev *InSet = AbbreviationsSet.FindNodeOrInsertPos(ID, InsertToken);
 
   // If it's newly added.
   if (InSet) {
     // Assign existing abbreviation number.
     Abbrev.setNumber(InSet->getNumber());
   } else {
     // Add to abbreviation list.
     Abbreviations.push_back(
         std::make_unique<DIEAbbrev>(Abbrev.getTag(), Abbrev.hasChildren()));
     for (const auto &Attr : Abbrev.getData())
       Abbreviations.back()->AddAttribute(Attr.getAttribute(), Attr.getForm());
     AbbreviationsSet.InsertNode(Abbreviations.back().get(), InsertToken);
     // Assign the unique abbreviation number.
     Abbrev.setNumber(Abbreviations.size());
     Abbreviations.back()->setNumber(Abbreviations.size());
   }
 }
 
-unsigned DwarfLinker::DIECloner::cloneStringAttribute(
+unsigned DwarfLinkerForBinary::DIECloner::cloneStringAttribute(
     DIE &Die, AttributeSpec AttrSpec, const DWARFFormValue &Val,
     const DWARFUnit &U, OffsetsStringPool &StringPool, AttributesInfo &Info) {
   // Switch everything to out of line strings.
   const char *String = *Val.getAsCString();
   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;
 
   Die.addValue(DIEAlloc, dwarf::Attribute(AttrSpec.Attr), dwarf::DW_FORM_strp,
                DIEInteger(StringEntry.getOffset()));
 
   return 4;
 }
 
-unsigned DwarfLinker::DIECloner::cloneDieReferenceAttribute(
+unsigned DwarfLinkerForBinary::DIECloner::cloneDieReferenceAttribute(
     DIE &Die, const DWARFDie &InputDIE, AttributeSpec AttrSpec,
     unsigned AttrSize, const DWARFFormValue &Val, const DebugMapObject &DMO,
     CompileUnit &Unit) {
   const DWARFUnit &U = Unit.getOrigUnit();
   uint64_t Ref = *Val.getAsReference();
   DIE *NewRefDie = nullptr;
   CompileUnit *RefUnit = nullptr;
   DeclContext *Ctxt = nullptr;
if (AttrSpec.Form == dwarf::DW_FORM_ref_addr ||
     return U.getRefAddrByteSize();
   }
 
   Die.addValue(DIEAlloc, dwarf::Attribute(AttrSpec.Attr),
                dwarf::Form(AttrSpec.Form), DIEEntry(*NewRefDie));
   return AttrSize;
 }
 
-void DwarfLinker::DIECloner::cloneExpression(
+void DwarfLinkerForBinary::DIECloner::cloneExpression(
     DataExtractor &Data, DWARFExpression Expression, const DebugMapObject &DMO,
     CompileUnit &Unit, SmallVectorImpl<uint8_t> &OutputBuffer) {
   using Encoding = DWARFExpression::Operation::Encoding;
 
   uint64_t OpOffset = 0;
   for (auto &Op : Expression) {
     auto Description = Op.getDescription();
     // DW_OP_const_type is variable-length and has 3
if ((Op0 == Encoding::BaseTypeRef && Op1 == Encoding::SizeNA) ||
       // Copy over everything else unmodified.
       StringRef Bytes = Data.getData().slice(OpOffset, Op.getEndOffset());
       OutputBuffer.append(Bytes.begin(), Bytes.end());
     }
     OpOffset = Op.getEndOffset();
   }
 }
 
-unsigned DwarfLinker::DIECloner::cloneBlockAttribute(
+unsigned DwarfLinkerForBinary::DIECloner::cloneBlockAttribute(
     DIE &Die, const DebugMapObject &DMO, CompileUnit &Unit,
     AttributeSpec AttrSpec, const DWARFFormValue &Val, unsigned AttrSize,
     bool IsLittleEndian) {
   DIEValueList *Attr;
   DIEValue Value;
   DIELoc *Loc = nullptr;
   DIEBlock *Block = nullptr;
   if (AttrSpec.Form == dwarf::DW_FORM_exprloc) {
if (Loc)
       Loc->ComputeSize(AsmPrinter);
     else
       Block->ComputeSize(AsmPrinter);
   }
   Die.addValue(DIEAlloc, Value);
   return AttrSize;
 }
 
-unsigned DwarfLinker::DIECloner::cloneAddressAttribute(
+unsigned DwarfLinkerForBinary::DIECloner::cloneAddressAttribute(
     DIE &Die, AttributeSpec AttrSpec, const DWARFFormValue &Val,
     const CompileUnit &Unit, AttributesInfo &Info) {
   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),
if (Die.getTag() == dwarf::DW_TAG_compile_unit) {
       Addr = (Info.OrigHighPc ? Info.OrigHighPc : Addr) + Info.PCOffset;
   }
 
   Die.addValue(DIEAlloc, static_cast<dwarf::Attribute>(AttrSpec.Attr),
                static_cast<dwarf::Form>(AttrSpec.Form), DIEInteger(Addr));
   return Unit.getOrigUnit().getAddressByteSize();
 }
 
-unsigned DwarfLinker::DIECloner::cloneScalarAttribute(
+unsigned DwarfLinkerForBinary::DIECloner::cloneScalarAttribute(
     DIE &Die, const DWARFDie &InputDIE, const DebugMapObject &DMO,
     CompileUnit &Unit, AttributeSpec AttrSpec, const DWARFFormValue &Val,
     unsigned AttrSize, AttributesInfo &Info) {
   uint64_t Value;
 
   if (LLVM_UNLIKELY(Linker.Options.Update)) {
     if (auto OptionalValue = Val.getAsUnsignedConstant())
       Value = *OptionalValue;
if (AttrSpec.Attr == dwarf::DW_AT_ranges) {
     Info.HasRanges = true;
   }
 
   // A more generic way to check for location attributes would be
   // nice, but it's very unlikely that any other attribute needs a
   // location list.
   // FIXME: use DWARFAttribute::mayHaveLocationDescription().
   else if (AttrSpec.Attr == dwarf::DW_AT_location ||
            AttrSpec.Attr == dwarf::DW_AT_frame_base)
     Unit.noteLocationAttribute(Patch, Info.PCOffset);
   else if (AttrSpec.Attr == dwarf::DW_AT_declaration && Value)
     Info.IsDeclaration = true;
 
   return AttrSize;
 }
 
 /// Clone \p InputDIE's attribute described by \p AttrSpec with
 /// value \p Val, and add it to \p Die.
 /// \returns the size of the cloned attribute.
-unsigned DwarfLinker::DIECloner::cloneAttribute(
+unsigned DwarfLinkerForBinary::DIECloner::cloneAttribute(
     DIE &Die, const DWARFDie &InputDIE, const DebugMapObject &DMO,
     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:

 /// 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 DwarfLinker::RelocationManager::applyValidRelocs(
+bool DwarfLinkerForBinary::RelocationManager::applyValidRelocs(
     MutableArrayRef<char> Data, uint64_t BaseOffset, bool IsLittleEndian) {
   assert((NextValidReloc == 0 ||
           BaseOffset > ValidRelocs[NextValidReloc - 1].Offset) &&
          "BaseOffset should only be increasing.");
   if (NextValidReloc >= ValidRelocs.size())
     return false;
 
   // Skip relocs that haven't been applied.
bool DwarfLinkerForBinary::RelocationManager::applyValidRelocs(
   return Applied;
 }
 
 static bool isObjCSelector(StringRef Name) {
   return Name.size() > 2 && (Name[0] == '-' || Name[0] == '+') &&
          (Name[1] == '[');
 }
 
-void DwarfLinker::DIECloner::addObjCAccelerator(CompileUnit &Unit,
-                                                const DIE *Die,
-                                                DwarfStringPoolEntryRef Name,
-                                                OffsetsStringPool &StringPool,
-                                                bool SkipPubSection) {
+void DwarfLinkerForBinary::DIECloner::addObjCAccelerator(
+    CompileUnit &Unit, const DIE *Die, DwarfStringPoolEntryRef Name,
+    OffsetsStringPool &StringPool, bool SkipPubSection) {
   assert(isObjCSelector(Name.getString()) && "not an objc selector");
   // Objective C method or class function.
   // "- [Class(Category) selector :withArg ...]"
   StringRef ClassNameStart(Name.getString().drop_front(2));
   size_t FirstSpace = ClassNameStart.find(' ');
   if (FirstSpace == StringRef::npos)
     return;
 
case dwarf::DW_AT_frame_base:
     // 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 &&
                        !InDebugMap)) &&
            !DWARFFormValue(AttrSpec.Form).isFormClass(DWARFFormValue::FC_Block);
   }
 }
 
-DIE *DwarfLinker::DIECloner::cloneDIE(
+DIE *DwarfLinkerForBinary::DIECloner::cloneDIE(
     const DWARFDie &InputDIE, const DebugMapObject &DMO, CompileUnit &Unit,
     OffsetsStringPool &StringPool, int64_t PCOffset, uint32_t OutOffset,
     unsigned Flags, bool IsLittleEndian, DIE *Die) {
   DWARFUnit &U = Unit.getOrigUnit();
   unsigned Idx = U.getDIEIndex(InputDIE);
   CompileUnit::DIEInfo &Info = Unit.getInfo(Idx);
 
   // Should the DIE appear in the output?
DIE *DwarfLinkerForBinary::DIECloner::cloneDIE(
 
   // We could copy the data only if we need to apply a relocation to it. After
   // testing, it seems there is no performance downside to doing the copy
   // unconditionally, and it makes the code simpler.
   SmallString<40> DIECopy(Data.getData().substr(Offset, NextOffset - Offset));
   Data =
       DWARFDataExtractor(DIECopy, Data.isLittleEndian(), Data.getAddressSize());
   // Modify the copy with relocated addresses.
-  if (RelocMgr.applyValidRelocs(DIECopy, Offset, Data.isLittleEndian())) {
+  if (RelocMgr.areRelocationsResolved() &&
+      RelocMgr.applyValidRelocs(DIECopy, Offset, Data.isLittleEndian())) {
     // If we applied relocations, we store the value of high_pc that was
     // potentially stored in the input DIE. If high_pc is an address
     // (Dwarf version == 2), then it might have been relocated to a
     // totally unrelated value (because the end address in the object
     // file might be start address of another function which got moved
     // independently by the linker). The computation of the actual
     // high_pc value is done in cloneAddressAttribute().
     AttrInfo.OrigHighPc =
if (Unit.getInfo(Idx).Keep) {
       break;
     }
   }
 
   DIEAbbrev NewAbbrev = Die->generateAbbrev();
   if (HasChildren)
     NewAbbrev.setChildrenFlag(dwarf::DW_CHILDREN_yes);
   // Assign a permanent abbrev number
-  Linker.AssignAbbrev(NewAbbrev);
+  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());
DIE *DwarfLinkerForBinary::DIECloner::cloneDIE(
   // Update our size.
   Die->setSize(OutOffset - Die->getOffset());
   return Die;
 }
 
 /// Patch the input object file relevant debug_ranges entries
 /// and emit them in the output file. Update the relevant attributes
 /// to point at the new entries.
-void DwarfLinker::patchRangesForUnit(const CompileUnit &Unit,
+void DwarfLinkerForBinary::patchRangesForUnit(const CompileUnit &Unit,
                                               DWARFContext &OrigDwarf,
                                               const DebugMapObject &DMO) const {
   DWARFDebugRangeList RangeList;
   const auto &FunctionRanges = Unit.getFunctionRanges();
   unsigned AddressSize = Unit.getOrigUnit().getAddressByteSize();
   DWARFDataExtractor RangeExtractor(OrigDwarf.getDWARFObj(),
                                     OrigDwarf.getDWARFObj().getRangesSection(),
                                     OrigDwarf.isLittleEndian(), AddressSize);
   auto InvalidRange = FunctionRanges.end(), CurrRange = InvalidRange;
   DWARFUnit &OrigUnit = Unit.getOrigUnit();

 }
 
 /// Generate the debug_aranges entries for \p Unit and if the
 /// unit has a DW_AT_ranges attribute, also emit the debug_ranges
 /// contribution for this attribute.
 /// FIXME: this could actually be done right in patchRangesForUnit,
 /// but for the sake of initial bit-for-bit compatibility with legacy
 /// dsymutil, we have to do it in a delayed pass.
-void DwarfLinker::generateUnitRanges(CompileUnit &Unit) const {
+void DwarfLinkerForBinary::generateUnitRanges(CompileUnit &Unit) const {
   auto Attr = Unit.getUnitRangesAttribute();
   if (Attr)
     Attr->set(Streamer->getRangesSectionSize());
   Streamer->emitUnitRangesEntries(Unit, static_cast<bool>(Attr));
 }
 
 /// Insert the new line info sequence \p Seq into the current
 /// set of already linked line info \p Rows.
for (auto &V : Die.values())
     }
 
   llvm_unreachable("Didn't find DW_AT_stmt_list in cloned DIE!");
 }
 
 /// Extract the line table for \p Unit from \p OrigDwarf, and
 /// recreate a relocated version of these for the address ranges that
 /// are present in the binary.
-void DwarfLinker::patchLineTableForUnit(CompileUnit &Unit,
+void DwarfLinkerForBinary::patchLineTableForUnit(CompileUnit &Unit,
                                                  DWARFContext &OrigDwarf,
                                                  RangesTy &Ranges,
                                                  const DebugMapObject &DMO) {
   DWARFDie CUDie = Unit.getOrigUnit().getUnitDIE();
   auto StmtList = dwarf::toSectionOffset(CUDie.find(dwarf::DW_AT_stmt_list));
   if (!StmtList)
     return;
 
   // Update the cloned DW_AT_stmt_list with the correct debug_line offset.
   if (auto *OutputDIE = Unit.getOutputUnitDIE())
     patchStmtList(*OutputDIE, DIEInteger(Streamer->getLineSectionSize()));
else {
     Params.DWARF2LineRange = LineTable.Prologue.LineRange;
     Streamer->emitLineTableForUnit(Params,
                                    LineData.slice(*StmtList + 4, PrologueEnd),
                                    LineTable.Prologue.MinInstLength, NewRows,
                                    Unit.getOrigUnit().getAddressByteSize());
   }
 }
 
-void DwarfLinker::emitAcceleratorEntriesForUnit(CompileUnit &Unit) {
+void DwarfLinkerForBinary::emitAcceleratorEntriesForUnit(CompileUnit &Unit) {
   switch (Options.TheAccelTableKind) {
   case AccelTableKind::Apple:
     emitAppleAcceleratorEntriesForUnit(Unit);
     break;
   case AccelTableKind::Dwarf:
     emitDwarfAcceleratorEntriesForUnit(Unit);
     break;
   case AccelTableKind::Default:
     llvm_unreachable("The default must be updated to a concrete value.");
     break;
   }
 }
 
-void DwarfLinker::emitAppleAcceleratorEntriesForUnit(CompileUnit &Unit) {
+void DwarfLinkerForBinary::emitAppleAcceleratorEntriesForUnit(
+    CompileUnit &Unit) {
   // Add namespaces.
   for (const auto &Namespace : Unit.getNamespaces())
     AppleNamespaces.addName(Namespace.Name,
                             Namespace.Die->getOffset() + Unit.getStartOffset());
 
   /// Add names.
   if (!Options.Minimize)
     Streamer->emitPubNamesForUnit(Unit);
AppleTypes.addName(
                                         : 0,
         Pubtype.QualifiedNameHash);
 
   /// Add ObjC names.
   for (const auto &ObjC : Unit.getObjC())
     AppleObjc.addName(ObjC.Name, ObjC.Die->getOffset() + Unit.getStartOffset());
 }
 
-void DwarfLinker::emitDwarfAcceleratorEntriesForUnit(CompileUnit &Unit) {
+void DwarfLinkerForBinary::emitDwarfAcceleratorEntriesForUnit(
+    CompileUnit &Unit) {
   for (const auto &Namespace : Unit.getNamespaces())
     DebugNames.addName(Namespace.Name, Namespace.Die->getOffset(),
                        Namespace.Die->getTag(), Unit.getUniqueID());
   for (const auto &Pubname : Unit.getPubnames())
     DebugNames.addName(Pubname.Name, Pubname.Die->getOffset(),
                        Pubname.Die->getTag(), Unit.getUniqueID());
   for (const auto &Pubtype : Unit.getPubtypes())
     DebugNames.addName(Pubtype.Name, Pubtype.Die->getOffset(),
                        Pubtype.Die->getTag(), Unit.getUniqueID());
 }
 
 /// Read the frame info stored in the object, and emit the
 /// patched frame descriptions for the linked binary.
 ///
 /// This is actually pretty easy as the data of the CIEs and FDEs can
 /// be considered as black boxes and moved as is. The only thing to do
 /// is to patch the addresses in the headers.
-void DwarfLinker::patchFrameInfoForObject(const DebugMapObject &DMO,
+void DwarfLinkerForBinary::patchFrameInfoForObject(const DebugMapObject &DMO,
                                                    RangesTy &Ranges,
                                                    DWARFContext &OrigDwarf,
                                                    unsigned AddrSize) {
   StringRef FrameData = OrigDwarf.getDWARFObj().getFrameSection().Data;
   if (FrameData.empty())
     return;
 
   DataExtractor Data(FrameData, OrigDwarf.isLittleEndian(), 0);
   uint64_t InputOffset = 0;
 
   // Store the data of the CIEs defined in this object, keyed by their
while (Data.isValidOffset(InputOffset)) {
     unsigned FDERemainingBytes = InitialLength - (4 + AddrSize);
     Streamer->emitFDE(IteratorInserted.first->getValue(), AddrSize,
                       Loc + Range->second.Offset,
                       FrameData.substr(InputOffset, FDERemainingBytes));
     InputOffset += FDERemainingBytes;
   }
 }
 
-void DwarfLinker::DIECloner::copyAbbrev(
-    const DWARFAbbreviationDeclaration &Abbrev, bool hasODR) {
+void DwarfLinkerForBinary::DIECloner::copyAbbrev(
+    const DWARFAbbreviationDeclaration &Abbrev, bool HasODR) {
   DIEAbbrev Copy(dwarf::Tag(Abbrev.getTag()),
                  dwarf::Form(Abbrev.hasChildren()));
 
   for (const auto &Attr : Abbrev.attributes()) {
     uint16_t Form = Attr.Form;
-    if (hasODR && isODRAttribute(Attr.Attr))
+    if (HasODR && isODRAttribute(Attr.Attr))
       Form = dwarf::DW_FORM_ref_addr;
     Copy.AddAttribute(dwarf::Attribute(Attr.Attr), dwarf::Form(Form));
   }
 
-  Linker.AssignAbbrev(Copy);
+  Linker.assignAbbrev(Copy);
 }
 
-uint32_t
-DwarfLinker::DIECloner::hashFullyQualifiedName(DWARFDie DIE, CompileUnit &U,
-                                               const DebugMapObject &DMO,
-                                               int ChildRecurseDepth) {
+uint32_t DwarfLinkerForBinary::DIECloner::hashFullyQualifiedName(
+    DWARFDie DIE, CompileUnit &U, const DebugMapObject &DMO,
   const char *Name = nullptr;
   DWARFUnit *OrigUnit = &U.getOrigUnit();
   CompileUnit *CU = &U;
   Optional<DWARFFormValue> Ref;
 
   while (1) {
     if (const char *CurrentName = DIE.getName(DINameKind::ShortName))
       Name = CurrentName;

 static uint64_t getDwoId(const DWARFDie &CUDie, const DWARFUnit &Unit) {
   auto DwoId = dwarf::toUnsigned(
       CUDie.find({dwarf::DW_AT_dwo_id, dwarf::DW_AT_GNU_dwo_id}));
   if (DwoId)
     return *DwoId;
   return 0;
 }
 
-bool DwarfLinker::registerModuleReference(
+bool DwarfLinkerForBinary::registerModuleReference(
     DWARFDie CUDie, const DWARFUnit &Unit, DebugMap &ModuleMap,
     const DebugMapObject &DMO, RangesTy &Ranges, OffsetsStringPool &StringPool,
     UniquingStringPool &UniquingStringPool, DeclContextTree &ODRContexts,
     uint64_t ModulesEndOffset, unsigned &UnitID, bool IsLittleEndian,
     unsigned Indent, bool Quiet) {
   std::string PCMfile = dwarf::toString(
       CUDie.find({dwarf::DW_AT_dwo_name, dwarf::DW_AT_GNU_dwo_name}), "");
   if (PCMfile.empty())
if (Error E = loadClangModule(CUDie, PCMfile, Name, DwoId, ModuleMap, DMO,
                                 IsLittleEndian, Indent + 2, Quiet)) {
     consumeError(std::move(E));
     return false;
   }
   return true;
 }
 
 ErrorOr<const object::ObjectFile &>
-DwarfLinker::loadObject(const DebugMapObject &Obj, const DebugMap &Map) {
+DwarfLinkerForBinary::loadObject(const DebugMapObject &Obj,
+                                 const DebugMap &Map) {
   auto ObjectEntry =
       BinHolder.getObjectEntry(Obj.getObjectFilename(), Obj.getTimestamp());
   if (!ObjectEntry) {
     auto Err = ObjectEntry.takeError();
     reportWarning(
         Twine(Obj.getObjectFilename()) + ": " + toString(std::move(Err)), Obj);
     return errorToErrorCode(std::move(Err));
   }
 
   auto Object = ObjectEntry->getObject(Map.getTriple());
   if (!Object) {
     auto Err = Object.takeError();
     reportWarning(
         Twine(Obj.getObjectFilename()) + ": " + toString(std::move(Err)), Obj);
     return errorToErrorCode(std::move(Err));
   }
 
   return *Object;
 }
 
-Error DwarfLinker::loadClangModule(
+Error DwarfLinkerForBinary::loadClangModule(
     DWARFDie CUDie, StringRef Filename, StringRef ModuleName, uint64_t DwoId,
     DebugMap &ModuleMap, const DebugMapObject &DMO, RangesTy &Ranges,
     OffsetsStringPool &StringPool, UniquingStringPool &UniquingStringPool,
     DeclContextTree &ODRContexts, uint64_t ModulesEndOffset, unsigned &UnitID,
     bool IsLittleEndian, unsigned Indent, bool Quiet) {
   /// Using a SmallString<0> because loadClangModule() is recursive.
   SmallString<0> Path(Options.PrependPath);
   if (sys::path::is_relative(Filename))
if (!ErrOrObj) {
     }
     return Error::success();
   }
 
   std::unique_ptr<CompileUnit> Unit;
 
   // Setup access to the debug info.
   auto DwarfContext = DWARFContext::create(*ErrOrObj);
-  RelocationManager RelocMgr(*this);
+  RelocationManager RelocMgr(*this, *ErrOrObj, DMO);
 
   for (const auto &CU : DwarfContext->compile_units()) {
     updateDwarfVersion(CU->getVersion());
     // Recursively get all modules imported by this one.
     auto CUDie = CU->getUnitDIE(false);
     if (!CUDie)
       continue;
     if (!registerModuleReference(CUDie, *CU, ModuleMap, DMO, Ranges, StringPool,
if (!registerModuleReference(CUDie, *CU, ModuleMap, DMO, Ranges, StringPool,
                   Filename,
               DMO);
         // Update the cache entry with the DwoId of the module loaded from disk.
         ClangModules[Filename] = PCMDwoId;
       }
 
       // Add this module.
       Unit = std::make_unique<CompileUnit>(*CU, UnitID++, !Options.NoODR,
-                                            ModuleName);
       Unit->setHasInterestingContent();
       analyzeContextInfo(CUDie, 0, *Unit, &ODRContexts.getRoot(),
                          UniquingStringPool, ODRContexts, ModulesEndOffset,
                          ParseableSwiftInterfaces,
                          [&](const Twine &Warning, const DWARFDie &DIE) {
                            reportWarning(Warning, DMO, &DIE);
                          });
       // Keep everything.
Error DwarfLinkerForBinary::loadClangModule(
   UnitListTy CompileUnits;
   CompileUnits.push_back(std::move(Unit));
   DIECloner(*this, RelocMgr, DIEAlloc, CompileUnits, Options)
       .cloneAllCompileUnits(*DwarfContext, DMO, Ranges, StringPool,
                             IsLittleEndian);
   return Error::success();
 }
 
-void DwarfLinker::DIECloner::cloneAllCompileUnits(
+void DwarfLinkerForBinary::DIECloner::cloneAllCompileUnits(
     DWARFContext &DwarfContext, const DebugMapObject &DMO, RangesTy &Ranges,
     OffsetsStringPool &StringPool, bool IsLittleEndian) {
   if (!Linker.Streamer)
     return;
 
   for (auto &CurrentUnit : CompileUnits) {
     auto InputDIE = CurrentUnit->getOrigUnit().getUnitDIE();
     CurrentUnit->setStartOffset(Linker.OutputDebugInfoSize);
for (auto &CurrentUnit : CompileUnits) {
     if (!CurrentUnit->getOutputUnitDIE())
       continue;
 
     Linker.Streamer->emitCompileUnitHeader(*CurrentUnit);
     Linker.Streamer->emitDIE(*CurrentUnit->getOutputUnitDIE());
   }
 }
 
-void DwarfLinker::updateAccelKind(DWARFContext &Dwarf) {
+void DwarfLinkerForBinary::updateAccelKind(DWARFContext &Dwarf) {
   if (Options.TheAccelTableKind != AccelTableKind::Default)
     return;
 
   auto &DwarfObj = Dwarf.getDWARFObj();
 
   if (!AtLeastOneDwarfAccelTable &&
       (!DwarfObj.getAppleNamesSection().Data.empty() ||
        !DwarfObj.getAppleTypesSection().Data.empty() ||
        !DwarfObj.getAppleNamespacesSection().Data.empty() ||
        !DwarfObj.getAppleObjCSection().Data.empty())) {
     AtLeastOneAppleAccelTable = true;
   }
 
-  if (!AtLeastOneDwarfAccelTable &&
-      !DwarfObj.getNamesSection().Data.empty()) {
+  if (!AtLeastOneDwarfAccelTable && !DwarfObj.getNamesSection().Data.empty()) {
     AtLeastOneDwarfAccelTable = true;
   }
 }
 
-bool DwarfLinker::emitPaperTrailWarnings(const DebugMapObject &DMO,
-                                         const DebugMap &Map,
-                                         OffsetsStringPool &StringPool) {
+bool DwarfLinkerForBinary::emitPaperTrailWarnings(
+    const DebugMapObject &DMO, const DebugMap &Map,
   if (DMO.getWarnings().empty() || !DMO.empty())
     return false;
 
   Streamer->switchToDebugInfoSection(/* Version */ 2);
   DIE *CUDie = DIE::get(DIEAlloc, dwarf::DW_TAG_compile_unit);
   CUDie->setOffset(11);
   StringRef Producer = StringPool.internString("dsymutil");
   StringRef File = StringPool.internString(DMO.getObjectFilename());
ConstDie.addValue(DIEAlloc, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag,
                       DIEInteger(1));
     ConstDie.addValue(DIEAlloc, dwarf::DW_AT_const_value, dwarf::DW_FORM_strp,
                       DIEInteger(StringPool.getStringOffset(Warning)));
   }
   unsigned Size = 4 /* FORM_strp */ + File.size() + 1 +
                   DMO.getWarnings().size() * (4 + 1 + 4) +
                   1 /* End of children */;
   DIEAbbrev Abbrev = CUDie->generateAbbrev();
-  AssignAbbrev(Abbrev);
+  assignAbbrev(Abbrev);
   CUDie->setAbbrevNumber(Abbrev.getNumber());
   Size += getULEB128Size(Abbrev.getNumber());
   // Abbreviation ordering needed for classic compatibility.
   for (auto &Child : CUDie->children()) {
     Abbrev = Child.generateAbbrev();
-    AssignAbbrev(Abbrev);
+    assignAbbrev(Abbrev);
     Child.setAbbrevNumber(Abbrev.getNumber());
     Size += getULEB128Size(Abbrev.getNumber());
   }
   CUDie->setSize(Size);
   auto &Asm = Streamer->getAsmPrinter();
   Asm.emitInt32(11 + CUDie->getSize() - 4);
   Asm.emitInt16(2);
   Asm.emitInt32(0);
for (auto &I : ParseableSwiftInterfaces) {
     sys::path::append(Path, ModuleName);
     Path.append(".swiftinterface");
     if (Options.Verbose)
       outs() << "copy parseable Swift interface " << InterfaceFile << " -> "
              << Path.str() << '\n';
 
     // copy_file attempts an APFS clone first, so this should be cheap.
     if ((EC = sys::fs::copy_file(InterfaceFile, Path.str())))
-      warn(Twine("cannot copy parseable Swift interface ") +
-           InterfaceFile + ": " +
-           toString(errorCodeToError(EC)));
+      warn(Twine("cannot copy parseable Swift interface ") + InterfaceFile +
+           ": " + toString(errorCodeToError(EC)));
     Path.resize(BaseLength);
   }
   return Error::success();
 }
 
 static Error emitRemarks(const LinkOptions &Options, StringRef BinaryPath,
-                         StringRef ArchName,
-                         const remarks::RemarkLinker &RL) {
+                         StringRef ArchName, const remarks::RemarkLinker &RL) {
   // Make sure we don't create the directories and the file if there is nothing
   // to serialize.
   if (RL.empty())
     return Error::success();
 
   SmallString<128> InputPath;
   SmallString<128> Path;
   // Create the "Remarks" directory in the "Resources" directory.
if (EC)
     return errorCodeToError(EC);
 
   if (Error E = RL.serialize(OS, Options.RemarksFormat))
     return E;
 
   return Error::success();
 }
 
-bool DwarfLinker::link(const DebugMap &Map) {
+bool DwarfLinkerForBinary::link(const DebugMap &Map) {
   if (!createStreamer(Map.getTriple(), OutFile))
     return false;
 
   // Size of the DIEs (and headers) generated for the linked output.
   OutputDebugInfoSize = 0;
   // A unique ID that identifies each compile unit.
   unsigned UnitID = 0;
   DebugMap ModuleMap(Map.getTriple(), Map.getBinaryPath());
if (emitPaperTrailWarnings(LinkContext.DMO, Map, OffsetsStringPool))
       continue;
 
     if (!LinkContext.ObjectFile)
       continue;
 
     // Look for relocations that correspond to debug map entries.
 
     if (LLVM_LIKELY(!Options.Update) &&
-        !LinkContext.RelocMgr.findValidRelocsInDebugInfo(
-            *LinkContext.ObjectFile, LinkContext.DMO)) {
+        !LinkContext.RelocMgr->hasValidRelocs()) {
       if (Options.Verbose)
         outs() << "No valid relocations found. Skipping.\n";
 
       // Clear this ObjFile entry as a signal to other loops that we should not
       // process this iteration.
       LinkContext.ObjectFile = nullptr;
       continue;
     }
auto CloneLambda = [&](size_t i) {
     // cross-cu references require the ParentIdx to be setup for every CU in
     // the object file before calling this.
     if (LLVM_UNLIKELY(Options.Update)) {
       for (auto &CurrentUnit : LinkContext.CompileUnits)
         CurrentUnit->markEverythingAsKept();
       Streamer->copyInvariantDebugSection(*LinkContext.ObjectFile);
     } else {
       for (auto &CurrentUnit : LinkContext.CompileUnits)
-        lookForDIEsToKeep(LinkContext.RelocMgr, LinkContext.Ranges,
+        lookForDIEsToKeep(*LinkContext.RelocMgr, LinkContext.Ranges,
                           LinkContext.CompileUnits,
                           CurrentUnit->getOrigUnit().getUnitDIE(),
                           LinkContext.DMO, *CurrentUnit, 0);
     }
 
     // The calls to applyValidRelocs inside cloneDIE will walk the reloc
     // array again (in the same way findValidRelocsInDebugInfo() did). We
     // need to reset the NextValidReloc index to the beginning.
-    LinkContext.RelocMgr.resetValidRelocs();
-    if (LinkContext.RelocMgr.hasValidRelocs() || LLVM_UNLIKELY(Options.Update))
-      DIECloner(*this, LinkContext.RelocMgr, DIEAlloc, LinkContext.CompileUnits,
-                Options)
+    if (LinkContext.RelocMgr->hasValidRelocs() || LLVM_UNLIKELY(Options.Update))
+      DIECloner(*this, *LinkContext.RelocMgr, DIEAlloc,
+                LinkContext.CompileUnits, Options)
           .cloneAllCompileUnits(*LinkContext.DwarfContext, LinkContext.DMO,
                                 LinkContext.Ranges, OffsetsStringPool,
                                 LinkContext.DwarfContext->isLittleEndian());
     if (!Options.NoOutput && !LinkContext.CompileUnits.empty() &&
         LLVM_LIKELY(!Options.Update))
       patchFrameInfoForObject(
           LinkContext.DMO, LinkContext.Ranges, *LinkContext.DwarfContext,
           LinkContext.CompileUnits[0]->getOrigUnit().getAddressByteSize());
if (auto E =
       return error(toString(std::move(E)));
   }
 
   return Streamer->finish(Map, Options.Translator);
 } // namespace dsymutil
 
 bool linkDwarf(raw_fd_ostream &OutFile, BinaryHolder &BinHolder,
                const DebugMap &DM, LinkOptions Options) {
-  DwarfLinker Linker(OutFile, BinHolder, std::move(Options));
+  DwarfLinkerForBinary Linker(OutFile, BinHolder, std::move(Options));
   return Linker.link(DM);
 }
 
 } // namespace dsymutil
 } // namespace llvm

llvm/tools/dsymutil/DwarfStreamer.h

 //===- tools/dsymutil/DwarfStreamer.h - Dwarf Streamer ----------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_DSYMUTIL_DWARFSTREAMER_H
 #define LLVM_TOOLS_DSYMUTIL_DWARFSTREAMER_H
 
-#include "CompileUnit.h"
 #include "DebugMap.h"
 #include "LinkUtils.h"
 #include "llvm/CodeGen/AccelTable.h"
 #include "llvm/CodeGen/AsmPrinter.h"
 #include "llvm/CodeGen/NonRelocatableStringpool.h"
+#include "llvm/DWARFLinker/DWARFLinkerCompileUnit.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugLine.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugRangeList.h"
 #include "llvm/MC/MCAsmBackend.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCCodeEmitter.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCDwarf.h"
 #include "llvm/MC/MCInstrInfo.h"

llvm/tools/dsymutil/DwarfStreamer.cpp

 //===- tools/dsymutil/DwarfStreamer.cpp - Dwarf Streamer ------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "DwarfStreamer.h"
-#include "CompileUnit.h"
 #include "LinkUtils.h"
 #include "MachOUtils.h"
 #include "llvm/ADT/Triple.h"
+#include "llvm/DWARFLinker/DWARFLinkerCompileUnit.h"
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/MC/MCTargetOptions.h"
 #include "llvm/MC/MCTargetOptionsCommandFlags.inc"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Target/TargetOptions.h"
 

llvm/tools/dsymutil/LLVMBuild.txt

 ;   http://llvm.org/docs/LLVMBuild.html
 ;
 ;===------------------------------------------------------------------------===;
 
 [component_0]
 type = Tool
 name = dsymutil
 parent = Tools
-required_libraries = AsmPrinter DebugInfoDWARF MC Object CodeGen Support all-targets
+required_libraries = AsmPrinter DebugInfoDWARF DWARFLinker MC Object CodeGen Support all-targets