[DWARFLinkerParallel] Add interface files, create a skeleton implementation.

[avl]

Summary

This patch creates skeleton implementation for the DWARFLinkerParallel.
It also integrates DWARFLinkerParallel into dsymutil and llvm-dwarfutil,
so that empty DWARFLinker::link() can be called. To do this new command
line option is added "--linker apple/llvm". Additionally it changes
existing DWARFLinker interfaces/implementations to be compatible:
use Error for error reporting for the DWARFStreamer, make DWARFFile to
owner of referenced resources, other small refactorings. This patch is extracted from D96035.

Depends on D147455

[avl]

rebased.

[JDevlieghere]

LGTM modulo inline comments. They're all nits so feel free to land this once they've been addressed.

llvm/include/llvm/DWARFLinkerParallel/DWARFFile.h

23–24

llvm/include/llvm/DWARFLinkerParallel/DWARFLinker.h

43–49

56–57

61–65

69–72

91–92

llvm/tools/dsymutil/DwarfLinkerForBinary.cpp

557

Can we add a meaningful error string?

594

This probably needs an unreachable to make (older versions) of gcc happy.

llvm_unreachable("All cases handled above!");

llvm/tools/dsymutil/dsymutil.cpp

248–254

Let's remove these newlines to be consistent with the existing code surrounding it.

[avl]

addressed comments.

[avl]

Thank you for the review!

[kda]

This is breaking Sanitizer buildbots:
https://lab.llvm.org/buildbot/#/builders/168/builds/13834
https://lab.llvm.org/buildbot/#/builders/239/builds/2578
https://lab.llvm.org/buildbot/#/builders/5/builds/34173

It looks like basic-linking-x86.test is not so good.

[avl]

In D147952#4394692, @kda wrote:

This is breaking Sanitizer buildbots:
https://lab.llvm.org/buildbot/#/builders/168/builds/13834
https://lab.llvm.org/buildbot/#/builders/239/builds/2578
https://lab.llvm.org/buildbot/#/builders/5/builds/34173

It looks like basic-linking-x86.test is not so good.

Thank you for reporting issue. Should be fixed by https://reviews.llvm.org/rGd2d32f39217f4cf15926ec6ae23e28447c3f5052.

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/ADT/AddressRanges.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/CodeGen/AccelTable.h"
 #include "llvm/CodeGen/NonRelocatableStringpool.h"
 #include "llvm/DWARFLinker/DWARFLinkerCompileUnit.h"
+#include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugLine.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugRangeList.h"
 #include "llvm/DebugInfo/DWARF/DWARFDie.h"
 #include "llvm/DebugInfo/DWARF/DWARFExpression.h"
 #include <map>
 
 namespace llvm {
-class DWARFContext;
 class DWARFExpression;
 class DWARFUnit;
 class DataExtractor;
 class DeclContextTree;
 template <typename T> class SmallVectorImpl;
 
 enum class DwarfLinkerClient { Dsymutil, LLD, General };
 
-/// The kind of accelerator tables we should emit.
-enum class DwarfLinkerAccelTableKind : uint8_t {
-  Apple,     ///< .apple_names, .apple_namespaces, .apple_types, .apple_objc.
-  Pub,       ///< .debug_pubnames, .debug_pubtypes
-  DebugNames ///< .debug_names.
-};
-
 /// 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();
 
public:
   /// Returns size of generated .debug_macinfo section.
   virtual uint64_t getDebugMacInfoSectionSize() const = 0;
 
   /// Returns size of generated .debug_macro section.
   virtual uint64_t getDebugMacroSectionSize() const = 0;
 
   /// Returns size of generated .debug_loclists section.
   virtual uint64_t getLocListsSectionSize() const = 0;
+
+  /// Dump the file to the disk.
+  virtual void finish() = 0;
+
+  /// Emit the swift_ast section stored in \p Buffer.
+  virtual void emitSwiftAST(StringRef Buffer) = 0;
+
+  /// Emit the swift reflection section stored in \p Buffer.
+  virtual void emitSwiftReflectionSection(
+      llvm::binaryformat::Swift5ReflectionSectionKind ReflSectionKind,
+      StringRef Buffer, uint32_t Alignment, uint32_t Size) = 0;
+
+  /// Returns underlying AsmPrinter.
+  virtual AsmPrinter &getAsmPrinter() const = 0;
 };
 
+class DwarfStreamer;
 using UnitListTy = std::vector<std::unique_ptr<CompileUnit>>;
 
 /// This class represents DWARF information for source file
 /// and its address map.
 class DWARFFile {
 public:
-  DWARFFile(StringRef Name, DWARFContext *Dwarf, AddressesMap *Addresses,
+  DWARFFile(StringRef Name, std::unique_ptr<DWARFContext> Dwarf,
+            std::unique_ptr<AddressesMap> Addresses,
             const std::vector<std::string> &Warnings)
-      : FileName(Name), Dwarf(Dwarf), Addresses(Addresses), Warnings(Warnings) {
-  }
+      : FileName(Name), Dwarf(std::move(Dwarf)),
+        Addresses(std::move(Addresses)), Warnings(Warnings) {}
 
   /// The object file name.
   StringRef FileName;
 
   /// The source DWARF information.
-  DWARFContext *Dwarf = nullptr;
+  std::unique_ptr<DWARFContext> Dwarf;
 
   /// Helpful address information(list of valid address ranges, relocations).
-  AddressesMap *Addresses = nullptr;
+  std::unique_ptr<AddressesMap> Addresses;
 
   /// Warnings for this object file.
   const std::vector<std::string> &Warnings;
 };
 
-typedef std::function<void(const Twine &Warning, StringRef Context,
-                           const DWARFDie *DIE)>
-    messageHandler;
-typedef std::function<void(const DWARFFile &File)> inputVerificationHandler;
-typedef std::function<ErrorOr<DWARFFile &>(StringRef ContainerName,
-                                           StringRef Path)>
-    objFileLoader;
 typedef std::map<std::string, std::string> swiftInterfacesMap;
 typedef std::map<std::string, std::string> objectPrefixMap;
 
 typedef function_ref<void(const DWARFUnit &Unit)> CompileUnitHandler;
 
 /// The core of the Dwarf linking logic.
 ///
 /// The generation 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 resolves to the corresponding
 /// code section(and thus have entries in the Addresses map). All the debug
 /// information that will be generated(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
 /// points to code section(the low_pc for a function, the location for
 /// a variable). These relocations are called ValidRelocs in the
 /// AddressesInfo and are gathered as a very first step when we start
 /// processing a object file.
 class DWARFLinker {
 public:
-  DWARFLinker(DwarfEmitter *Emitter,
-              DwarfLinkerClient ClientID = DwarfLinkerClient::General)
-      : TheDwarfEmitter(Emitter), DwarfLinkerClientID(ClientID) {}
+  typedef std::function<void(const Twine &Warning, StringRef Context,
+                             const DWARFDie *DIE)>
+      messageHandler;
+  DWARFLinker(messageHandler ErrorHandler, messageHandler WarningHandler,
+              std::function<StringRef(StringRef)> StringsTranslator)
+      : DwarfLinkerClientID(DwarfLinkerClient::Dsymutil),
+        StringsTranslator(StringsTranslator), ErrorHandler(ErrorHandler),
+        WarningHandler(WarningHandler) {}
+
+  static std::unique_ptr<DWARFLinker> createLinker(
+      messageHandler ErrorHandler, messageHandler WarningHandler,
+      std::function<StringRef(StringRef)> StringsTranslator = nullptr) {
+    return std::make_unique<DWARFLinker>(ErrorHandler, WarningHandler,
+                                         StringsTranslator);
+  }
+
+  /// Type of output file.
+  enum class OutputFileType {
+    Object,
+    Assembly,
+  };
+
+  /// The kind of accelerator tables we should emit.
+  enum class AccelTableKind : uint8_t {
+    Apple,     ///< .apple_names, .apple_namespaces, .apple_types, .apple_objc.
+    Pub,       ///< .debug_pubnames, .debug_pubtypes
+    DebugNames ///< .debug_names.
+  };
+  typedef std::function<void(const DWARFFile &File)> inputVerificationHandler;
+  typedef std::function<ErrorOr<DWARFFile &>(StringRef ContainerName,
+                                             StringRef Path)>
+      objFileLoader;
+
+  Error createEmitter(const Triple &TheTriple, OutputFileType FileType,
+                      raw_pwrite_stream &OutFile);
+
+  DwarfEmitter *getEmitter();
 
   /// Add object file to be linked. Pre-load compile unit die. Call
   /// \p OnCUDieLoaded for each compile unit die. If specified \p File
   /// has reference to the Clang module then such module would be
   /// pre-loaded by \p Loader for !Update case.
   ///
   /// \pre NoODR, Update options should be set before call to addObjectFile.
   void addObjectFile(
       DWARFFile &File, objFileLoader Loader = nullptr,
       CompileUnitHandler OnCUDieLoaded = [](const DWARFUnit &) {});
 
-  /// Link debug info for added objFiles. Object
-  /// files are linked all together.
+  /// Link debug info for added objFiles. Object files are linked all together.
   Error link();
 
   /// A number of methods setting various linking options:
 
   /// Allows to generate log of linking process to the standard output.
   void setVerbosity(bool Verbose) { Options.Verbose = Verbose; }
 
   /// Print statistics to standard output.
   void setStatistics(bool Statistics) { Options.Statistics = Statistics; }
 
   /// Verify the input DWARF.
   void setVerifyInputDWARF(bool Verify) { Options.VerifyInputDWARF = Verify; }
 
-  /// Do not emit linked dwarf info.
-  void setNoOutput(bool NoOut) { Options.NoOutput = NoOut; }
-
   /// Do not unique types according to ODR.
   void setNoODR(bool NoODR) { Options.NoODR = NoODR; }
 
-  /// update existing DWARF info(for the linked binary).
-  void setUpdate(bool Update) { Options.Update = Update; }
+  /// Update index tables only(do not modify rest of DWARF).
+  void setUpdateIndexTablesOnly(bool Update) { Options.Update = Update; }
+
+  /// Allow generating valid, but non-deterministic output.
+  void setAllowNonDeterministicOutput(bool) { /* Nothing to do. */
+  }
 
   /// Set whether to keep the enclosing function for a static variable.
   void setKeepFunctionForStatic(bool KeepFunctionForStatic) {
     Options.KeepFunctionForStatic = KeepFunctionForStatic;
   }
 
   /// Use specified number of threads for parallel files linking.
   void setNumThreads(unsigned NumThreads) { Options.Threads = NumThreads; }
 
   /// Add kind of accelerator tables to be generated.
-  void addAccelTableKind(DwarfLinkerAccelTableKind Kind) {
+  void addAccelTableKind(AccelTableKind Kind) {
     assert(std::find(Options.AccelTables.begin(), Options.AccelTables.end(),
                      Kind) == Options.AccelTables.end());
     Options.AccelTables.emplace_back(Kind);
   }
 
   /// Set prepend path for clang modules.
   void setPrependPath(const std::string &Ppath) { Options.PrependPath = Ppath; }
 
-  /// Set translator which would be used for strings.
-  void
-  setStringsTranslator(std::function<StringRef(StringRef)> StringsTranslator) {
-    this->StringsTranslator = StringsTranslator;
-  }
-
   /// Set estimated objects files amount, for preliminary data allocation.
   void setEstimatedObjfilesAmount(unsigned ObjFilesNum) {
     ObjectContexts.reserve(ObjFilesNum);
   }
 
-  /// Set warning handler which would be used to report warnings.
-  void setWarningHandler(messageHandler Handler) {
-    Options.WarningHandler = Handler;
-  }
-
-  /// Set error handler which would be used to report errors.
-  void setErrorHandler(messageHandler Handler) {
-    Options.ErrorHandler = Handler;
-  }
-
   /// Set verification handler which would be used to report verification
   /// errors.
   void setInputVerificationHandler(inputVerificationHandler Handler) {
     Options.InputVerificationHandler = Handler;
   }
 
   /// Set map for Swift interfaces.
   void setSwiftInterfacesMap(swiftInterfacesMap *Map) {
     Options.ParseableSwiftInterfaces = Map;
   }
 
   /// Set prefix map for objects.
   void setObjectPrefixMap(objectPrefixMap *Map) {
     Options.ObjectPrefixMap = Map;
   }
 
   /// Set target DWARF version.
   Error setTargetDWARFVersion(uint16_t TargetDWARFVersion) {
-    if (TargetDWARFVersion < 1 || TargetDWARFVersion > 5)
+    if ((TargetDWARFVersion < 1) || (TargetDWARFVersion > 5))
       return createStringError(std::errc::invalid_argument,
                                "unsupported DWARF version: %d",
                                TargetDWARFVersion);
 
     Options.TargetDWARFVersion = TargetDWARFVersion;
     return Error::success();
   }
 
private:
   /// Verify the given DWARF file.
   void verifyInput(const DWARFFile &File);
 
   /// returns true if we need to translate strings.
   bool needToTranslateStrings() { return StringsTranslator != nullptr; }
 
   void reportWarning(const Twine &Warning, const DWARFFile &File,
                      const DWARFDie *DIE = nullptr) const {
-    if (Options.WarningHandler != nullptr)
-      Options.WarningHandler(Warning, File.FileName, DIE);
+    if (WarningHandler != nullptr)
+      WarningHandler(Warning, File.FileName, DIE);
   }
 
   void reportError(const Twine &Warning, const DWARFFile &File,
                    const DWARFDie *DIE = nullptr) const {
-    if (Options.ErrorHandler != nullptr)
-      Options.ErrorHandler(Warning, File.FileName, DIE);
+    if (ErrorHandler != nullptr)
+      ErrorHandler(Warning, File.FileName, DIE);
   }
 
   /// Emit warnings as Dwarf compile units to leave a trail after linking.
   bool emitPaperTrailWarnings(const DWARFFile &File,
                               OffsetsStringPool &StringPool);
 
   void copyInvariantDebugSection(DWARFContext &Dwarf);
 
private:
 
   /// DIEBlock objects that need to be destructed (but not freed!).
   std::vector<DIEBlock *> DIEBlocks;
 
   /// Allocator used for all the DIEValue objects.
   BumpPtrAllocator DIEAlloc;
   /// @}
 
-  DwarfEmitter *TheDwarfEmitter;
+  std::unique_ptr<DwarfStreamer> TheDwarfEmitter;
   std::vector<LinkContext> ObjectContexts;
 
   /// The CIEs that have been emitted in the output section. The actual CIE
   /// data serves a the key to this StringMap, this takes care of comparing the
   /// semantics of CIEs defined in different object files.
   StringMap<uint32_t> EmittedCIEs;
 
   /// Offset of the last CIE that has been emitted in the output
private:
 
   DwarfLinkerClient DwarfLinkerClientID;
 
   std::function<StringRef(StringRef)> StringsTranslator = nullptr;
 
   /// A unique ID that identifies each compile unit.
   unsigned UniqueUnitID = 0;
 
+  // error handler
+  messageHandler ErrorHandler = nullptr;
+
+  // warning handler
+  messageHandler WarningHandler = nullptr;
+
   /// linking options
   struct DWARFLinkerOptions {
     /// DWARF version for the output.
     uint16_t TargetDWARFVersion = 0;
 
     /// Generate processing log to the standard output.
     bool Verbose = false;
 
     /// Print statistics.
     bool Statistics = false;
 
     /// Verify the input DWARF.
     bool VerifyInputDWARF = false;
 
-    /// Skip emitting output
-    bool NoOutput = false;
-
     /// Do not unique types according to ODR
     bool NoODR = false;
 
     /// Update
     bool Update = false;
 
     /// Whether we want a static variable to force us to keep its enclosing
     /// function.
     bool KeepFunctionForStatic = false;
 
     /// Number of threads.
     unsigned Threads = 1;
 
     /// The accelerator table kinds
-    SmallVector<DwarfLinkerAccelTableKind, 1> AccelTables;
+    SmallVector<AccelTableKind, 1> AccelTables;
 
     /// Prepend path for the clang modules.
     std::string PrependPath;
 
-    // warning handler
-    messageHandler WarningHandler = nullptr;
-
-    // error handler
-    messageHandler ErrorHandler = nullptr;
-
     // input verification handler
     inputVerificationHandler InputVerificationHandler = nullptr;
 
     /// A list of all .swiftinterface files referenced by the debug
     /// info, mapping Module name to path on disk. The entries need to
     /// be uniqued and sorted and there are only few entries expected
     /// per compile unit, which is why this is a std::map.
     /// this is dsymutil specific fag.

llvm/include/llvm/DWARFLinker/DWARFStreamer.h

 #include "llvm/MC/MCObjectFileInfo.h"
 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/Target/TargetMachine.h"
 
 namespace llvm {
 template <typename DataT> class AccelTable;
 
-enum class OutputFileType {
-  Object,
-  Assembly,
-};
-
 ///   User of DwarfStreamer should call initialization code
 ///   for AsmPrinter:
 ///
 ///   InitializeAllTargetInfos();
 ///   InitializeAllTargetMCs();
 ///   InitializeAllTargets();
 ///   InitializeAllAsmPrinters();
 
 class MCCodeEmitter;
 class DWARFDebugMacro;
 
 /// The Dwarf streaming logic.
 ///
 /// All interactions with the MC layer that is used to build the debug
 /// information binary representation are handled in this class.
 class DwarfStreamer : public DwarfEmitter {
 public:
-  DwarfStreamer(OutputFileType OutFileType, raw_pwrite_stream &OutFile,
+  DwarfStreamer(DWARFLinker::OutputFileType OutFileType,
+                raw_pwrite_stream &OutFile,
                 std::function<StringRef(StringRef Input)> Translator,
-                messageHandler Error, messageHandler Warning)
+                DWARFLinker::messageHandler Warning)
       : OutFile(OutFile), OutFileType(OutFileType), Translator(Translator),
-        ErrorHandler(Error), WarningHandler(Warning) {}
+        WarningHandler(Warning) {}
 
-  bool init(Triple TheTriple, StringRef Swift5ReflectionSegmentName);
+  Error init(Triple TheTriple, StringRef Swift5ReflectionSegmentName);
 
   /// Dump the file to the disk.
-  void finish();
+  void finish() override;
 
-  AsmPrinter &getAsmPrinter() const { return *Asm; }
+  AsmPrinter &getAsmPrinter() const override { return *Asm; }
 
   /// Set the current output section to debug_info and change
   /// the MC Dwarf version to \p DwarfVersion.
   void switchToDebugInfoSection(unsigned DwarfVersion);
 
   /// Emit the compilation unit header for \p Unit in the
   /// debug_info section.
   ///
public:
 
   /// Emit the string table described by \p Pool into .debug_str table.
   void emitStrings(const NonRelocatableStringpool &Pool) override;
 
   /// Emit the string table described by \p Pool into .debug_line_str table.
   void emitLineStrings(const NonRelocatableStringpool &Pool) override;
 
   /// Emit the swift_ast section stored in \p Buffer.
-  void emitSwiftAST(StringRef Buffer);
+  void emitSwiftAST(StringRef Buffer) override;
 
   /// Emit the swift reflection section stored in \p Buffer.
   void emitSwiftReflectionSection(
       llvm::binaryformat::Swift5ReflectionSectionKind ReflSectionKind,
-      StringRef Buffer, uint32_t Alignment, uint32_t Size);
+      StringRef Buffer, uint32_t Alignment, uint32_t Size) override;
 
   /// Emit debug ranges(.debug_ranges, .debug_rnglists) header.
   MCSymbol *emitDwarfDebugRangeListHeader(const CompileUnit &Unit) override;
 
   /// Emit debug ranges(.debug_ranges, .debug_rnglists) fragment.
   void emitDwarfDebugRangeListFragment(const CompileUnit &Unit,
                                        const AddressRanges &LinkedRanges,
                                        PatchLocation Patch) override;
uint64_t getLocListsSectionSize() const override {
     return LocListsSectionSize;
   }
 
   void emitMacroTables(DWARFContext *Context,
                        const Offset2UnitMap &UnitMacroMap,
                        OffsetsStringPool &StringPool) override;
 
 private:
-  inline void error(const Twine &Error, StringRef Context = "") {
-    if (ErrorHandler)
-      ErrorHandler(Error, Context, nullptr);
-  }
-
   inline void warn(const Twine &Warning, StringRef Context = "") {
     if (WarningHandler)
       WarningHandler(Warning, Context, nullptr);
   }
 
   void emitMacroTableImpl(const DWARFDebugMacro *MacroTable,
                           const Offset2UnitMap &UnitMacroMap,
                           OffsetsStringPool &StringPool, uint64_t &OutOffset);
private:
   MCCodeEmitter *MCE; // Owned by MCStreamer
   MCStreamer *MS;     // Owned by AsmPrinter
   std::unique_ptr<TargetMachine> TM;
   std::unique_ptr<AsmPrinter> Asm;
   /// @}
 
   /// The output file we stream the linked Dwarf to.
   raw_pwrite_stream &OutFile;
-  OutputFileType OutFileType = OutputFileType::Object;
+  DWARFLinker::OutputFileType OutFileType = DWARFLinker::OutputFileType::Object;
   std::function<StringRef(StringRef Input)> Translator;
 
   uint64_t RangesSectionSize = 0;
   uint64_t RngListsSectionSize = 0;
   uint64_t LocSectionSize = 0;
   uint64_t LocListsSectionSize = 0;
   uint64_t LineSectionSize = 0;
   uint64_t FrameSectionSize = 0;
private:
   std::vector<EmittedUnit> EmittedUnits;
 
   /// Emit the pubnames or pubtypes section contribution for \p
   /// Unit into \p Sec. The data is provided in \p Names.
   void emitPubSectionForUnit(MCSection *Sec, StringRef Name,
                              const CompileUnit &Unit,
                              const std::vector<CompileUnit::AccelInfo> &Names);
 
-  messageHandler ErrorHandler = nullptr;
-  messageHandler WarningHandler = nullptr;
+  DWARFLinker::messageHandler WarningHandler = nullptr;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_DWARFLINKER_DWARFSTREAMER_H

llvm/include/llvm/DWARFLinkerParallel/DWARFFile.h

+//===- DWARFFile.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_DWARFLINKERPARALLEL_DWARFFILE_H
+#define LLVM_DWARFLINKERPARALLEL_DWARFFILE_H
+
+#include "llvm/ADT/StringRef.h"
+#include "llvm/DWARFLinkerParallel/AddressesMap.h"
+#include "llvm/DebugInfo/DWARF/DWARFContext.h"
+#include "llvm/Support/Endian.h"
+#include <functional>
+#include <memory>
+
+namespace llvm {
+namespace dwarflinker_parallel {
+
+/// this class represents DWARF information for source file
+/// and it`s address map.
+///
+/// May be used asynchroniously for reading.
+class DWARFFile {
+public:
+  using UnloadCallbackTy = std::function<void(StringRef FileName)>;
+
+  DWARFFile(StringRef Name, std::unique_ptr<DWARFContext> Dwarf,
+            std::unique_ptr<AddressesMap> Addresses,
+            const std::vector<std::string> &Warnings,
+            UnloadCallbackTy UnloadFunc = nullptr)
+      : FileName(Name), Dwarf(std::move(Dwarf)),
+        Addresses(std::move(Addresses)), Warnings(Warnings),
+        UnloadFunc(UnloadFunc) {
+    if (this->Dwarf)
+      Endianess = this->Dwarf->isLittleEndian() ? support::endianness::little
+                                                : support::endianness::big;
+  }
+
+  /// Object file name.
+  StringRef FileName;
+
+  /// Source DWARF information.
+  std::unique_ptr<DWARFContext> Dwarf;
+
+  /// Helpful address information(list of valid address ranges, relocations).
+  std::unique_ptr<AddressesMap> Addresses;
+
+  /// Warnings for object file.
+  const std::vector<std::string> &Warnings;
+
+  /// Endiannes of source DWARF information.
+  support::endianness Endianess = support::endianness::little;
+
+  /// Callback to the module keeping object file to unload.
+  UnloadCallbackTy UnloadFunc;
+
+  /// Unloads object file and corresponding AddressesMap and Dwarf Context.
+  void unload() {
+    Addresses.reset();
+    Dwarf.reset();
+
+    if (UnloadFunc)
+      UnloadFunc(FileName);
+  }
+};
+
+} // end namespace dwarflinker_parallel
+} // end namespace llvm
+
+#endif // LLVM_DWARFLINKERPARALLEL_DWARFFILE_H

llvm/include/llvm/DWARFLinkerParallel/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_DWARFLINKERPARALLEL_DWARFLINKER_H
 #define LLVM_DWARFLINKERPARALLEL_DWARFLINKER_H
 
-#include "llvm/DWARFLinkerParallel/AddressesMap.h"
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/CodeGen/AsmPrinter.h"
+#include "llvm/DWARFLinkerParallel/DWARFFile.h"
+#include "llvm/DebugInfo/DWARF/DWARFContext.h"
+#include "llvm/DebugInfo/DWARF/DWARFDie.h"
+#include "llvm/MC/MCDwarf.h"
+#include "llvm/TargetParser/Triple.h"
+
+/// ------------------------------------------------------------------
+/// The core of the Dwarf linking logic.
+///
+/// The generation 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 resolves to the corresponding
+/// code section(and thus have entries in the Addresses map). All the debug
+/// information that will be generated(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
+/// points to code section(the low_pc for a function, the location for
+/// a variable). These relocations are gathered as a very first step
+/// when we start processing a object file by AddressesMap.
+///
+/// The overall linking process looks like this:
+///
+/// parrallel_for_each(ObjectFile) {
+///   for_each (Compile Unit) {
+///     1. load Clang modules.
+///   }
+///
+///   parrallel_for_each(Compile Unit) {
+///     1. load input DWARF for Compile Unit.
+///     2. report warnings for Clang modules.
+///     3. analyze live DIEs and type names(if ODR deduplication is requested).
+///     4. clone DIEs(Generate output DIEs and resulting DWARF tables).
+///        The result is in OutDebugInfoBytes, which is ELF file containg
+///        DWARF tables corresponding for current compile unit.
+///     5. cleanup Input and Output DIEs.
+///   }
+///
+///   deallocate loaded Object file.
+/// }
+///
+/// if (ODR deduplication is requested)
+///   generate artificial compilation unit "Type Table"(It uses partially
+///   generated dies at clone stage).
+///
+/// for_each (ObjectFile) {
+///   for_each (Compile Unit) {
+///     1. set offsets to Compile Units DWARF tables.
+///     2. sort offsets/attributes/patches to have a predictable result.
+///     3. patch size/offsets fields.
+///     4. generate index tables.
+///     5. move DWARF tables of compile units into the resulting file.
+///   }
+/// }
+///
+/// i.e. every compile unit is processed separately, visited only once
+/// (except case inter-CU references exist), and used data are freed
+/// after the compile unit is processed. The resulting file is glued
+/// from generated debug tables, corresponding to separate compile units.
+///
+/// Handling inter-CU references: inter-CU references are hard to process
+/// using only one pass. f.e. if CU1 references CU100 and CU100 references
+/// CU1, we could not finish handling of CU1 until we finished CU100.
+/// Thus we either need to load all CUs into the memory, either load CUs several
+/// times. This implementation loads inter-connected CU into memory at the first
+/// pass and processes them at the second pass.
+///
+/// ODR deduplication: Artificial compilation unit will be constructed to keep
+/// type dies. All types are moved into that compilation unit. Type's references
+/// are patched so that they point to the corresponding types from artificial
+/// compilation unit. All partial type definitions would be merged into single
+/// type definition.
+///
 
 namespace llvm {
-namespace dwarflinker_parallel {} // end namespace dwarflinker_parallel
+namespace dwarflinker_parallel {
+
+/// ExtraDwarfEmitter allows to add extra data to the DWARFLinker output.
+/// The finish() method should be called after all extra data are emitted.
+class ExtraDwarfEmitter {
+public:
+  virtual ~ExtraDwarfEmitter() = default;
+
+  /// Dump the file to the disk.
+  virtual void finish() = 0;
+
+  /// Emit section named SecName with data SecData.
+  virtual void emitSectionContents(StringRef SecData, StringRef SecName) = 0;
+
+  /// Emit temporarily symbol named \p SymName inside section \p SecName.
+  virtual MCSymbol *emitTempSym(StringRef SecName, StringRef SymName) = 0;
+
+  /// Emit the swift_ast section stored in \p Buffer.
+  virtual void emitSwiftAST(StringRef Buffer) = 0;
+
+  /// Emit the swift reflection section stored in \p Buffer.
+  virtual void emitSwiftReflectionSection(
+      llvm::binaryformat::Swift5ReflectionSectionKind ReflSectionKind,
+      StringRef Buffer, uint32_t Alignment, uint32_t Size) = 0;
+
+  /// Returns underlying AsmPrinter.
+  virtual AsmPrinter &getAsmPrinter() const = 0;
+};
+
+class DWARFLinker {
+public:
+  /// Type of output file.
+  enum class OutputFileType {
+    Object,
+    Assembly,
+  };
+
+  /// The kind of accelerator tables we should emit.
+  enum class AccelTableKind : uint8_t {
+    Apple,     ///< .apple_names, .apple_namespaces, .apple_types, .apple_objc.
+    Pub,       ///< .debug_pubnames, .debug_pubtypes
+    DebugNames ///< .debug_names.
+  };
+
+  using MessageHandlerTy = std::function<void(
+      const Twine &Warning, StringRef Context, const DWARFDie *DIE)>;
+  using ObjFileLoaderTy = std::function<ErrorOr<DWARFFile &>(
+      StringRef ContainerName, StringRef Path)>;
+  using InputVerificationHandlerTy = std::function<void(const DWARFFile &File)>;
+  using ObjectPrefixMapTy = std::map<std::string, std::string>;
+  using CompileUnitHandlerTy = function_ref<void(const DWARFUnit &Unit)>;
+  using TranslatorFuncTy = std::function<StringRef(StringRef)>;
+  using SwiftInterfacesMapTy = std::map<std::string, std::string>;
+
+  virtual ~DWARFLinker() = default;
+
+  /// Creates dwarf linker instance.
+  static std::unique_ptr<DWARFLinker>
+  createLinker(MessageHandlerTy ErrorHandler, MessageHandlerTy WarningHandler,
+               TranslatorFuncTy StringsTranslator = nullptr);
+
+  /// Creates emitter for output dwarf.
+  virtual Error createEmitter(const Triple &TheTriple, OutputFileType FileType,
+                              raw_pwrite_stream &OutFile) = 0;
+
+  /// Returns previously created dwarf emitter. May be nullptr.
+  virtual ExtraDwarfEmitter *getEmitter() = 0;
+
+  /// Add object file to be linked. Pre-load compile unit die. Call
+  /// \p OnCUDieLoaded for each compile unit die. If specified \p File
+  /// has reference to the Clang module then such module would be
+  /// pre-loaded by \p Loader for !Update case.
+  ///
+  /// \pre NoODR, Update options should be set before call to addObjectFile.
+  virtual void addObjectFile(
+      DWARFFile &File, ObjFileLoaderTy Loader = nullptr,
+      CompileUnitHandlerTy OnCUDieLoaded = [](const DWARFUnit &) {}) = 0;
+
+  /// Link debug info for added files.
+  virtual Error link() = 0;
+
+  /// \defgroup Methods setting various linking options:
+  ///
+  /// @{
+
+  /// Allows to generate log of linking process to the standard output.
+  virtual void setVerbosity(bool Verbose) = 0;
+
+  /// Print statistics to standard output.
+  virtual void setStatistics(bool Statistics) = 0;
+
+  /// Verify the input DWARF.
+  virtual void setVerifyInputDWARF(bool Verify) = 0;
+
+  /// Do not unique types according to ODR.
+  virtual void setNoODR(bool NoODR) = 0;
+
+  /// Update index tables only(do not modify rest of DWARF).
+  virtual void setUpdateIndexTablesOnly(bool UpdateIndexTablesOnly) = 0;
+
+  /// Allow generating valid, but non-deterministic output.
+  virtual void
+  setAllowNonDeterministicOutput(bool AllowNonDeterministicOutput) = 0;
+
+  /// Set to keep the enclosing function for a static variable.
+  virtual void setKeepFunctionForStatic(bool KeepFunctionForStatic) = 0;
+
+  /// Use specified number of threads for parallel files linking.
+  virtual void setNumThreads(unsigned NumThreads) = 0;
+
+  /// Add kind of accelerator tables to be generated.
+  virtual void addAccelTableKind(AccelTableKind Kind) = 0;
+
+  /// Set prepend path for clang modules.
+  virtual void setPrependPath(const std::string &Ppath) = 0;
+
+  /// Set estimated objects files amount, for preliminary data allocation.
+  virtual void setEstimatedObjfilesAmount(unsigned ObjFilesNum) = 0;
+
+  /// Set verification handler which would be used to report verification
+  /// errors.
+  virtual void
+  setInputVerificationHandler(InputVerificationHandlerTy Handler) = 0;
+
+  /// Set map for Swift interfaces.
+  virtual void setSwiftInterfacesMap(SwiftInterfacesMapTy *Map) = 0;
+
+  /// Set prefix map for objects.
+  virtual void setObjectPrefixMap(ObjectPrefixMapTy *Map) = 0;
+
+  /// Set target DWARF version.
+  virtual Error setTargetDWARFVersion(uint16_t TargetDWARFVersion) = 0;
+  /// @}
+};
+
+} // end namespace dwarflinker_parallel
 } // end namespace llvm
 
 #endif // LLVM_DWARFLINKERPARALLEL_DWARFLINKER_H

llvm/include/llvm/DWARFLinkerParallel/StringTable.h

public:
 
   /// Enumerate all strings in sequential order and call \p Handler for each
   /// string.
   void forEach(function_ref<void(DwarfStringPoolEntryRef)> Handler) const {
     for (const StringEntry *Entry : StringEntriesForEmission)
       Handler(*Entry);
   }
 
+  std::function<StringRef(StringRef)> getTranslator() {
+    return StringsTranslator;
+  }
+
 protected:
   /// List of strings for emission.
   StringsVector StringEntriesForEmission;
 
   /// String pool for the translated strings.
   StringPool &Strings;
 
   /// Translator for the strings.
   std::function<StringRef(StringRef)> StringsTranslator;
 };
 
 } // end of namespace dwarflinker_parallel
 } // end namespace llvm
 
 #endif // LLVM_DWARFLINKERPARALLEL_STRINGTABLE_H

llvm/include/llvm/DebugInfo/DWARF/DWARFUnit.h

 class DWARFDebugAbbrev;
 class DWARFUnit;
 class DWARFDebugRangeList;
 class DWARFLocationTable;
 class DWARFObject;
 class raw_ostream;
 struct DIDumpOptions;
 struct DWARFSection;
+namespace dwarflinker_parallel {
+class CompileUnit;
+}
 
 /// Base class describing the header of any kind of "unit."  Some information
 /// is specific to certain unit types.  We separate this class out so we can
 /// parse the header before deciding what specific kind of unit to construct.
 class DWARFUnitHeader {
   // Offset within section.
   uint64_t Offset = 0;
   // Version, address size, and DWARF format.
class DWARFUnit {
   DenseSet<uint64_t> RootsParsedForVariables;
 
   using die_iterator_range =
       iterator_range<std::vector<DWARFDebugInfoEntry>::iterator>;
 
   std::shared_ptr<DWARFUnit> DWO;
 
 protected:
+  friend dwarflinker_parallel::CompileUnit;
+
   /// Return the index of a \p Die entry inside the unit's DIE vector.
   ///
   /// It is illegal to call this method with a DIE that hasn't be
   /// created by this unit. In other word, it's illegal to call this
   /// method on a DIE that isn't accessible by following
   /// children/sibling links starting from this unit's getUnitDIE().
   uint32_t getDIEIndex(const DWARFDebugInfoEntry *Die) const {
     auto First = DieArray.data();

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"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/BitVector.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/CodeGen/NonRelocatableStringpool.h"
 #include "llvm/DWARFLinker/DWARFLinkerDeclContext.h"
+#include "llvm/DWARFLinker/DWARFStreamer.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/DWARFDebugMacro.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugRangeList.h"
 #include "llvm/DebugInfo/DWARF/DWARFDie.h"
 #include "llvm/DebugInfo/DWARF/DWARFExpression.h"
void DWARFLinker::DIECloner::rememberUnitForMacroOffset(CompileUnit &Unit) {
   if (std::optional<uint64_t> MacroAttr =
           dwarf::toSectionOffset(OrigUnitDie.find(dwarf::DW_AT_macro_info))) {
     UnitMacroMap.insert(std::make_pair(*MacroAttr, &Unit));
     return;
   }
 }
 
 void DWARFLinker::DIECloner::generateLineTableForUnit(CompileUnit &Unit) {
-  if (LLVM_UNLIKELY(Linker.Options.NoOutput))
+  if (LLVM_UNLIKELY(Emitter == nullptr))
     return;
 
   // Check whether DW_AT_stmt_list attribute is presented.
   DWARFDie CUDie = Unit.getOrigUnit().getUnitDIE();
   auto StmtList = dwarf::toSectionOffset(CUDie.find(dwarf::DW_AT_stmt_list));
   if (!StmtList)
     return;
 
if (const DWARFDebugLine::LineTable *LT =
 
     Emitter->emitLineTableForUnit(LineTable, Unit, DebugStrPool,
                                   DebugLineStrPool);
   } else
     Linker.reportWarning("Cann't load line table.", ObjFile);
 }
 
 void DWARFLinker::emitAcceleratorEntriesForUnit(CompileUnit &Unit) {
-  for (DwarfLinkerAccelTableKind AccelTableKind : Options.AccelTables) {
+  for (AccelTableKind AccelTableKind : Options.AccelTables) {
     switch (AccelTableKind) {
-    case DwarfLinkerAccelTableKind::Apple: {
+    case AccelTableKind::Apple: {
       // Add namespaces.
       for (const auto &Namespace : Unit.getNamespaces())
         AppleNamespaces.addName(Namespace.Name, Namespace.Die->getOffset() +
                                                     Unit.getStartOffset());
       // Add names.
       for (const auto &Pubname : Unit.getPubnames())
         AppleNames.addName(Pubname.Name,
                            Pubname.Die->getOffset() + Unit.getStartOffset());
       // Add types.
       for (const auto &Pubtype : Unit.getPubtypes())
         AppleTypes.addName(
             Pubtype.Name, Pubtype.Die->getOffset() + Unit.getStartOffset(),
             Pubtype.Die->getTag(),
             Pubtype.ObjcClassImplementation ? dwarf::DW_FLAG_type_implementation
                                             : 0,
             Pubtype.QualifiedNameHash);
       // Add ObjC names.
       for (const auto &ObjC : Unit.getObjC())
         AppleObjc.addName(ObjC.Name,
                           ObjC.Die->getOffset() + Unit.getStartOffset());
     } break;
-    case DwarfLinkerAccelTableKind::Pub: {
+    case AccelTableKind::Pub: {
       TheDwarfEmitter->emitPubNamesForUnit(Unit);
       TheDwarfEmitter->emitPubTypesForUnit(Unit);
     } break;
-    case DwarfLinkerAccelTableKind::DebugNames: {
+    case AccelTableKind::DebugNames: {
       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(),
if (Unit)
     Context.ModuleUnits.emplace_back(RefModuleUnit{*ErrOrObj, std::move(Unit)});
 
   return Error::success();
 }
 
 uint64_t DWARFLinker::DIECloner::cloneAllCompileUnits(
     DWARFContext &DwarfContext, const DWARFFile &File, bool IsLittleEndian) {
   uint64_t OutputDebugInfoSize =
-      Linker.Options.NoOutput ? 0 : Emitter->getDebugInfoSectionSize();
+      (Emitter == nullptr) ? 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(DwarfVersion);
       continue;
     }
     if (CurrentUnit->getInfo(0).Keep) {
       // Clone the InputDIE into your Unit DIE in our compile unit since it
       // already has a DIE inside of it.
       CurrentUnit->createOutputDIE();
       rememberUnitForMacroOffset(*CurrentUnit);
       cloneDIE(InputDIE, File, *CurrentUnit, 0 /* PC offset */, UnitHeaderSize,
                0, IsLittleEndian, CurrentUnit->getOutputUnitDIE());
     }
 
     OutputDebugInfoSize = CurrentUnit->computeNextUnitOffset(DwarfVersion);
 
-    if (!Linker.Options.NoOutput) {
-      assert(Emitter);
+    if (Emitter != nullptr) {
 
       generateLineTableForUnit(*CurrentUnit);
 
       Linker.emitAcceleratorEntriesForUnit(*CurrentUnit);
 
       if (LLVM_UNLIKELY(Linker.Options.Update))
         continue;
 
if (Emitter != nullptr) {
                                         OrigUnit.getFormParams().Format),
                         File, *CurrentUnit, OutBytes, RelocAdjustment,
                         IsLittleEndian);
       };
       Linker.generateUnitLocations(*CurrentUnit, File, ProcessExpr);
     }
   }
 
-  if (!Linker.Options.NoOutput) {
+  if (Emitter != nullptr) {
     assert(Emitter);
     // Emit macro tables.
-    Emitter->emitMacroTables(File.Dwarf, UnitMacroMap, DebugStrPool);
+    Emitter->emitMacroTables(File.Dwarf.get(), UnitMacroMap, DebugStrPool);
 
     // Emit all the compile unit's debug information.
     for (auto &CurrentUnit : CompileUnits) {
       CurrentUnit->fixupForwardReferences();
 
       if (!CurrentUnit->getOutputUnitDIE())
         continue;
 
for (const std::unique_ptr<DWARFUnit> &CU :
       if (!LLVM_UNLIKELY(Options.Update))
         registerModuleReference(CUDie, ObjectContexts.back(), Loader,
                                 OnCUDieLoaded);
     }
   }
 }
 
 Error DWARFLinker::link() {
-  assert(Options.NoOutput || TheDwarfEmitter);
   assert((Options.TargetDWARFVersion != 0) &&
          "TargetDWARFVersion should be set");
 
   // First populate the data structure we need for each iteration of the
   // parallel loop.
   unsigned NumObjects = ObjectContexts.size();
 
   // This Dwarf string pool which is used for emission. It must be used
Error DWARFLinker::link() {
   }
 
   // At this point we know how much data we have emitted. We use this value to
   // compare canonical DIE offsets in analyzeContextInfo to see if a definition
   // is already emitted, without being affected by canonical die offsets set
   // later. This prevents undeterminism when analyze and clone execute
   // concurrently, as clone set the canonical DIE offset and analyze reads it.
   const uint64_t ModulesEndOffset =
-      Options.NoOutput ? 0 : TheDwarfEmitter->getDebugInfoSectionSize();
+      (TheDwarfEmitter == nullptr) ? 0
+                                   : TheDwarfEmitter->getDebugInfoSectionSize();
 
   // These variables manage the list of processed object files.
   // The mutex and condition variable are to ensure that this is thread safe.
   std::mutex ProcessedFilesMutex;
   std::condition_variable ProcessedFilesConditionVariable;
   BitVector ProcessedFiles(NumObjects, false);
 
   //  Analyzing the context info is particularly expensive so it is executed in
#endif
     // 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.
     if (OptContext.File.Addresses->hasValidRelocs() ||
         LLVM_UNLIKELY(Options.Update)) {
       SizeByObject[OptContext.File.FileName].Input =
           getDebugInfoSize(*OptContext.File.Dwarf);
       SizeByObject[OptContext.File.FileName].Output =
-          DIECloner(*this, TheDwarfEmitter, OptContext.File, DIEAlloc,
+          DIECloner(*this, TheDwarfEmitter.get(), OptContext.File, DIEAlloc,
                     OptContext.CompileUnits, Options.Update, DebugStrPool,
                     DebugLineStrPool)
               .cloneAllCompileUnits(*OptContext.File.Dwarf, OptContext.File,
                                     OptContext.File.Dwarf->isLittleEndian());
     }
-    if (!Options.NoOutput && !OptContext.CompileUnits.empty() &&
+    if ((TheDwarfEmitter != nullptr) && !OptContext.CompileUnits.empty() &&
         LLVM_LIKELY(!Options.Update))
       patchFrameInfoForObject(
           OptContext.File, OptContext.File.Addresses->getValidAddressRanges(),
           *OptContext.File.Dwarf,
           OptContext.CompileUnits[0]->getOrigUnit().getAddressByteSize());
 
     // Clean-up before starting working on the next object.
     cleanupAuxiliarryData(OptContext);
   };
 
   auto EmitLambda = [&]() {
     // Emit everything that's global.
-    if (!Options.NoOutput) {
+    if (TheDwarfEmitter != nullptr) {
       TheDwarfEmitter->emitAbbrevs(Abbreviations, Options.TargetDWARFVersion);
       TheDwarfEmitter->emitStrings(DebugStrPool);
       TheDwarfEmitter->emitLineStrings(DebugLineStrPool);
-      for (DwarfLinkerAccelTableKind TableKind : Options.AccelTables) {
+      for (AccelTableKind TableKind : Options.AccelTables) {
         switch (TableKind) {
-        case DwarfLinkerAccelTableKind::Apple:
+        case AccelTableKind::Apple:
           TheDwarfEmitter->emitAppleNamespaces(AppleNamespaces);
           TheDwarfEmitter->emitAppleNames(AppleNames);
           TheDwarfEmitter->emitAppleTypes(AppleTypes);
           TheDwarfEmitter->emitAppleObjc(AppleObjc);
           break;
-        case DwarfLinkerAccelTableKind::Pub:
+        case AccelTableKind::Pub:
           // Already emitted by emitAcceleratorEntriesForUnit.
           // Already emitted by emitAcceleratorEntriesForUnit.
           break;
-        case DwarfLinkerAccelTableKind::DebugNames:
+        case AccelTableKind::DebugNames:
           TheDwarfEmitter->emitDebugNames(DebugNames);
           break;
         }
       }
     }
   };
 
   auto AnalyzeAll = [&]() {
analyzeContextInfo(Unit.Unit->getOrigUnit().getUnitDIE(), 0, *(Unit.Unit),
                      });
   // Keep everything.
   Unit.Unit->markEverythingAsKept();
 
   // Clone unit.
   UnitListTy CompileUnits;
   CompileUnits.emplace_back(std::move(Unit.Unit));
   assert(TheDwarfEmitter);
-  DIECloner(*this, TheDwarfEmitter, Unit.File, DIEAlloc, CompileUnits,
+  DIECloner(*this, TheDwarfEmitter.get(), Unit.File, DIEAlloc, CompileUnits,
             Options.Update, DebugStrPool, DebugLineStrPool)
       .cloneAllCompileUnits(*Unit.File.Dwarf, Unit.File,
                             Unit.File.Dwarf->isLittleEndian());
   return Error::success();
 }
 
 void DWARFLinker::verifyInput(const DWARFFile &File) {
   assert(File.Dwarf);
 
   raw_ostream &os = Options.Verbose ? errs() : nulls();
   DIDumpOptions DumpOpts;
   if (!File.Dwarf->verify(os, DumpOpts.noImplicitRecursion())) {
     if (Options.InputVerificationHandler)
       Options.InputVerificationHandler(File);
   }
 }
 
+Error DWARFLinker::createEmitter(const Triple &TheTriple,
+                                 OutputFileType FileType,
+                                 raw_pwrite_stream &OutFile) {
+
+  TheDwarfEmitter = std::make_unique<DwarfStreamer>(
+      FileType, OutFile, StringsTranslator, WarningHandler);
+
+  return TheDwarfEmitter->init(TheTriple, "__DWARF");
+}
+
+DwarfEmitter *DWARFLinker::getEmitter() { return TheDwarfEmitter.get(); }
+
 } // namespace llvm

llvm/lib/DWARFLinker/DWARFStreamer.cpp

 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Target/TargetOptions.h"
 #include "llvm/TargetParser/Triple.h"
 
 namespace llvm {
 
-bool DwarfStreamer::init(Triple TheTriple,
+Error DwarfStreamer::init(Triple TheTriple,
                           StringRef Swift5ReflectionSegmentName) {
   std::string ErrorStr;
   std::string TripleName;
-  StringRef Context = "dwarf streamer init";
 
   // Get the target.
   const Target *TheTarget =
       TargetRegistry::lookupTarget(TripleName, TheTriple, ErrorStr);
   if (!TheTarget)
-    return error(ErrorStr, Context), false;
+    return createStringError(std::errc::invalid_argument, ErrorStr.c_str());
+
   TripleName = TheTriple.getTriple();
 
   // Create all the MC Objects.
   MRI.reset(TheTarget->createMCRegInfo(TripleName));
   if (!MRI)
-    return error(Twine("no register info for target ") + TripleName, Context),
-           false;
+    return createStringError(std::errc::invalid_argument,
+                             "no register info for target %s",
+                             TripleName.c_str());
 
   MCTargetOptions MCOptions = mc::InitMCTargetOptionsFromFlags();
   MAI.reset(TheTarget->createMCAsmInfo(*MRI, TripleName, MCOptions));
   if (!MAI)
-    return error("no asm info for target " + TripleName, Context), false;
+    return createStringError(std::errc::invalid_argument,
+                             "no asm info for target %s", TripleName.c_str());
 
   MSTI.reset(TheTarget->createMCSubtargetInfo(TripleName, "", ""));
   if (!MSTI)
-    return error("no subtarget info for target " + TripleName, Context), false;
+    return createStringError(std::errc::invalid_argument,
+                             "no subtarget info for target %s",
+                             TripleName.c_str());
 
   MC.reset(new MCContext(TheTriple, MAI.get(), MRI.get(), MSTI.get(), nullptr,
                          nullptr, true, Swift5ReflectionSegmentName));
   MOFI.reset(TheTarget->createMCObjectFileInfo(*MC, /*PIC=*/false, false));
   MC->setObjectFileInfo(MOFI.get());
 
   MAB = TheTarget->createMCAsmBackend(*MSTI, *MRI, MCOptions);
   if (!MAB)
-    return error("no asm backend for target " + TripleName, Context), false;
+    return createStringError(std::errc::invalid_argument,
+                             "no asm backend for target %s",
+                             TripleName.c_str());
 
   MII.reset(TheTarget->createMCInstrInfo());
   if (!MII)
-    return error("no instr info info for target " + TripleName, Context), false;
+    return createStringError(std::errc::invalid_argument,
+                             "no instr info info for target %s",
+                             TripleName.c_str());
 
   MCE = TheTarget->createMCCodeEmitter(*MII, *MC);
   if (!MCE)
-    return error("no code emitter for target " + TripleName, Context), false;
+    return createStringError(std::errc::invalid_argument,
+                             "no code emitter for target %s",
+                             TripleName.c_str());
 
   switch (OutFileType) {
-  case OutputFileType::Assembly: {
+  case DWARFLinker::OutputFileType::Assembly: {
     MIP = TheTarget->createMCInstPrinter(TheTriple, MAI->getAssemblerDialect(),
                                          *MAI, *MII, *MRI);
     MS = TheTarget->createAsmStreamer(
         *MC, std::make_unique<formatted_raw_ostream>(OutFile), true, true, MIP,
         std::unique_ptr<MCCodeEmitter>(MCE), std::unique_ptr<MCAsmBackend>(MAB),
         true);
     break;
   }
-  case OutputFileType::Object: {
+  case DWARFLinker::OutputFileType::Object: {
     MS = TheTarget->createMCObjectStreamer(
         TheTriple, *MC, std::unique_ptr<MCAsmBackend>(MAB),
         MAB->createObjectWriter(OutFile), std::unique_ptr<MCCodeEmitter>(MCE),
         *MSTI, MCOptions.MCRelaxAll, MCOptions.MCIncrementalLinkerCompatible,
         /*DWARFMustBeAtTheEnd*/ false);
     break;
   }
   }
 
   if (!MS)
-    return error("no object streamer for target " + TripleName, Context), false;
+    return createStringError(std::errc::invalid_argument,
+                             "no object streamer for target %s",
+                             TripleName.c_str());
 
   // Finally create the AsmPrinter we'll use to emit the DIEs.
   TM.reset(TheTarget->createTargetMachine(TripleName, "", "", TargetOptions(),
                                           std::nullopt));
   if (!TM)
-    return error("no target machine for target " + TripleName, Context), false;
+    return createStringError(std::errc::invalid_argument,
+                             "no target machine for target %s",
+                             TripleName.c_str());
 
   Asm.reset(TheTarget->createAsmPrinter(*TM, std::unique_ptr<MCStreamer>(MS)));
   if (!Asm)
-    return error("no asm printer for target " + TripleName, Context), false;
+    return createStringError(std::errc::invalid_argument,
+                             "no asm printer for target %s",
+                             TripleName.c_str());
   Asm->setDwarfUsesRelocationsAcrossSections(false);
 
   RangesSectionSize = 0;
   RngListsSectionSize = 0;
   LocSectionSize = 0;
   LocListsSectionSize = 0;
   LineSectionSize = 0;
   FrameSectionSize = 0;
   DebugInfoSectionSize = 0;
   MacInfoSectionSize = 0;
   MacroSectionSize = 0;
 
-  return true;
+  return Error::success();
 }
 
 void DwarfStreamer::finish() { MS->finish(); }
 
 void DwarfStreamer::switchToDebugInfoSection(unsigned DwarfVersion) {
   MS->switchSection(MOFI->getDwarfInfoSection());
   MC->setDwarfVersion(DwarfVersion);
 }

llvm/lib/DWARFLinkerParallel/CMakeLists.txt

 add_llvm_component_library(LLVMDWARFLinkerParallel
   DWARFLinker.cpp
   StringPool.cpp
+  DWARFEmitterImpl.cpp
+  DWARFLinkerImpl.cpp
+  TableOffsets.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/DWARFLinkerParallel
 
   DEPENDS
   intrinsics_gen
 
   LINK_COMPONENTS
   AsmPrinter
   BinaryFormat
   CodeGen
   DebugInfoDWARF
   MC
   Object
   Support
   )

llvm/lib/DWARFLinkerParallel/DWARFEmitterImpl.h

+//===- DwarfEmitterImpl.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_DWARFLINKERPARALLEL_DWARFEMITTERIMPL_H
+#define LLVM_DWARFLINKERPARALLEL_DWARFEMITTERIMPL_H
+
+#include "DWARFLinkerCompileUnit.h"
+#include "llvm/BinaryFormat/Swift.h"
+#include "llvm/CodeGen/AccelTable.h"
+#include "llvm/CodeGen/AsmPrinter.h"
+#include "llvm/DWARFLinkerParallel/DWARFLinker.h"
+#include "llvm/DWARFLinkerParallel/StringTable.h"
+#include "llvm/MC/MCAsmInfo.h"
+#include "llvm/MC/MCContext.h"
+#include "llvm/MC/MCInstrInfo.h"
+#include "llvm/MC/MCObjectFileInfo.h"
+#include "llvm/MC/MCRegisterInfo.h"
+#include "llvm/MC/MCStreamer.h"
+#include "llvm/MC/MCSubtargetInfo.h"
+#include "llvm/Target/TargetMachine.h"
+
+namespace llvm {
+
+///   User of DwarfEmitterImpl should call initialization code
+///   for AsmPrinter:
+///
+///   InitializeAllTargetInfos();
+///   InitializeAllTargetMCs();
+///   InitializeAllTargets();
+///   InitializeAllAsmPrinters();
+
+template <typename DataT> class AccelTable;
+class MCCodeEmitter;
+class DWARFDebugMacro;
+
+namespace dwarflinker_parallel {
+
+struct UnitStartSymbol {
+  unsigned UnitID = 0;
+  MCSymbol *Symbol = 0;
+};
+using UnitStartSymbolsTy = SmallVector<UnitStartSymbol>;
+using Offset2UnitMapTy = DenseMap<uint64_t, CompileUnit *>;
+
+struct RangeAttrPatch;
+struct LocAttrPatch;
+
+/// The Dwarf emission logic.
+///
+/// All interactions with the MC layer that is used to build the debug
+/// information binary representation are handled in this class.
+class DwarfEmitterImpl : public ExtraDwarfEmitter {
+public:
+  DwarfEmitterImpl(DWARFLinker::OutputFileType OutFileType,
+                   raw_pwrite_stream &OutFile,
+                   std::function<StringRef(StringRef Input)> Translator,
+                   DWARFLinker::MessageHandlerTy Warning)
+      : OutFile(OutFile), OutFileType(OutFileType), Translator(Translator),
+        WarningHandler(Warning) {}
+
+  Error init(Triple TheTriple, StringRef Swift5ReflectionSegmentName);
+
+  /// Dump the file to the disk.
+  void finish() override { MS->finish(); }
+
+  AsmPrinter &getAsmPrinter() const override { return *Asm; }
+
+  /// Set the current output section to debug_info and change
+  /// the MC Dwarf version to \p DwarfVersion.
+  void switchToDebugInfoSection(unsigned DwarfVersion) {}
+
+  /// Emit the swift_ast section stored in \p Buffer.
+  void emitSwiftAST(StringRef Buffer) override {}
+
+  /// Emit the swift reflection section stored in \p Buffer.
+  void emitSwiftReflectionSection(
+      llvm::binaryformat::Swift5ReflectionSectionKind ReflSectionKind,
+      StringRef Buffer, uint32_t Alignment, uint32_t Size) override {}
+
+  void emitPaperTrailWarningsDie(DIE &Die) {}
+
+  void emitSectionContents(StringRef SecData, StringRef SecName) override {}
+
+  MCSymbol *emitTempSym(StringRef SecName, StringRef SymName) override {
+    return nullptr;
+  }
+
+  void emitAbbrevs(const SmallVector<std::unique_ptr<DIEAbbrev>> &Abbrevs,
+                   unsigned DwarfVersion) {}
+
+  void emitStrings(const StringTable &Strings) {}
+
+  void emitLineStrings(const StringTable &Strings) {}
+
+  void emitDebugNames(AccelTable<DWARF5AccelTableStaticData> &,
+                      UnitStartSymbolsTy &UnitOffsets) {}
+
+  void emitAppleNamespaces(AccelTable<AppleAccelTableStaticOffsetData> &) {}
+
+  void emitAppleNames(AccelTable<AppleAccelTableStaticOffsetData> &) {}
+
+  void emitAppleObjc(AccelTable<AppleAccelTableStaticOffsetData> &) {}
+
+  void emitAppleTypes(AccelTable<AppleAccelTableStaticTypeData> &) {}
+
+  MCSymbol *emitDwarfDebugRangeListHeader(const CompileUnit &Unit) {
+    return nullptr;
+  }
+
+  void emitDwarfDebugRangeListFragment(const CompileUnit &Unit,
+                                       const AddressRanges &LinkedRanges,
+                                       RangeAttrPatch &Patch) {}
+
+  void emitDwarfDebugRangeListFooter(const CompileUnit &Unit,
+                                     MCSymbol *EndLabel) {}
+
+  MCSymbol *emitDwarfDebugLocListHeader(const CompileUnit &Unit) {
+    return nullptr;
+  }
+
+  void emitDwarfDebugLocListFragment(
+      const CompileUnit &Unit,
+      const DWARFLocationExpressionsVector &LinkedLocationExpression,
+      LocAttrPatch &Patch) {}
+
+  void emitDwarfDebugLocListFooter(const CompileUnit &Unit,
+                                   MCSymbol *EndLabel) {}
+
+  void emitDwarfDebugArangesTable(const CompileUnit &Unit,
+                                  const AddressRanges &LinkedRanges) {}
+
+  void translateLineTable(DataExtractor LineData, uint64_t Offset) {}
+
+  void emitLineTableForUnit(MCDwarfLineTableParams Params,
+                            StringRef PrologueBytes, unsigned MinInstLength,
+                            std::vector<DWARFDebugLine::Row> &Rows,
+                            unsigned AdddressSize) {}
+
+  void emitLineTableForUnit(const DWARFDebugLine::LineTable &LineTable,
+                            const CompileUnit &Unit, const StringTable &Strings,
+                            const StringTable &LineTableStrings) {}
+
+  void emitPubNamesForUnit(const CompileUnit &Unit) {}
+
+  void emitPubTypesForUnit(const CompileUnit &Unit) {}
+
+  void emitCIE(StringRef CIEBytes) {}
+
+  void emitFDE(uint32_t CIEOffset, uint32_t AddreSize, uint64_t Address,
+               StringRef Bytes) {}
+
+  void emitCompileUnitHeader(CompileUnit &Unit, unsigned DwarfVersion) {}
+
+  void emitDIE(DIE &Die) {}
+
+  void emitMacroTables(DWARFContext *Context,
+                       const Offset2UnitMapTy &UnitMacroMap,
+                       StringTable &Strings) {}
+
+  /// Returns size of generated .debug_line section.
+  uint64_t getDebugLineSectionSize() const { return LineSectionSize; }
+
+  /// Returns size of generated .debug_frame section.
+  uint64_t getDebugFrameSectionSize() const { return FrameSectionSize; }
+
+  /// Returns size of generated .debug_ranges section.
+  uint64_t getDebugRangesSectionSize() const { return RangesSectionSize; }
+
+  /// Returns size of generated .debug_rnglists section.
+  uint64_t getDebugRngListsSectionSize() const { return RngListsSectionSize; }
+
+  /// Returns size of generated .debug_info section.
+  uint64_t getDebugInfoSectionSize() const { return DebugInfoSectionSize; }
+
+  /// Returns size of generated .debug_macinfo section.
+  uint64_t getDebugMacInfoSectionSize() const { return MacInfoSectionSize; }
+
+  /// Returns size of generated .debug_macro section.
+  uint64_t getDebugMacroSectionSize() const { return MacroSectionSize; }
+
+  /// Returns size of generated .debug_loc section.
+  uint64_t getDebugLocSectionSize() const { return LocSectionSize; }
+
+  /// Returns size of generated .debug_loclists section.
+  uint64_t getDebugLocListsSectionSize() const { return LocListsSectionSize; }
+
+private:
+  inline void warn(const Twine &Warning, StringRef Context = "") {
+    if (WarningHandler)
+      WarningHandler(Warning, Context, nullptr);
+  }
+
+  void emitMacroTableImpl(const DWARFDebugMacro *MacroTable,
+                          const Offset2UnitMapTy &UnitMacroMap,
+                          StringPool &StringPool, uint64_t &OutOffset) {}
+
+  /// Emit piece of .debug_ranges for \p LinkedRanges.
+  void emitDwarfDebugRangesTableFragment(const CompileUnit &Unit,
+                                         const AddressRanges &LinkedRanges,
+                                         RangeAttrPatch &Patch) {}
+
+  /// Emit piece of .debug_rnglists for \p LinkedRanges.
+  void emitDwarfDebugRngListsTableFragment(const CompileUnit &Unit,
+                                           const AddressRanges &LinkedRanges,
+                                           RangeAttrPatch &Patch) {}
+
+  /// Emit piece of .debug_loc for \p LinkedRanges.
+  void emitDwarfDebugLocTableFragment(
+      const CompileUnit &Unit,
+      const DWARFLocationExpressionsVector &LinkedLocationExpression,
+      LocAttrPatch &Patch) {}
+
+  /// Emit piece of .debug_loclists for \p LinkedRanges.
+  void emitDwarfDebugLocListsTableFragment(
+      const CompileUnit &Unit,
+      const DWARFLocationExpressionsVector &LinkedLocationExpression,
+      LocAttrPatch &Patch) {}
+
+  /// \defgroup MCObjects MC layer objects constructed by the streamer
+  /// @{
+  std::unique_ptr<MCRegisterInfo> MRI;
+  std::unique_ptr<MCAsmInfo> MAI;
+  std::unique_ptr<MCObjectFileInfo> MOFI;
+  std::unique_ptr<MCContext> MC;
+  MCAsmBackend *MAB; // Owned by MCStreamer
+  std::unique_ptr<MCInstrInfo> MII;
+  std::unique_ptr<MCSubtargetInfo> MSTI;
+  MCInstPrinter *MIP; // Owned by AsmPrinter
+  MCCodeEmitter *MCE; // Owned by MCStreamer
+  MCStreamer *MS;     // Owned by AsmPrinter
+  std::unique_ptr<TargetMachine> TM;
+  std::unique_ptr<AsmPrinter> Asm;
+  /// @}
+
+  /// The output file we stream the linked Dwarf to.
+  raw_pwrite_stream &OutFile;
+  DWARFLinker::OutputFileType OutFileType = DWARFLinker::OutputFileType::Object;
+  std::function<StringRef(StringRef Input)> Translator;
+
+  uint64_t RangesSectionSize = 0;
+  uint64_t RngListsSectionSize = 0;
+  uint64_t LocSectionSize = 0;
+  uint64_t LocListsSectionSize = 0;
+  uint64_t LineSectionSize = 0;
+  uint64_t FrameSectionSize = 0;
+  uint64_t DebugInfoSectionSize = 0;
+  uint64_t MacInfoSectionSize = 0;
+  uint64_t MacroSectionSize = 0;
+
+  /// Keep track of emitted CUs and their Unique ID.
+  struct EmittedUnit {
+    unsigned ID;
+    MCSymbol *LabelBegin;
+  };
+  std::vector<EmittedUnit> EmittedUnitsTy;
+
+  /// Emit the pubnames or pubtypes section contribution for \p
+  /// Unit into \p Sec. The data is provided in \p Names.
+  void emitPubSectionForUnit(MCSection *Sec, StringRef Name,
+                             const CompileUnit &Unit,
+                             const std::vector<CompileUnit::AccelInfo> &Names);
+
+  DWARFLinker::MessageHandlerTy WarningHandler = nullptr;
+};
+
+} // end namespace dwarflinker_parallel
+} // end namespace llvm
+
+#endif // LLVM_DWARFLINKERPARALLEL_DWARFEMITTERIMPL_H

llvm/lib/DWARFLinkerParallel/DWARFEmitterImpl.cpp

+//===- DWARFEmitterImpl.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 "DWARFEmitterImpl.h"
+#include "llvm/DWARFLinker/DWARFLinkerCompileUnit.h"
+#include "llvm/MC/MCAsmBackend.h"
+#include "llvm/MC/MCCodeEmitter.h"
+#include "llvm/MC/MCObjectWriter.h"
+#include "llvm/MC/MCSubtargetInfo.h"
+#include "llvm/MC/MCTargetOptions.h"
+#include "llvm/MC/MCTargetOptionsCommandFlags.h"
+#include "llvm/MC/TargetRegistry.h"
+#include "llvm/Support/FormattedStream.h"
+
+namespace llvm {
+namespace dwarflinker_parallel {
+
+Error DwarfEmitterImpl::init(Triple TheTriple,
+                             StringRef Swift5ReflectionSegmentName) {
+  std::string ErrorStr;
+  std::string TripleName;
+
+  // Get the target.
+  const Target *TheTarget =
+      TargetRegistry::lookupTarget(TripleName, TheTriple, ErrorStr);
+  if (!TheTarget)
+    return createStringError(std::errc::invalid_argument, ErrorStr.c_str());
+  TripleName = TheTriple.getTriple();
+
+  // Create all the MC Objects.
+  MRI.reset(TheTarget->createMCRegInfo(TripleName));
+  if (!MRI)
+    return createStringError(std::errc::invalid_argument,
+                             "no register info for target %s",
+                             TripleName.c_str());
+
+  MCTargetOptions MCOptions = mc::InitMCTargetOptionsFromFlags();
+  MAI.reset(TheTarget->createMCAsmInfo(*MRI, TripleName, MCOptions));
+  if (!MAI)
+    return createStringError(std::errc::invalid_argument,
+                             "no asm info for target %s", TripleName.c_str());
+
+  MSTI.reset(TheTarget->createMCSubtargetInfo(TripleName, "", ""));
+  if (!MSTI)
+    return createStringError(std::errc::invalid_argument,
+                             "no subtarget info for target %s",
+                             TripleName.c_str());
+
+  MC.reset(new MCContext(TheTriple, MAI.get(), MRI.get(), MSTI.get(), nullptr,
+                         nullptr, true, Swift5ReflectionSegmentName));
+  MOFI.reset(TheTarget->createMCObjectFileInfo(*MC, /*PIC=*/false, false));
+  MC->setObjectFileInfo(MOFI.get());
+
+  MAB = TheTarget->createMCAsmBackend(*MSTI, *MRI, MCOptions);
+  if (!MAB)
+    return createStringError(std::errc::invalid_argument,
+                             "no asm backend for target %s",
+                             TripleName.c_str());
+
+  MII.reset(TheTarget->createMCInstrInfo());
+  if (!MII)
+    return createStringError(std::errc::invalid_argument,
+                             "no instr info info for target %s",
+                             TripleName.c_str());
+
+  MCE = TheTarget->createMCCodeEmitter(*MII, *MC);
+  if (!MCE)
+    return createStringError(std::errc::invalid_argument,
+                             "no code emitter for target %s",
+                             TripleName.c_str());
+
+  switch (OutFileType) {
+  case DWARFLinker::OutputFileType::Assembly: {
+    MIP = TheTarget->createMCInstPrinter(TheTriple, MAI->getAssemblerDialect(),
+                                         *MAI, *MII, *MRI);
+    MS = TheTarget->createAsmStreamer(
+        *MC, std::make_unique<formatted_raw_ostream>(OutFile), true, true, MIP,
+        std::unique_ptr<MCCodeEmitter>(MCE), std::unique_ptr<MCAsmBackend>(MAB),
+        true);
+    break;
+  }
+  case DWARFLinker::OutputFileType::Object: {
+    MS = TheTarget->createMCObjectStreamer(
+        TheTriple, *MC, std::unique_ptr<MCAsmBackend>(MAB),
+        MAB->createObjectWriter(OutFile), std::unique_ptr<MCCodeEmitter>(MCE),
+        *MSTI, MCOptions.MCRelaxAll, MCOptions.MCIncrementalLinkerCompatible,
+        /*DWARFMustBeAtTheEnd*/ false);
+    break;
+  }
+  }
+
+  if (!MS)
+    return createStringError(std::errc::invalid_argument,
+                             "no object streamer for target %s",
+                             TripleName.c_str());
+
+  // Finally create the AsmPrinter we'll use to emit the DIEs.
+  TM.reset(TheTarget->createTargetMachine(TripleName, "", "", TargetOptions(),
+                                          std::nullopt));
+  if (!TM)
+    return createStringError(std::errc::invalid_argument,
+                             "no target machine for target %s",
+                             TripleName.c_str());
+
+  Asm.reset(TheTarget->createAsmPrinter(*TM, std::unique_ptr<MCStreamer>(MS)));
+  if (!Asm)
+    return createStringError(std::errc::invalid_argument,
+                             "no asm printer for target %s",
+                             TripleName.c_str());
+  Asm->setDwarfUsesRelocationsAcrossSections(false);
+
+  RangesSectionSize = 0;
+  RngListsSectionSize = 0;
+  LocSectionSize = 0;
+  LocListsSectionSize = 0;
+  LineSectionSize = 0;
+  FrameSectionSize = 0;
+  DebugInfoSectionSize = 0;
+  MacInfoSectionSize = 0;
+  MacroSectionSize = 0;
+
+  return Error::success();
+}
+
+} // end of namespace dwarflinker_parallel
+} // namespace llvm

llvm/lib/DWARFLinkerParallel/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/DWARFLinkerParallel/DWARFLinker.h"
+#include "DWARFLinkerImpl.h"
 
-namespace llvm {
-namespace dwarflinker_parallel {} // end of namespace dwarflinker_parallel
-} // namespace llvm
+std::unique_ptr<llvm::dwarflinker_parallel::DWARFLinker>
+llvm::dwarflinker_parallel::DWARFLinker::createLinker(
+    MessageHandlerTy ErrorHandler, MessageHandlerTy WarningHandler,
+    TranslatorFuncTy StringsTranslator) {
+  return std::make_unique<DWARFLinkerImpl>(ErrorHandler, WarningHandler,
+                                           StringsTranslator);
+}

llvm/lib/DWARFLinkerParallel/DWARFLinkerCompileUnit.h

+//===- 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_DWARFLINKERPARALLEL_DWARFLINKERCOMPILEUNIT_H
+#define LLVM_DWARFLINKERPARALLEL_DWARFLINKERCOMPILEUNIT_H
+
+#include "DWARFLinkerUnit.h"
+#include "llvm/DWARFLinkerParallel/DWARFFile.h"
+#include "llvm/DWARFLinkerParallel/DWARFLinker.h"
+#include <optional>
+
+namespace llvm {
+namespace dwarflinker_parallel {
+
+struct LinkContext;
+class DWARFFile;
+
+/// Stores all information related to a compile unit, be it in its original
+/// instance of the object file or its brand new cloned and generated DIE tree.
+class CompileUnit : public DwarfUnit {
+public:
+  CompileUnit(LinkContext &Context, unsigned ID, StringRef ClangModuleName,
+              DWARFFile &File,
+              DWARFLinker::SwiftInterfacesMapTy *SwiftInterfaces,
+              UnitMessageHandlerTy WarningHandler)
+      : DwarfUnit(ID, ClangModuleName, WarningHandler), Context(Context),
+        ContaingFile(File), ParseableSwiftInterfaces(SwiftInterfaces) {
+    FormParams.Version = 4;
+    FormParams.Format = dwarf::DWARF32;
+    FormParams.AddrSize = 4;
+    UnitName = ContaingFile.FileName;
+  }
+
+  CompileUnit(LinkContext &Context, DWARFUnit &OrigUnit, unsigned ID,
+              StringRef ClangModuleName, DWARFFile &File,
+              UnitMessageHandlerTy WarningHandler)
+      : DwarfUnit(ID, ClangModuleName, WarningHandler), Context(Context),
+        ContaingFile(File), OrigUnit(&OrigUnit) {
+    DWARFDie CUDie = OrigUnit.getUnitDIE();
+    if (!CUDie)
+      return;
+
+    if (File.Dwarf)
+      Endianess = File.Dwarf->isLittleEndian() ? support::endianness::little
+                                               : support::endianness::big;
+
+    FormParams.Version = OrigUnit.getVersion();
+    FormParams.Format = dwarf::DWARF32;
+    FormParams.AddrSize = OrigUnit.getAddressByteSize();
+
+    Language = dwarf::toUnsigned(CUDie.find(dwarf::DW_AT_language), 0);
+
+    UnitName = ContaingFile.FileName;
+    SysRoot = dwarf::toStringRef(CUDie.find(dwarf::DW_AT_LLVM_sysroot)).str();
+  }
+
+  /// \defgroup Helper methods to access OrigUnit.
+  ///
+  /// @{
+
+  /// Returns paired compile unit from input DWARF.
+  DWARFUnit &getOrigUnit() const {
+    assert(OrigUnit != nullptr);
+    return *OrigUnit;
+  }
+
+  const DWARFDebugInfoEntry *
+  getFirstChildEntry(const DWARFDebugInfoEntry *Die) const {
+    assert(OrigUnit != nullptr);
+    return OrigUnit->getFirstChildEntry(Die);
+  }
+
+  const DWARFDebugInfoEntry *
+  getSiblingEntry(const DWARFDebugInfoEntry *Die) const {
+    assert(OrigUnit != nullptr);
+    return OrigUnit->getSiblingEntry(Die);
+  }
+
+  DWARFDie getParent(const DWARFDebugInfoEntry *Die) {
+    assert(OrigUnit != nullptr);
+    return OrigUnit->getParent(Die);
+  }
+
+  DWARFDie getDIEAtIndex(unsigned Index) {
+    assert(OrigUnit != nullptr);
+    return OrigUnit->getDIEAtIndex(Index);
+  }
+
+  const DWARFDebugInfoEntry *getDebugInfoEntry(unsigned Index) const {
+    assert(OrigUnit != nullptr);
+    return OrigUnit->getDebugInfoEntry(Index);
+  }
+
+  DWARFDie getUnitDIE(bool ExtractUnitDIEOnly = true) {
+    assert(OrigUnit != nullptr);
+    return OrigUnit->getUnitDIE(ExtractUnitDIEOnly);
+  }
+
+  DWARFDie getDIE(const DWARFDebugInfoEntry *Die) {
+    assert(OrigUnit != nullptr);
+    return DWARFDie(OrigUnit, Die);
+  }
+
+  uint32_t getDIEIndex(const DWARFDebugInfoEntry *Die) const {
+    assert(OrigUnit != nullptr);
+    return OrigUnit->getDIEIndex(Die);
+  }
+
+  uint32_t getDIEIndex(const DWARFDie &Die) const {
+    assert(OrigUnit != nullptr);
+    return OrigUnit->getDIEIndex(Die);
+  }
+
+  std::optional<DWARFFormValue> find(uint32_t DieIdx,
+                                     ArrayRef<dwarf::Attribute> Attrs) const {
+    assert(OrigUnit != nullptr);
+    return find(OrigUnit->getDebugInfoEntry(DieIdx), Attrs);
+  }
+
+  std::optional<DWARFFormValue> find(const DWARFDebugInfoEntry *Die,
+                                     ArrayRef<dwarf::Attribute> Attrs) const {
+    if (!Die)
+      return std::nullopt;
+    auto AbbrevDecl = Die->getAbbreviationDeclarationPtr();
+    if (AbbrevDecl) {
+      for (auto Attr : Attrs) {
+        if (auto Value = AbbrevDecl->getAttributeValue(Die->getOffset(), Attr,
+                                                       *OrigUnit))
+          return Value;
+      }
+    }
+    return std::nullopt;
+  }
+
+  std::optional<uint32_t> getDIEIndexForOffset(uint64_t Offset) {
+    return OrigUnit->getDIEIndexForOffset(Offset);
+  }
+
+  /// @}
+
+private:
+  /// Context containing this compilation unit.
+  LinkContext &Context;
+
+  /// DWARFFile containing this compile unit.
+  DWARFFile &ContaingFile;
+
+  /// Pointer to the paired compile unit from the input DWARF.
+  DWARFUnit *OrigUnit = nullptr;
+
+  /// Map for swift interfaces.
+  DWARFLinker::SwiftInterfacesMapTy *ParseableSwiftInterfaces = nullptr;
+};
+
+} // end of namespace dwarflinker_parallel
+} // end namespace llvm
+
+#endif // LLVM_DWARFLINKERPARALLEL_DWARFLINKERCOMPILEUNIT_H

llvm/lib/DWARFLinkerParallel/DWARFLinkerImpl.h

+//===- DWARFLinkerImpl.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_DWARFLINKERPARALLEL_DWARFLINKERIMPL_H
+#define LLVM_DWARFLINKERPARALLEL_DWARFLINKERIMPL_H
+
+#include "DWARFEmitterImpl.h"
+#include "DWARFLinkerCompileUnit.h"
+#include "llvm/ADT/AddressRanges.h"
+#include "llvm/CodeGen/AccelTable.h"
+#include "llvm/DWARFLinkerParallel/DWARFLinker.h"
+#include "llvm/DWARFLinkerParallel/StringPool.h"
+#include "llvm/DWARFLinkerParallel/StringTable.h"
+
+namespace llvm {
+namespace dwarflinker_parallel {
+
+using Offset2UnitMapTy = DenseMap<uint64_t, CompileUnit *>;
+
+struct RangeAttrPatch;
+struct LocAttrPatch;
+
+class DWARFLinkerImpl : public DWARFLinker {
+public:
+  DWARFLinkerImpl(MessageHandlerTy ErrorHandler,
+                  MessageHandlerTy WarningHandler,
+                  TranslatorFuncTy StringsTranslator)
+      : UniqueUnitID(0), ErrorHandler(ErrorHandler),
+        WarningHandler(WarningHandler),
+        OutputStrings(Strings, StringsTranslator) {}
+
+  Error createEmitter(const Triple &TheTriple, OutputFileType FileType,
+                      raw_pwrite_stream &OutFile) override;
+
+  ExtraDwarfEmitter *getEmitter() override;
+
+  /// Add object file to be linked. Pre-load compile unit die. Call
+  /// \p OnCUDieLoaded for each compile unit die. If specified \p File
+  /// has reference to the Clang module then such module would be
+  /// pre-loaded by \p Loader for !Update case.
+  ///
+  /// \pre NoODR, Update options should be set before call to addObjectFile.
+  void addObjectFile(
+      DWARFFile &File, ObjFileLoaderTy Loader = nullptr,
+      CompileUnitHandlerTy OnCUDieLoaded = [](const DWARFUnit &) {}) override {}
+
+  /// Link debug info for added files.
+  Error link() override {
+    reportWarning("LLVM parallel dwarflinker is not implemented yet.", "");
+    return Error::success();
+  }
+
+  /// \defgroup Methods setting various linking options:
+  ///
+  /// @{
+  ///
+
+  /// Allows to generate log of linking process to the standard output.
+  void setVerbosity(bool Verbose) override { Options.Verbose = Verbose; }
+
+  /// Print statistics to standard output.
+  void setStatistics(bool Statistics) override {
+    Options.Statistics = Statistics;
+  }
+
+  /// Verify the input DWARF.
+  void setVerifyInputDWARF(bool Verify) override {
+    Options.VerifyInputDWARF = Verify;
+  }
+
+  /// Do not unique types according to ODR.
+  void setNoODR(bool NoODR) override { Options.NoODR = NoODR; }
+
+  /// Update index tables only(do not modify rest of DWARF).
+  void setUpdateIndexTablesOnly(bool UpdateIndexTablesOnly) override {
+    Options.UpdateIndexTablesOnly = UpdateIndexTablesOnly;
+  }
+
+  /// Allow generating valid, but non-deterministic output.
+  void
+  setAllowNonDeterministicOutput(bool AllowNonDeterministicOutput) override {
+    Options.AllowNonDeterministicOutput = AllowNonDeterministicOutput;
+  }
+
+  /// Set to keep the enclosing function for a static variable.
+  void setKeepFunctionForStatic(bool KeepFunctionForStatic) override {
+    Options.KeepFunctionForStatic = KeepFunctionForStatic;
+  }
+
+  /// Use specified number of threads for parallel files linking.
+  void setNumThreads(unsigned NumThreads) override {
+    Options.Threads = NumThreads;
+  }
+
+  /// Add kind of accelerator tables to be generated.
+  void addAccelTableKind(AccelTableKind Kind) override {
+    assert(std::find(Options.AccelTables.begin(), Options.AccelTables.end(),
+                     Kind) == Options.AccelTables.end());
+    Options.AccelTables.emplace_back(Kind);
+  }
+
+  /// Set prepend path for clang modules.
+  void setPrependPath(const std::string &Ppath) override {
+    Options.PrependPath = Ppath;
+  }
+
+  /// Set estimated objects files amount, for preliminary data allocation.
+  void setEstimatedObjfilesAmount(unsigned ObjFilesNum) override {
+    ObjectContexts.reserve(ObjFilesNum);
+  }
+
+  /// Set verification handler which would be used to report verification
+  /// errors.
+  void
+  setInputVerificationHandler(InputVerificationHandlerTy Handler) override {
+    Options.InputVerificationHandler = Handler;
+  }
+
+  /// Set map for Swift interfaces.
+  void setSwiftInterfacesMap(SwiftInterfacesMapTy *Map) override {
+    Options.ParseableSwiftInterfaces = Map;
+  }
+
+  /// Set prefix map for objects.
+  void setObjectPrefixMap(ObjectPrefixMapTy *Map) override {
+    Options.ObjectPrefixMap = Map;
+  }
+
+  /// Set target DWARF version.
+  Error setTargetDWARFVersion(uint16_t TargetDWARFVersion) override {
+    if ((TargetDWARFVersion < 1) || (TargetDWARFVersion > 5))
+      return createStringError(std::errc::invalid_argument,
+                               "unsupported DWARF version: %d",
+                               TargetDWARFVersion);
+
+    Options.TargetDWARFVersion = TargetDWARFVersion;
+    return Error::success();
+  }
+  /// @}
+
+protected:
+  /// Reports Warning.
+  void reportWarning(const Twine &Warning, const DWARFFile &File,
+                     const DWARFDie *DIE = nullptr) const {
+    if (WarningHandler != nullptr)
+      WarningHandler(Warning, File.FileName, DIE);
+  }
+
+  /// Reports Warning.
+  void reportWarning(const Twine &Warning, StringRef FileName,
+                     const DWARFDie *DIE = nullptr) const {
+    if (WarningHandler != nullptr)
+      WarningHandler(Warning, FileName, DIE);
+  }
+
+  /// Reports Error.
+  void reportError(const Twine &Warning, StringRef FileName,
+                   const DWARFDie *DIE = nullptr) const {
+    if (ErrorHandler != nullptr)
+      ErrorHandler(Warning, FileName, DIE);
+  }
+
+  /// Returns next available unique Compile Unit ID.
+  unsigned getNextUniqueUnitID() { return UniqueUnitID.fetch_add(1); }
+
+  /// Keeps track of data associated with one object during linking.
+  /// i.e. source file descriptor, compilation units, output data
+  /// for compilation units common tables.
+  struct LinkContext : public TableOffsets {
+    using UnitListTy = SmallVector<std::unique_ptr<CompileUnit>>;
+
+    /// Keep information for referenced clang module: already loaded DWARF info
+    /// of the clang module and a CompileUnit of the module.
+    struct RefModuleUnit {
+      RefModuleUnit(DWARFFile &File, std::unique_ptr<CompileUnit> Unit)
+          : File(File), Unit(std::move(Unit)) {}
+      RefModuleUnit(RefModuleUnit &&Other)
+          : File(Other.File), Unit(std::move(Other.Unit)) {}
+      RefModuleUnit(const RefModuleUnit &) = delete;
+
+      DWARFFile &File;
+      std::unique_ptr<CompileUnit> Unit;
+    };
+    using ModuleUnitListTy = SmallVector<RefModuleUnit>;
+
+    /// Object file descriptor.
+    DWARFFile &File;
+
+    /// Set of Compilation Units(may be accessed asynchroniously for reading).
+    UnitListTy CompileUnits;
+
+    /// Set of Compile Units for modules.
+    ModuleUnitListTy ModulesCompileUnits;
+
+    /// Size of Debug info before optimizing.
+    uint64_t OriginalDebugInfoSize = 0;
+
+    /// Output sections, common for all compilation units.
+    OutTablesFileTy OutDebugInfoBytes;
+
+    /// Endianness for the final file.
+    support::endianness Endianess = support::endianness::little;
+
+    LinkContext(DWARFFile &File) : File(File) {
+      if (File.Dwarf) {
+        if (!File.Dwarf->compile_units().empty())
+          CompileUnits.reserve(File.Dwarf->getNumCompileUnits());
+
+        Endianess = File.Dwarf->isLittleEndian() ? support::endianness::little
+                                                 : support::endianness::big;
+      }
+    }
+
+    /// Add Compile Unit corresponding to the module.
+    void addModulesCompileUnit(RefModuleUnit &&Unit) {
+      ModulesCompileUnits.emplace_back(std::move(Unit));
+    }
+
+    /// Return Endiannes of the source DWARF information.
+    support::endianness getEndianness() { return Endianess; }
+
+    /// Link context might contain debug tables which are common for the whole
+    /// object files(invariant tables, .debug_frame). This method returns start
+    /// offset inside final DWARF file for such tables.
+    uint64_t getStartOffset(CompileUnit::DebugTableKind TableKind) const {
+      return TableOffsets[static_cast<typename std::underlying_type<
+          CompileUnit::DebugTableKind>::type>(TableKind)];
+    }
+
+    /// Set start offset for debug tables common for the whole object file.
+    void setStartOffset(CompileUnit::DebugTableKind TableKind,
+                        uint64_t Offset) {
+      TableOffsets[static_cast<typename std::underlying_type<
+          CompileUnit::DebugTableKind>::type>(TableKind)] = Offset;
+    }
+
+    /// \returns pointer to compilation unit which corresponds \p Offset.
+    CompileUnit *getUnitForOffset(CompileUnit &CU, uint64_t Offset) const;
+  };
+
+  /// linking options
+  struct DWARFLinkerOptions {
+    /// DWARF version for the output.
+    uint16_t TargetDWARFVersion = 0;
+
+    /// Generate processing log to the standard output.
+    bool Verbose = false;
+
+    /// Print statistics.
+    bool Statistics = false;
+
+    /// Verify the input DWARF.
+    bool VerifyInputDWARF = false;
+
+    /// Do not unique types according to ODR
+    bool NoODR = false;
+
+    /// Update index tables.
+    bool UpdateIndexTablesOnly = false;
+
+    /// Whether we want a static variable to force us to keep its enclosing
+    /// function.
+    bool KeepFunctionForStatic = false;
+
+    /// Allow to generate valid, but non deterministic output.
+    bool AllowNonDeterministicOutput = false;
+
+    /// Number of threads.
+    unsigned Threads = 1;
+
+    /// The accelerator table kinds
+    SmallVector<AccelTableKind, 1> AccelTables;
+
+    /// Prepend path for the clang modules.
+    std::string PrependPath;
+
+    /// input verification handler(it might be called asynchronously).
+    InputVerificationHandlerTy InputVerificationHandler = nullptr;
+
+    /// A list of all .swiftinterface files referenced by the debug
+    /// info, mapping Module name to path on disk. The entries need to
+    /// be uniqued and sorted and there are only few entries expected
+    /// per compile unit, which is why this is a std::map.
+    /// this is dsymutil specific fag.
+    ///
+    /// (it might be called asynchronously).
+    SwiftInterfacesMapTy *ParseableSwiftInterfaces = nullptr;
+
+    /// A list of remappings to apply to file paths.
+    ///
+    /// (it might be called asynchronously).
+    ObjectPrefixMapTy *ObjectPrefixMap = nullptr;
+  } Options;
+
+  /// \defgroup Data members accessed asinchroniously.
+  ///
+  /// @{
+
+  /// Unique ID for compile unit.
+  std::atomic<unsigned> UniqueUnitID;
+
+  /// Strings pool. Keeps all strings.
+  StringPool Strings;
+
+  /// error handler(it might be called asynchronously).
+  MessageHandlerTy ErrorHandler = nullptr;
+
+  /// warning handler(it might be called asynchronously).
+  MessageHandlerTy WarningHandler = nullptr;
+  /// @}
+
+  /// \defgroup Data members accessed sequentially.
+  ///
+  /// @{
+
+  /// Set of strings which should be emitted.
+  StringTable OutputStrings;
+
+  /// Keeps all linking contexts.
+  SmallVector<std::unique_ptr<LinkContext>> ObjectContexts;
+
+  /// The emitter of final dwarf file.
+  std::unique_ptr<DwarfEmitterImpl> TheDwarfEmitter;
+  /// @}
+};
+
+} // end namespace dwarflinker_parallel
+} // end namespace llvm
+
+#endif // LLVM_DWARFLINKERPARALLEL_DWARFLINKERIMPL_H

llvm/lib/DWARFLinkerParallel/DWARFLinkerImpl.cpp

+//=== DWARFLinkerImpl.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 "DWARFLinkerImpl.h"
+
+namespace llvm {
+namespace dwarflinker_parallel {
+
+/// Similar to DWARFUnitSection::getUnitForOffset(), but returning our
+/// CompileUnit object instead.
+CompileUnit *
+DWARFLinkerImpl::LinkContext::getUnitForOffset(CompileUnit &CurrentCU,
+                                               uint64_t Offset) const {
+  if (CurrentCU.isClangModule())
+    return &CurrentCU;
+
+  auto CU = llvm::upper_bound(
+      CompileUnits, Offset,
+      [](uint64_t LHS, const std::unique_ptr<CompileUnit> &RHS) {
+        return LHS < RHS->getOrigUnit().getNextUnitOffset();
+      });
+
+  return CU != CompileUnits.end() ? CU->get() : nullptr;
+}
+
+Error DWARFLinkerImpl::createEmitter(const Triple &TheTriple,
+                                     OutputFileType FileType,
+                                     raw_pwrite_stream &OutFile) {
+
+  TheDwarfEmitter = std::make_unique<DwarfEmitterImpl>(
+      FileType, OutFile, OutputStrings.getTranslator(), WarningHandler);
+
+  return TheDwarfEmitter->init(TheTriple, "__DWARF");
+}
+
+ExtraDwarfEmitter *DWARFLinkerImpl::getEmitter() {
+  return TheDwarfEmitter.get();
+}
+
+} // end of namespace dwarflinker_parallel
+} // namespace llvm

llvm/lib/DWARFLinkerParallel/DWARFLinkerUnit.h

+//===- DWARFLinkerUnit.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_DWARFLINKERPARALLEL_DWARFLINKERUNIT_H
+#define LLVM_DWARFLINKERPARALLEL_DWARFLINKERUNIT_H
+
+#include "TableOffsets.h"
+#include "llvm/CodeGen/DIE.h"
+#include "llvm/DWARFLinkerParallel/StringPool.h"
+#include "llvm/DebugInfo/DWARF/DWARFUnit.h"
+#include "llvm/Support/LEB128.h"
+
+namespace llvm {
+namespace dwarflinker_parallel {
+
+using UnitMessageHandlerTy = function_ref<void(
+    const Twine &Error, StringRef Context, const DWARFDie *DIE)>;
+
+/// Each unit keeps output data as a file with debug tables
+/// corresponding to the concrete unit.
+using OutTablesFileTy = SmallString<0>;
+
+/// Base class for all Dwarf units(Compile unit/Type table unit).
+class DwarfUnit : public TableOffsets {
+public:
+  virtual ~DwarfUnit() {}
+  DwarfUnit(unsigned ID, StringRef ClangModuleName,
+            UnitMessageHandlerTy WarningHandler)
+      : ID(ID), ClangModuleName(ClangModuleName),
+        WarningHandler(WarningHandler) {
+    FormParams.Version = 4;
+    FormParams.Format = dwarf::DWARF32;
+    FormParams.AddrSize = 4;
+  }
+
+  /// Endiannes for the compile unit.
+  support::endianness getEndianness() const { return Endianess; }
+
+  /// Return DWARF version.
+  uint16_t getVersion() const { return FormParams.Version; }
+
+  /// Return size of header of debug_info table.
+  uint16_t getHeaderSize() const { return FormParams.Version >= 5 ? 12 : 11; }
+
+  /// Return size of address.
+  uint8_t getAddressByteSize() const { return FormParams.AddrSize; }
+
+  /// Return size of reference.
+  uint8_t getRefAddrByteSize() const { return FormParams.getRefAddrByteSize(); }
+
+  /// Return format of the Dwarf(DWARF32 or DWARF64).
+  /// TODO: DWARF64 is not currently supported.
+  dwarf::DwarfFormat getDwarfFormat() const { return FormParams.Format; }
+
+  /// Unique id of the unit.
+  unsigned getUniqueID() const { return ID; }
+
+  /// Return language of this unit.
+  uint16_t getLanguage() const { return Language; }
+
+  /// Set size of this(newly generated) compile unit.
+  void setUnitSize(uint64_t UnitSize) { this->UnitSize = UnitSize; }
+
+  /// Returns size of this(newly generated) compile unit.
+  uint64_t getUnitSize() const { return UnitSize; }
+
+  /// Returns this unit name.
+  StringRef getUnitName() const { return UnitName; }
+
+  /// Return the DW_AT_LLVM_sysroot of the compile unit or an empty StringRef.
+  StringRef getSysRoot() { return SysRoot; }
+
+  /// Create a Die for this unit.
+  void setOutputDIE(DIE *UnitDie) { NewUnit = UnitDie; }
+
+  /// Return Die for this compile unit.
+  DIE *getOutputUnitDIE() const { return NewUnit; }
+
+  /// Return true if this compile unit is from Clang module.
+  bool isClangModule() const { return !ClangModuleName.empty(); }
+
+  /// Return Clang module name;
+  const std::string &getClangModuleName() const { return ClangModuleName; }
+
+  /// Returns generated file keeping debug tables for this compile unit.
+  OutTablesFileTy &getOutDwarfBits() { return OutDebugInfoBits; }
+
+  /// Erases generated file keeping debug tables for this compile unit.
+  void eraseDwarfBits() { OutDebugInfoBits = OutTablesFileTy(); }
+
+  MCSymbol *getLabelBegin() { return LabelBegin; }
+  void setLabelBegin(MCSymbol *S) { LabelBegin = S; }
+
+  /// Error reporting methods.
+  /// @{
+
+  void reportWarning(const Twine &Warning,
+                     const DWARFDie *Die = nullptr) const {
+    if (WarningHandler)
+      WarningHandler(Warning, getUnitName(), Die);
+  }
+  void reportWarning(Error Warning) const {
+    handleAllErrors(std::move(Warning), [&](ErrorInfoBase &Info) {
+      if (WarningHandler)
+        WarningHandler(Info.message(), getUnitName(), nullptr);
+    });
+  }
+  /// @}
+
+  /// This structure keeps fields which would be used for creating accelerator
+  /// table.
+  struct AccelInfo {
+    AccelInfo(StringEntry *Name, const DIE *Die, bool SkipPubSection = false);
+    AccelInfo(StringEntry *Name, const DIE *Die, uint32_t QualifiedNameHash,
+              bool ObjCClassIsImplementation);
+
+    /// Name of the entry.
+    StringEntry *Name = nullptr;
+
+    /// Tag of the DIE this entry describes.
+    dwarf::Tag Tag = dwarf::DW_TAG_null;
+
+    /// Output offset of the DIE this entry describes.
+    uint64_t OutOffset = 0;
+
+    /// Hash of the fully qualified name.
+    uint32_t QualifiedNameHash = 0;
+
+    /// Emit this entry only in the apple_* sections.
+    bool SkipPubSection = false;
+
+    /// Is this an ObjC class implementation?
+    bool ObjcClassImplementation = false;
+
+    /// Cloned Die containing acceleration info.
+    const DIE *Die = nullptr;
+  };
+
+protected:
+  /// Unique ID for the unit.
+  unsigned ID = 0;
+
+  /// Properties of the unit.
+  dwarf::FormParams FormParams;
+
+  /// DIE for newly generated compile unit.
+  DIE *NewUnit = nullptr;
+
+  /// The DW_AT_language of this unit.
+  uint16_t Language = 0;
+
+  /// The name of this unit.
+  std::string UnitName;
+
+  /// The DW_AT_LLVM_sysroot of this unit.
+  std::string SysRoot;
+
+  /// If this is a Clang module, this holds the module's name.
+  std::string ClangModuleName;
+
+  uint64_t UnitSize = 0;
+
+  /// Elf file containg generated debug tables for this compile unit.
+  OutTablesFileTy OutDebugInfoBits;
+
+  /// Endiannes for this compile unit.
+  support::endianness Endianess = support::endianness::little;
+
+  MCSymbol *LabelBegin = nullptr;
+
+  /// true if current unit references_to/is_referenced by other unit.
+  std::atomic<bool> IsInterconnectedCU = {false};
+
+  UnitMessageHandlerTy WarningHandler;
+};
+
+} // end of namespace dwarflinker_parallel
+} // end namespace llvm
+
+#endif // LLVM_DWARFLINKERPARALLEL_DWARFLINKERUNIT_H

llvm/lib/DWARFLinkerParallel/TableOffsets.h

+//===- TableOffsets.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_DWARFLINKERPARALLEL_TABLEOFFSETS_H
+#define LLVM_DWARFLINKERPARALLEL_TABLEOFFSETS_H
+
+#include "llvm/ADT/StringRef.h"
+#include <array>
+#include <cstdint>
+
+namespace llvm {
+namespace dwarflinker_parallel {
+
+/// This class keeps offsets to the debug tables. Any objects which is
+/// supposed to be emitted into the debug tables should use this class to
+/// track debug tables offsets.
+class TableOffsets {
+public:
+  /// List of tracked debug tables.
+  enum class DebugTableKind : uint8_t {
+    DebugInfo = 0,
+    DebugLine,
+    DebugFrame,
+    DebugRange,
+    DebugRngLists,
+    DebugLoc,
+    DebugLocLists,
+    DebugARanges,
+    DebugAbbrev,
+    DebugMacinfo,
+    DebugMacro,
+  };
+  constexpr static size_t TableKindsNum = 11;
+
+  /// Recognise the table name and match it with the DebugTableKind.
+  static std::optional<DebugTableKind> parseDebugTableName(StringRef Name);
+
+  /// When objects(f.e. compile units) are glued into the single file,
+  /// the debug tables corresponding to the concrete object are assigned
+  /// with offsets inside the whole file. This method returns offset
+  /// to the \p TableKind debug table, corresponding to this object.
+  uint64_t getStartOffset(DebugTableKind TableKind) const {
+    return TableOffsets[static_cast<
+        typename std::underlying_type<DebugTableKind>::type>(TableKind)];
+  }
+
+  /// Set offset to the start of specified \p TableKind debug table,
+  /// corresponding to this object.
+  void setStartOffset(DebugTableKind TableKind, uint64_t Offset) {
+    TableOffsets[static_cast<
+        typename std::underlying_type<DebugTableKind>::type>(TableKind)] =
+        Offset;
+  }
+
+protected:
+  /// Offsets to the debug tables composing this object.
+  std::array<uint64_t, TableKindsNum> TableOffsets = {0};
+};
+
+} // end of namespace dwarflinker_parallel
+} // end namespace llvm
+
+#endif // LLVM_DWARFLINKERPARALLEL_TABLEOFFSETS_H

llvm/lib/DWARFLinkerParallel/TableOffsets.cpp

+//=== TableOffsets.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 "TableOffsets.h"
+#include "llvm/ADT/StringSwitch.h"
+
+namespace llvm {
+namespace dwarflinker_parallel {
+
+std::optional<TableOffsets::DebugTableKind>
+TableOffsets::parseDebugTableName(llvm::StringRef SecName) {
+  return llvm::StringSwitch<std::optional<TableOffsets::DebugTableKind>>(
+             SecName)
+      .Case("debug_info", DebugTableKind::DebugInfo)
+      .Case("debug_line", DebugTableKind::DebugLine)
+      .Case("debug_frame", DebugTableKind::DebugFrame)
+      .Case("debug_ranges", DebugTableKind::DebugRange)
+      .Case("debug_rnglists", DebugTableKind::DebugRngLists)
+      .Case("debug_loc", DebugTableKind::DebugLoc)
+      .Case("debug_loclists", DebugTableKind::DebugLocLists)
+      .Case("debug_aranges", DebugTableKind::DebugARanges)
+      .Case("debug_abbrev", DebugTableKind::DebugAbbrev)
+      .Case("debug_macinfo", DebugTableKind::DebugMacinfo)
+      .Case("debug_macro", DebugTableKind::DebugMacro)
+      .Default(std::nullopt);
+
+  return std::nullopt;
+}
+
+} // end of namespace dwarflinker_parallel
+} // end of namespace llvm

llvm/test/tools/dsymutil/X86/DWARFLinkerParallel/basic-linking-x86.test

+RUN: cat %p/../../Inputs/basic.macho.x86_64 > %t1
+RUN: dsymutil --linker llvm -accelerator=Pub -f -oso-prepend-path=%p/.. %t1 2>&1 | FileCheck %s --allow-empty
+
+#CHECK: LLVM parallel dwarflinker is not implemented yet.

llvm/test/tools/llvm-dwarfutil/ELF/X86/DWARFLinkerParallel/gc-default.test

 ## This test checks that debug info related to deleted code (marked with
 ## default tombstone value) is removed.
 
 # RUN: yaml2obj %s -o %t.o
+# RUN: llvm-dwarfutil --linker llvm %t.o %t1.out 2>&1 | FileCheck %s --allow-empty
 
-# RUN: llvm-dwarfutil %t.o - | llvm-dwarfdump -a - | FileCheck %s --check-prefixes=CHECK,CHECK-GC
-
-# RUN: llvm-dwarfutil --garbage-collection %t.o - | llvm-dwarfdump -a - | FileCheck %s --check-prefixes=CHECK,CHECK-GC
-
-# RUN: llvm-dwarfutil --no-garbage-collection --garbage-collection %t.o - | llvm-dwarfdump -a - | FileCheck %s --check-prefixes=CHECK,CHECK-GC
-
-# RUN: llvm-dwarfutil --garbage-collection --no-garbage-collection %t.o - | llvm-dwarfdump -a - | FileCheck %s --check-prefixes=CHECK,CHECK-NOGC
-
-# RUN: llvm-dwarfutil %t.o --tombstone=universal - | llvm-dwarfdump -a - | FileCheck %s --check-prefixes=CHECK,CHECK-GC
-
-# CHECK: DW_TAG_compile_unit
-# CHECK: DW_AT_name{{.*}}"CU1"
-# CHECK: DW_TAG_class_type
-# CHECK: DW_AT_name{{.*}}"class1"
-# CHECK-GC-NOT: DW_TAG_class_type
-# CHECK-GC-NOT: "class2"
-# CHECK-GC-NOT: "class3"
-# CHECK-NOGC: DW_TAG_class_type
-# CHECK-NOGC: "class2"
-# CHECK-NOGC: "class3"
-# CHECK: DW_TAG_subprogram
-# CHECK: DW_AT_name{{.*}}"foo1"
-# CHECK: DW_AT_low_pc{{.*}}0x0000000000001000
-# CHECK: DW_AT_high_pc{{.*}}0x0000000000001010
-# CHECK: DW_AT_type{{.*}}"class1"
-# CHECK-GC-NOT: DW_TAG_subprogram
-# CHECK-GC-NOT: "foo2"
-# CHECK-NOGC: DW_TAG_subprogram
-# CHECK-NOGC: "foo2"
-
+#CHECK: LLVM parallel dwarflinker is not implemented yet.
 
 --- !ELF
 FileHeader:
   Class:    ELFCLASS64
   Data:     ELFDATA2LSB
   Type:     ET_REL
   Machine:  EM_X86_64
 Sections:

llvm/test/tools/llvm-dwarfutil/ELF/X86/gc-default.test

 ## This test checks that debug info related to deleted code (marked with
 ## default tombstone value) is removed.
 
 # RUN: yaml2obj %s -o %t.o
 
 # RUN: llvm-dwarfutil %t.o - | llvm-dwarfdump -a - | FileCheck %s --check-prefixes=CHECK,CHECK-GC
 
+# RUN: llvm-dwarfutil --linker apple %t.o - | llvm-dwarfdump -a - | FileCheck %s --check-prefixes=CHECK,CHECK-GC
+
 # RUN: llvm-dwarfutil --garbage-collection %t.o - | llvm-dwarfdump -a - | FileCheck %s --check-prefixes=CHECK,CHECK-GC
 
 # RUN: llvm-dwarfutil --no-garbage-collection --garbage-collection %t.o - | llvm-dwarfdump -a - | FileCheck %s --check-prefixes=CHECK,CHECK-GC
 
 # RUN: llvm-dwarfutil --garbage-collection --no-garbage-collection %t.o - | llvm-dwarfdump -a - | FileCheck %s --check-prefixes=CHECK,CHECK-NOGC
 
 # RUN: llvm-dwarfutil %t.o --tombstone=universal - | llvm-dwarfdump -a - | FileCheck %s --check-prefixes=CHECK,CHECK-GC
 

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
   AllTargetsCodeGens
   AllTargetsDescs
   AllTargetsInfos
   AsmPrinter
   CodeGen
   CodeGenTypes
   DWARFLinker
+  DWARFLinkerParallel
   DebugInfoDWARF
   MC
   Object
   Option
   Remarks
   Support
   Target
   TargetParser

llvm/tools/dsymutil/DwarfLinkerForBinary.h

enum TraversalFlags {
     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:
 
   /// Keeps track of relocations.
-  class AddressManager : public AddressesMap {
+  template <typename AddressesMapBase>
+  class AddressManager : public AddressesMapBase {
     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)
public:
     /// \returns relocation value if relocation exist, otherwise std::nullopt.
     std::optional<int64_t>
     hasValidRelocationAt(const std::vector<ValidReloc> &Relocs,
                          uint64_t StartOffset, uint64_t EndOffset);
 
     std::optional<int64_t> getExprOpAddressRelocAdjustment(
         DWARFUnit &U, const DWARFExpression::Operation &Op,
         uint64_t StartOffset, uint64_t EndOffset) override;
+
     std::optional<int64_t>
     getSubprogramRelocAdjustment(const DWARFDie &DIE) override;
 
     bool applyValidRelocs(MutableArrayRef<char> Data, uint64_t BaseOffset,
                           bool IsLittleEndian) override;
 
     RangesTy &getValidAddressRanges() override { return AddressRanges; }
 
     void clear() override {
       AddressRanges.clear();
       ValidDebugInfoRelocs.clear();
       ValidDebugAddrRelocs.clear();
     }
   };
 
 private:
   /// \defgroup Helpers Various helper methods.
   ///
   /// @{
-  bool createStreamer(const Triple &TheTriple, raw_fd_ostream &OutFile);
+  template <typename OutStreamer>
+  bool createStreamer(const Triple &TheTriple,
+                      typename OutStreamer::OutputFileType FileType,
+                      std::unique_ptr<OutStreamer> &Streamer,
+                      raw_fd_ostream &OutFile);
 
   /// Attempt to load a debug object from disk.
   ErrorOr<const object::ObjectFile &> loadObject(const DebugMapObject &Obj,
                                                  const Triple &triple);
-  ErrorOr<DWARFFile &> loadObject(const DebugMapObject &Obj,
+
+  template <typename OutDWARFFile, typename AddressesMap>
+  ErrorOr<std::unique_ptr<OutDWARFFile>> loadObject(const DebugMapObject &Obj,
                                                     const DebugMap &DebugMap,
                                                     remarks::RemarkLinker &RL);
 
   void collectRelocationsToApplyToSwiftReflectionSections(
       const object::SectionRef &Section, StringRef &Contents,
       const llvm::object::MachOObjectFile *MO,
       const std::vector<uint64_t> &SectionToOffsetInDwarf,
       const llvm::dsymutil::DebugMapObject *Obj,
       std::vector<MachOUtils::DwarfRelocationApplicationInfo>
           &RelocationsToApply) const;
 
   Error copySwiftInterfaces(StringRef Architecture) const;
 
+  template <typename OutStreamer>
   void copySwiftReflectionMetadata(
-      const llvm::dsymutil::DebugMapObject *Obj, DwarfStreamer *Streamer,
+      const llvm::dsymutil::DebugMapObject *Obj, OutStreamer *Streamer,
       std::vector<uint64_t> &SectionToOffsetInDwarf,
       std::vector<MachOUtils::DwarfRelocationApplicationInfo>
           &RelocationsToApply);
 
+  template <typename Linker, typename OutDwarfFile, typename AddressMapBase>
+  bool linkImpl(const DebugMap &Map,
+                typename Linker::OutputFileType ObjectType);
+
   raw_fd_ostream &OutFile;
   BinaryHolder &BinHolder;
   LinkOptions Options;
   std::mutex &ErrorHandlerMutex;
 
-  std::unique_ptr<DwarfStreamer> Streamer;
-  std::vector<std::unique_ptr<DWARFFile>> ObjectsForLinking;
-  std::vector<std::unique_ptr<DWARFContext>> ContextForLinking;
-  std::vector<std::unique_ptr<AddressManager>> AddressMapForLinking;
   std::vector<std::string> EmptyWarnings;
 
   /// A list of all .swiftinterface files referenced by the debug
   /// info, mapping Module name to path on disk. The entries need to
   /// be uniqued and sorted and there are only few entries expected
   /// per compile unit, which is why this is a std::map.
   std::map<std::string, std::string> ParseableSwiftInterfaces;
 

llvm/tools/dsymutil/DwarfLinkerForBinary.cpp

 #include "llvm/BinaryFormat/MachO.h"
 #include "llvm/BinaryFormat/Swift.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/DWARFLinkerParallel/DWARFLinker.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/DWARFExpression.h"

 
 void DwarfLinkerForBinary::reportError(Twine Error, Twine Context,
                                        const DWARFDie *DIE) const {
   std::lock_guard<std::mutex> Guard(ErrorHandlerMutex);
   error(Error, Context);
   dumpDIE(DIE, Options.Verbose);
 }
 
-bool DwarfLinkerForBinary::createStreamer(const Triple &TheTriple,
-                                          raw_fd_ostream &OutFile) {
-  if (Options.NoOutput)
-    return true;
-
-  Streamer = std::make_unique<DwarfStreamer>(
-      Options.FileType, OutFile, Options.Translator,
-      [&](const Twine &Error, StringRef Context, const DWARFDie *) {
-        reportError(Error, Context);
-      },
-      [&](const Twine &Warning, StringRef Context, const DWARFDie *) {
-        reportWarning(Warning, Context);
-      });
-  return Streamer->init(TheTriple, "__DWARF");
-}
-
 ErrorOr<const object::ObjectFile &>
 DwarfLinkerForBinary::loadObject(const DebugMapObject &Obj,
                                  const Triple &Triple) {
   auto ObjectEntry =
       BinHolder.getObjectEntry(Obj.getObjectFilename(), Obj.getTimestamp());
   if (!ObjectEntry) {
     auto Err = ObjectEntry.takeError();
     reportWarning(Twine(Obj.getObjectFilename()) + ": " +
if (EC)
     return errorCodeToError(EC);
 
   if (Error E = RL.serialize(OS, Options.RemarksFormat))
     return E;
 
   return Error::success();
 }
 
-ErrorOr<DWARFFile &>
+template <typename OutDWARFFile, typename AddressesMap>
+ErrorOr<std::unique_ptr<OutDWARFFile>>
 DwarfLinkerForBinary::loadObject(const DebugMapObject &Obj,
                                  const DebugMap &DebugMap,
                                  remarks::RemarkLinker &RL) {
   auto ErrorOrObj = loadObject(Obj, DebugMap.getTriple());
+  std::unique_ptr<OutDWARFFile> Res;
 
   if (ErrorOrObj) {
-    ContextForLinking.push_back(
-        std::unique_ptr<DWARFContext>(DWARFContext::create(*ErrorOrObj)));
-    AddressMapForLinking.push_back(
-        std::make_unique<AddressManager>(*this, *ErrorOrObj, Obj));
-
-    ObjectsForLinking.push_back(std::make_unique<DWARFFile>(
-        Obj.getObjectFilename(), ContextForLinking.back().get(),
-        AddressMapForLinking.back().get(),
-        Obj.empty() ? Obj.getWarnings() : EmptyWarnings));
+    Res = std::make_unique<OutDWARFFile>(
+        Obj.getObjectFilename(), DWARFContext::create(*ErrorOrObj),
+        std::make_unique<AddressesMap>(*this, *ErrorOrObj, Obj),
+        Obj.empty() ? Obj.getWarnings() : EmptyWarnings);
 
     Error E = RL.link(*ErrorOrObj);
     if (Error NewE = handleErrors(
             std::move(E), [&](std::unique_ptr<FileError> EC) -> Error {
               return remarksErrorHandler(Obj, *this, std::move(EC));
             }))
       return errorToErrorCode(std::move(NewE));
 
-    return *ObjectsForLinking.back();
+    return Res;
   }
 
   return ErrorOrObj.getError();
 }
 
 static bool binaryHasStrippableSwiftReflectionSections(
     const DebugMap &Map, const LinkOptions &Options, BinaryHolder &BinHolder) {
   // If the input binary has strippable swift5 reflection sections, there is no
   // need to copy them to the .dSYM. Only copy them for binaries where the
   // linker omitted the reflection metadata.
   if (!Map.getBinaryPath().empty() &&
-      Options.FileType == OutputFileType::Object) {
+      Options.FileType == DWARFLinker::OutputFileType::Object) {
 
     auto ObjectEntry = BinHolder.getObjectEntry(Map.getBinaryPath());
     // If ObjectEntry or Object has an error, no binary exists, therefore no
     // reflection sections exist.
     if (!ObjectEntry) {
       // Any errors will be diagnosed later in the main loop, ignore them here.
       llvm::consumeError(ObjectEntry.takeError());
       return false;
for (auto &I : ParseableSwiftInterfaces) {
     if ((EC = sys::fs::copy_file(InterfaceFile, Path.str())))
       reportWarning(Twine("cannot copy parseable Swift interface ") +
                     InterfaceFile + ": " + toString(errorCodeToError(EC)));
     Path.resize(BaseLength);
   }
   return Error::success();
 }
 
+template <typename OutStreamer>
 void DwarfLinkerForBinary::copySwiftReflectionMetadata(
-    const llvm::dsymutil::DebugMapObject *Obj, DwarfStreamer *Streamer,
+    const llvm::dsymutil::DebugMapObject *Obj, OutStreamer *Streamer,
     std::vector<uint64_t> &SectionToOffsetInDwarf,
     std::vector<MachOUtils::DwarfRelocationApplicationInfo>
         &RelocationsToApply) {
   using binaryformat::Swift5ReflectionSectionKind;
   auto OF =
       llvm::object::ObjectFile::createObjectFile(Obj->getObjectFilename());
   if (!OF) {
     llvm::consumeError(OF.takeError());
for (auto SectionKind : SectionKindsToEmit) {
       Streamer->emitSwiftReflectionSection(SectionKind, *SectionContents,
                                            Section.getAlignment().value(),
                                            Section.getSize());
     }
   }
 }
 
 bool DwarfLinkerForBinary::link(const DebugMap &Map) {
-  if (!createStreamer(Map.getTriple(), OutFile))
-    return false;
+  if (Options.DWARFLinkerType == DsymutilDWARFLinkerType::LLVM) {
+    dwarflinker_parallel::DWARFLinker::OutputFileType DWARFLinkerOutputType;
+    switch (Options.FileType) {
+    case DWARFLinker::OutputFileType::Object:
+      DWARFLinkerOutputType =
+          dwarflinker_parallel::DWARFLinker::OutputFileType::Object;
+      break;
 
-  ObjectsForLinking.clear();
-  ContextForLinking.clear();
-  AddressMapForLinking.clear();
+    case DWARFLinker::OutputFileType::Assembly:
+      DWARFLinkerOutputType =
+          dwarflinker_parallel::DWARFLinker::OutputFileType::Assembly;
+      break;
 
-  DebugMap DebugMap(Map.getTriple(), Map.getBinaryPath());
+    default:
+      llvm_unreachable("");
+    }
 
-  DWARFLinker GeneralLinker(Streamer.get(), DwarfLinkerClient::Dsymutil);
+    return linkImpl<dwarflinker_parallel::DWARFLinker,
+                    dwarflinker_parallel::DWARFFile,
+                    AddressManager<dwarflinker_parallel::AddressesMap>>(
+        Map, DWARFLinkerOutputType);
+  }
 
-  remarks::RemarkLinker RL;
-  if (!Options.RemarksPrependPath.empty())
-    RL.setExternalFilePrependPath(Options.RemarksPrependPath);
-  GeneralLinker.setObjectPrefixMap(&Options.ObjectPrefixMap);
+  return linkImpl<DWARFLinker, DWARFFile, AddressManager<AddressesMap>>(
+      Map, Options.FileType);
+}
+
+template <typename Linker>
+void setAcceleratorTables(Linker &GeneralLinker,
+                          DsymutilAccelTableKind TableKind,
+                          uint16_t MaxDWARFVersion) {
+  switch (TableKind) {
+  case DsymutilAccelTableKind::Apple:
+    GeneralLinker.addAccelTableKind(Linker::AccelTableKind::Apple);
+    break;
+  case DsymutilAccelTableKind::Dwarf:
+    GeneralLinker.addAccelTableKind(Linker::AccelTableKind::DebugNames);
+    break;
+  case DsymutilAccelTableKind::Pub:
+    GeneralLinker.addAccelTableKind(Linker::AccelTableKind::Pub);
+    break;
+  case DsymutilAccelTableKind::Default:
+    if (MaxDWARFVersion >= 5)
+      GeneralLinker.addAccelTableKind(Linker::AccelTableKind::DebugNames);
+    else
+      GeneralLinker.addAccelTableKind(Linker::AccelTableKind::Apple);
+    break;
+  case DsymutilAccelTableKind::None:
+    // Nothing to do.
+    break;
+  }
+}
+
+template <typename Linker, typename OutDwarfFile, typename AddressMap>
+bool DwarfLinkerForBinary::linkImpl(
+    const DebugMap &Map, typename Linker::OutputFileType ObjectType) {
+
+  std::vector<std::unique_ptr<OutDwarfFile>> ObjectsForLinking;
+
+  DebugMap DebugMap(Map.getTriple(), Map.getBinaryPath());
 
   std::function<StringRef(StringRef)> TranslationLambda = [&](StringRef Input) {
     assert(Options.Translator);
     return Options.Translator(Input);
   };
 
-  GeneralLinker.setVerbosity(Options.Verbose);
-  GeneralLinker.setStatistics(Options.Statistics);
-  GeneralLinker.setVerifyInputDWARF(Options.VerifyInputDWARF);
-  GeneralLinker.setNoOutput(Options.NoOutput);
-  GeneralLinker.setNoODR(Options.NoODR);
-  GeneralLinker.setUpdate(Options.Update);
-  GeneralLinker.setNumThreads(Options.Threads);
-  GeneralLinker.setPrependPath(Options.PrependPath);
-  GeneralLinker.setKeepFunctionForStatic(Options.KeepFunctionForStatic);
-  if (Options.Translator)
-    GeneralLinker.setStringsTranslator(TranslationLambda);
-  GeneralLinker.setWarningHandler(
-      [&](const Twine &Warning, StringRef Context, const DWARFDie *DIE) {
-        reportWarning(Warning, Context, DIE);
-      });
-  GeneralLinker.setErrorHandler(
+  std::unique_ptr<Linker> GeneralLinker = Linker::createLinker(
       [&](const Twine &Error, StringRef Context, const DWARFDie *DIE) {
         reportError(Error, Context, DIE);
+      },
+      [&](const Twine &Warning, StringRef Context, const DWARFDie *DIE) {
+        reportWarning(Warning, Context, DIE);
+      },
+      Options.Translator ? TranslationLambda : nullptr);
+
+  if (!Options.NoOutput) {
+    if (Error Err = GeneralLinker->createEmitter(Map.getTriple(), ObjectType,
+                                                 OutFile)) {
+      handleAllErrors(std::move(Err), [&](const ErrorInfoBase &EI) {
+        reportError(EI.message(), "dwarf streamer init");
       });
-  GeneralLinker.setInputVerificationHandler([&](const DWARFFile &File) {
+      return false;
+    }
+  }
+
+  remarks::RemarkLinker RL;
+  if (!Options.RemarksPrependPath.empty())
+    RL.setExternalFilePrependPath(Options.RemarksPrependPath);
+  GeneralLinker->setObjectPrefixMap(&Options.ObjectPrefixMap);
+
+  GeneralLinker->setVerbosity(Options.Verbose);
+  GeneralLinker->setStatistics(Options.Statistics);
+  GeneralLinker->setVerifyInputDWARF(Options.VerifyInputDWARF);
+  GeneralLinker->setNoODR(Options.NoODR);
+  GeneralLinker->setUpdateIndexTablesOnly(Options.Update);
+  GeneralLinker->setNumThreads(Options.Threads);
+  GeneralLinker->setPrependPath(Options.PrependPath);
+  GeneralLinker->setKeepFunctionForStatic(Options.KeepFunctionForStatic);
+  GeneralLinker->setInputVerificationHandler([&](const OutDwarfFile &File) {
     reportWarning("input verification failed", File.FileName);
     HasVerificationErrors = true;
   });
-  objFileLoader Loader = [&DebugMap, &RL,
-                          this](StringRef ContainerName,
-                                StringRef Path) -> ErrorOr<DWARFFile &> {
+  auto Loader = [&](StringRef ContainerName,
+                    StringRef Path) -> ErrorOr<OutDwarfFile &> {
     auto &Obj = DebugMap.addDebugMapObject(
         Path, sys::TimePoint<std::chrono::seconds>(), MachO::N_OSO);
 
-    if (auto ErrorOrObj = loadObject(Obj, DebugMap, RL)) {
-      return *ErrorOrObj;
+    if (ErrorOr<std::unique_ptr<OutDwarfFile>> ErrorOrObj =
+            loadObject<OutDwarfFile, AddressMap>(Obj, DebugMap, RL)) {
+      ObjectsForLinking.emplace_back(std::move(*ErrorOrObj));
+      return *ObjectsForLinking.back();
     } else {
       // Try and emit more helpful warnings by applying some heuristics.
       StringRef ObjFile = ContainerName;
       bool IsClangModule = sys::path::extension(Path).equals(".pcm");
       bool IsArchive = ObjFile.endswith(")");
 
       if (IsClangModule) {
         StringRef ModuleCacheDir = sys::path::parent_path(Path);
if (ErrorOr<std::unique_ptr<OutDwarfFile>> ErrorOrObj =
         }
       }
 
       return ErrorOrObj.getError();
     }
 
     llvm_unreachable("Unhandled DebugMap object");
   };
-  GeneralLinker.setSwiftInterfacesMap(&ParseableSwiftInterfaces);
+  GeneralLinker->setSwiftInterfacesMap(&ParseableSwiftInterfaces);
   bool ReflectionSectionsPresentInBinary = false;
   // If there is no output specified, no point in checking the binary for swift5
   // reflection sections.
   if (!Options.NoOutput) {
     ReflectionSectionsPresentInBinary =
         binaryHasStrippableSwiftReflectionSections(Map, Options, BinHolder);
   }
 
   std::vector<MachOUtils::DwarfRelocationApplicationInfo> RelocationsToApply;
   if (!Options.NoOutput && !ReflectionSectionsPresentInBinary) {
     auto SectionToOffsetInDwarf =
         calculateStartOfStrippableReflectionSections(Map);
     for (const auto &Obj : Map.objects())
-      copySwiftReflectionMetadata(Obj.get(), Streamer.get(),
+      copySwiftReflectionMetadata(Obj.get(), GeneralLinker->getEmitter(),
                                   SectionToOffsetInDwarf, RelocationsToApply);
   }
 
   uint16_t MaxDWARFVersion = 0;
   std::function<void(const DWARFUnit &Unit)> OnCUDieLoaded =
       [&MaxDWARFVersion](const DWARFUnit &Unit) {
         MaxDWARFVersion = std::max(Unit.getVersion(), MaxDWARFVersion);
       };
if (Obj->getType() == MachO::N_AST) {
               << sys::TimePoint<>(ModificationTime) << ") and debug map ("
               << sys::TimePoint<>(Obj->getTimestamp()) << ")\n";
           continue;
         }
       }
 
       // Copy the module into the .swift_ast section.
       if (!Options.NoOutput)
-        Streamer->emitSwiftAST((*ErrorOrMem)->getBuffer());
+        GeneralLinker->getEmitter()->emitSwiftAST((*ErrorOrMem)->getBuffer());
 
       continue;
     }
 
-    if (auto ErrorOrObj = loadObject(*Obj, Map, RL))
-      GeneralLinker.addObjectFile(*ErrorOrObj, Loader, OnCUDieLoaded);
-    else {
-      ObjectsForLinking.push_back(std::make_unique<DWARFFile>(
+    if (ErrorOr<std::unique_ptr<OutDwarfFile>> ErrorOrObj =
+            loadObject<OutDwarfFile, AddressMap>(*Obj, Map, RL)) {
+      ObjectsForLinking.emplace_back(std::move(*ErrorOrObj));
+      GeneralLinker->addObjectFile(*ObjectsForLinking.back(), Loader,
+                                   OnCUDieLoaded);
+    } else {
+      ObjectsForLinking.push_back(std::make_unique<OutDwarfFile>(
           Obj->getObjectFilename(), nullptr, nullptr,
           Obj->empty() ? Obj->getWarnings() : EmptyWarnings));
-      GeneralLinker.addObjectFile(*ObjectsForLinking.back());
+      GeneralLinker->addObjectFile(*ObjectsForLinking.back());
     }
   }
 
   // If we haven't seen any CUs, pick an arbitrary valid Dwarf version anyway.
   if (MaxDWARFVersion == 0)
     MaxDWARFVersion = 3;
 
-  if (Error E = GeneralLinker.setTargetDWARFVersion(MaxDWARFVersion))
+  if (Error E = GeneralLinker->setTargetDWARFVersion(MaxDWARFVersion))
     return error(toString(std::move(E)));
 
-  switch (Options.TheAccelTableKind) {
-  case DsymutilAccelTableKind::Apple:
-    GeneralLinker.addAccelTableKind(DwarfLinkerAccelTableKind::Apple);
-    break;
-  case DsymutilAccelTableKind::Dwarf:
-    GeneralLinker.addAccelTableKind(DwarfLinkerAccelTableKind::DebugNames);
-    break;
-  case DsymutilAccelTableKind::Pub:
-    GeneralLinker.addAccelTableKind(DwarfLinkerAccelTableKind::Pub);
-    break;
-  case DsymutilAccelTableKind::Default:
-    if (MaxDWARFVersion >= 5)
-      GeneralLinker.addAccelTableKind(DwarfLinkerAccelTableKind::DebugNames);
-    else
-      GeneralLinker.addAccelTableKind(DwarfLinkerAccelTableKind::Apple);
-    break;
-  case DsymutilAccelTableKind::None:
-    // Nothing to do.
-    break;
-  }
+  setAcceleratorTables<Linker>(*GeneralLinker, Options.TheAccelTableKind,
+                               MaxDWARFVersion);
 
   // link debug info for loaded object files.
-  if (Error E = GeneralLinker.link())
+  if (Error E = GeneralLinker->link())
     return error(toString(std::move(E)));
 
   StringRef ArchName = Map.getTriple().getArchName();
   if (Error E = emitRemarks(Options, Map.getBinaryPath(), ArchName, RL))
     return error(toString(std::move(E)));
 
   if (Options.NoOutput)
     return true;
 
   if (Options.ResourceDir && !ParseableSwiftInterfaces.empty()) {
     StringRef ArchName = Triple::getArchTypeName(Map.getTriple().getArch());
     if (auto E = copySwiftInterfaces(ArchName))
       return error(toString(std::move(E)));
   }
 
   if (Map.getTriple().isOSDarwin() && !Map.getBinaryPath().empty() &&
-      Options.FileType == OutputFileType::Object)
+      ObjectType == Linker::OutputFileType::Object)
     return MachOUtils::generateDsymCompanion(
         Options.VFS, Map, Options.Translator,
-        *Streamer->getAsmPrinter().OutStreamer, OutFile, RelocationsToApply);
+        *GeneralLinker->getEmitter()->getAsmPrinter().OutStreamer, OutFile,
+        RelocationsToApply);
 
-  Streamer->finish();
+  GeneralLinker->getEmitter()->finish();
   return true;
 }
 
 /// 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, std::vector<ValidReloc> &ValidRelocs) {
+template <typename AddressesMapBase>
+void DwarfLinkerForBinary::AddressManager<AddressesMapBase>::
+    findValidRelocsMachO(const object::SectionRef &Section,
+                         const object::MachOObjectFile &Obj,
+                         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;
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 DwarfLinkerForBinary::AddressManager::findValidRelocs(
+template <typename AddressesMapBase>
+bool DwarfLinkerForBinary::AddressManager<AddressesMapBase>::findValidRelocs(
     const object::SectionRef &Section, const object::ObjectFile &Obj,
     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, Relocs);
   else
     Linker.reportWarning(Twine("unsupported object file type: ") +
                              Obj.getFileName(),
                          DMO.getObjectFilename());
   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(Relocs);
   return true;
 }
 
 /// 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::findValidRelocsInDebugSections(
-    const object::ObjectFile &Obj, const DebugMapObject &DMO) {
+template <typename AddressesMapBase>
+bool DwarfLinkerForBinary::AddressManager<AddressesMapBase>::
+    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")
       FoundValidRelocs |=
           findValidRelocs(Section, Obj, DMO, ValidDebugInfoRelocs);
     if (SectionName == "debug_addr")
       FoundValidRelocs |=
           findValidRelocs(Section, Obj, DMO, ValidDebugAddrRelocs);
   }
   return FoundValidRelocs;
 }
 
-std::vector<DwarfLinkerForBinary::AddressManager::ValidReloc>
-DwarfLinkerForBinary::AddressManager::getRelocations(
+template <typename AddressesMapBase>
+std::vector<
+    typename DwarfLinkerForBinary::AddressManager<AddressesMapBase>::ValidReloc>
+DwarfLinkerForBinary::AddressManager<AddressesMapBase>::getRelocations(
     const std::vector<ValidReloc> &Relocs, uint64_t StartPos, uint64_t EndPos) {
-  std::vector<DwarfLinkerForBinary::AddressManager::ValidReloc> Res;
+  std::vector<
+      DwarfLinkerForBinary::AddressManager<AddressesMapBase>::ValidReloc>
+      Res;
 
   auto CurReloc = partition_point(Relocs, [StartPos](const ValidReloc &Reloc) {
     return Reloc.Offset < StartPos;
   });
 
   while (CurReloc != Relocs.end() && CurReloc->Offset >= StartPos &&
          CurReloc->Offset < EndPos) {
     Res.push_back(*CurReloc);
     CurReloc++;
   }
 
   return Res;
 }
 
-void DwarfLinkerForBinary::AddressManager::printReloc(const ValidReloc &Reloc) {
+template <typename AddressesMapBase>
+void DwarfLinkerForBinary::AddressManager<AddressesMapBase>::printReloc(
+    const ValidReloc &Reloc) {
   const auto &Mapping = Reloc.Mapping->getValue();
   const uint64_t ObjectAddress = Mapping.ObjectAddress
                                      ? uint64_t(*Mapping.ObjectAddress)
                                      : std::numeric_limits<uint64_t>::max();
 
   outs() << "Found valid debug map entry: " << Reloc.Mapping->getKey() << "\t"
          << format("0x%016" PRIx64 " => 0x%016" PRIx64 "\n", ObjectAddress,
                    uint64_t(Mapping.BinaryAddress));
 }
 
-int64_t
-DwarfLinkerForBinary::AddressManager::getRelocValue(const ValidReloc &Reloc) {
+template <typename AddressesMapBase>
+int64_t DwarfLinkerForBinary::AddressManager<AddressesMapBase>::getRelocValue(
+    const ValidReloc &Reloc) {
   int64_t AddrAdjust = relocate(Reloc);
   if (Reloc.Mapping->getValue().ObjectAddress)
     AddrAdjust -= uint64_t(*Reloc.Mapping->getValue().ObjectAddress);
   return AddrAdjust;
 }
 
+template <typename AddressesMapBase>
 std::optional<int64_t>
-DwarfLinkerForBinary::AddressManager::hasValidRelocationAt(
+DwarfLinkerForBinary::AddressManager<AddressesMapBase>::hasValidRelocationAt(
     const std::vector<ValidReloc> &AllRelocs, uint64_t StartOffset,
     uint64_t EndOffset) {
   std::vector<ValidReloc> Relocs =
       getRelocations(AllRelocs, StartOffset, EndOffset);
 
   if (Relocs.size() == 0)
     return std::nullopt;
 
getAttributeOffsets(const DWARFAbbreviationDeclaration *Abbrev, unsigned Idx,
 
   uint64_t End = Offset;
   DWARFFormValue::skipValue(Abbrev->getFormByIndex(Idx), Data, &End,
                             Unit.getFormParams());
 
   return std::make_pair(Offset, End);
 }
 
-std::optional<int64_t>
-DwarfLinkerForBinary::AddressManager::getExprOpAddressRelocAdjustment(
-    DWARFUnit &U, const DWARFExpression::Operation &Op, uint64_t StartOffset,
-    uint64_t EndOffset) {
+template <typename AddressesMapBase>
+std::optional<int64_t> DwarfLinkerForBinary::AddressManager<AddressesMapBase>::
+    getExprOpAddressRelocAdjustment(DWARFUnit &U,
+                                    const DWARFExpression::Operation &Op,
+                                    uint64_t StartOffset, uint64_t EndOffset) {
   switch (Op.getCode()) {
   default: {
     assert(false && "Specified operation does not have address operand");
   } break;
   case dwarf::DW_OP_const4u:
   case dwarf::DW_OP_const8u:
   case dwarf::DW_OP_const4s:
   case dwarf::DW_OP_const8s:
   case dwarf::DW_OP_addr: {
     return hasValidRelocationAt(ValidDebugInfoRelocs, StartOffset, EndOffset);
   } break;
   case dwarf::DW_OP_constx:
   case dwarf::DW_OP_addrx: {
     return hasValidRelocationAt(ValidDebugAddrRelocs, StartOffset, EndOffset);
   } break;
   }
 
   return std::nullopt;
 }
 
-std::optional<int64_t>
-DwarfLinkerForBinary::AddressManager::getSubprogramRelocAdjustment(
-    const DWARFDie &DIE) {
+template <typename AddressesMapBase>
+std::optional<int64_t> DwarfLinkerForBinary::AddressManager<
+    AddressesMapBase>::getSubprogramRelocAdjustment(const DWARFDie &DIE) {
   const auto *Abbrev = DIE.getAbbreviationDeclarationPtr();
 
   std::optional<uint32_t> LowPcIdx =
       Abbrev->findAttributeIndex(dwarf::DW_AT_low_pc);
   if (!LowPcIdx)
     return std::nullopt;
 
   dwarf::Form Form = Abbrev->getFormByIndex(*LowPcIdx);
case dwarf::DW_FORM_addrx4: {
     Linker.reportWarning("no base offset for address table", SrcFileName);
     return std::nullopt;
   }
   default:
     return std::nullopt;
   }
 }
 
-uint64_t
-DwarfLinkerForBinary::AddressManager::relocate(const ValidReloc &Reloc) const {
+template <typename AddressesMapBase>
+uint64_t DwarfLinkerForBinary::AddressManager<AddressesMapBase>::relocate(
+    const ValidReloc &Reloc) const {
   return Reloc.Mapping->getValue().BinaryAddress + Reloc.Addend;
 }
 
 /// 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(
+template <typename AddressesMapBase>
+bool DwarfLinkerForBinary::AddressManager<AddressesMapBase>::applyValidRelocs(
     MutableArrayRef<char> Data, uint64_t BaseOffset, bool IsLittleEndian) {
   std::vector<ValidReloc> Relocs = getRelocations(
       ValidDebugInfoRelocs, BaseOffset, BaseOffset + Data.size());
 
   for (const ValidReloc &CurReloc : Relocs) {
     assert(CurReloc.Offset - BaseOffset < Data.size());
     assert(CurReloc.Offset - BaseOffset + CurReloc.Size <= Data.size());
     char Buf[8];

llvm/tools/dsymutil/LinkUtils.h

 enum class DsymutilAccelTableKind : uint8_t {
   None,
   Apple,   ///< .apple_names, .apple_namespaces, .apple_types, .apple_objc.
   Dwarf,   ///< DWARF v5 .debug_names.
   Default, ///< Dwarf for DWARF5 or later, Apple otherwise.
   Pub,     ///< .debug_pubnames, .debug_pubtypes
 };
 
+enum class DsymutilDWARFLinkerType : uint8_t {
+  Apple, /// Apple`s implementation of DWARFLinker.
+  LLVM   /// LLVM implementation of DWARFLinker.
+};
+
 struct LinkOptions {
   /// Verbosity
   bool Verbose = false;
 
   /// Statistics
   bool Statistics = false;
 
   /// Verify the input DWARF.
struct LinkOptions {
 
   /// Do not check swiftmodule timestamp
   bool NoTimestamp = false;
 
   /// Whether we want a static variable to force us to keep its enclosing
   /// function.
   bool KeepFunctionForStatic = false;
 
+  /// Type of DWARFLinker to use.
+  DsymutilDWARFLinkerType DWARFLinkerType = DsymutilDWARFLinkerType::Apple;
+
   /// Use a 64-bit header when emitting universal binaries.
   bool Fat64 = false;
 
   /// Number of threads.
   unsigned Threads = 1;
 
   // Output file type.
-  OutputFileType FileType = OutputFileType::Object;
+  DWARFLinker::OutputFileType FileType = DWARFLinker::OutputFileType::Object;
 
   /// The accelerator table kind
   DsymutilAccelTableKind TheAccelTableKind;
 
   /// -oso-prepend-path
   std::string PrependPath;
 
   /// The -object-prefix-map.

llvm/tools/dsymutil/Options.td

def remarks_prepend_path: Separate<["--", "-"], "remarks-prepend-path">,
   Group<grp_general>;
 def: Joined<["--", "-"], "remarks-prepend-path=">, Alias<remarks_prepend_path>;
 
 def remarks_output_format: Separate<["--", "-"], "remarks-output-format">,
   MetaVarName<"<format>">,
   HelpText<"Specify the format to be used when serializing the linked remarks.">,
   Group<grp_general>;
 def: Joined<["--", "-"], "remarks-output-format=">, Alias<remarks_output_format>;
+
+def linker: Separate<["--", "-"], "linker">,
+  MetaVarName<"<DWARF linker type>">,
+  HelpText<"Specify the desired type of DWARF linker. Defaults to 'apple'">,
+  Group<grp_general>;
+def: Joined<["--", "-"], "linker=">, Alias<linker>;

llvm/tools/dsymutil/dsymutil.cpp

if (opt::Arg *Accelerator = Args.getLastArg(OPT_accelerator)) {
     return make_error<StringError>("invalid accelerator type specified: '" + S +
                                        "'. Supported values are 'Apple', "
                                        "'Dwarf', 'Pub', 'Default' and 'None'.",
                                    inconvertibleErrorCode());
   }
   return DsymutilAccelTableKind::Default;
 }
 
+static Expected<DsymutilDWARFLinkerType>
+getDWARFLinkerType(opt::InputArgList &Args) {
+  if (opt::Arg *LinkerType = Args.getLastArg(OPT_linker)) {
+    StringRef S = LinkerType->getValue();
+
+    if (S == "apple")
+      return DsymutilDWARFLinkerType::Apple;
+
+    if (S == "llvm")
+      return DsymutilDWARFLinkerType::LLVM;
+
+    return make_error<StringError>("invalid DWARF linker type specified: '" +
+                                       S +
+                                       "'. Supported values are 'apple', "
+                                       "'llvm'.",
+                                   inconvertibleErrorCode());
+  }
+
+  return DsymutilDWARFLinkerType::Apple;
+}
+
 static Expected<ReproducerMode> getReproducerMode(opt::InputArgList &Args) {
   if (Args.hasArg(OPT_gen_reproducer))
     return ReproducerMode::GenerateOnExit;
   if (opt::Arg *Reproducer = Args.getLastArg(OPT_reproducer)) {
     StringRef S = Reproducer->getValue();
     if (S == "GenerateOnExit")
       return ReproducerMode::GenerateOnExit;
     if (S == "GenerateOnCrash")
static Expected<DsymutilOptions> getOptions(opt::InputArgList &Args) {
   }
 
   if (Expected<DsymutilAccelTableKind> AccelKind = getAccelTableKind(Args)) {
     Options.LinkOpts.TheAccelTableKind = *AccelKind;
   } else {
     return AccelKind.takeError();
   }
 
+  if (Expected<DsymutilDWARFLinkerType> DWARFLinkerType =
+          getDWARFLinkerType(Args)) {
+    Options.LinkOpts.DWARFLinkerType = *DWARFLinkerType;
+  } else {
+    return DWARFLinkerType.takeError();
+  }
+
   if (opt::Arg *SymbolMap = Args.getLastArg(OPT_symbolmap))
     Options.SymbolMap = SymbolMap->getValue();
 
   if (Args.hasArg(OPT_symbolmap))
     Options.LinkOpts.Update = true;
 
   if (Expected<std::vector<std::string>> InputFiles =
           getInputs(Args, Options.LinkOpts.Update)) {
static Expected<DsymutilOptions> getOptions(opt::InputArgList &Args) {
 
   if (opt::Arg *OutputFile = Args.getLastArg(OPT_output))
     Options.OutputFile = OutputFile->getValue();
 
   if (opt::Arg *Toolchain = Args.getLastArg(OPT_toolchain))
     Options.Toolchain = Toolchain->getValue();
 
   if (Args.hasArg(OPT_assembly))
-    Options.LinkOpts.FileType = OutputFileType::Assembly;
+    Options.LinkOpts.FileType = DWARFLinker::OutputFileType::Assembly;
 
   if (opt::Arg *NumThreads = Args.getLastArg(OPT_threads))
     Options.LinkOpts.Threads = atoi(NumThreads->getValue());
   else
     Options.LinkOpts.Threads = 0; // Use all available hardware threads
 
   if (Options.DumpDebugMap || Options.LinkOpts.Verbose)
     Options.LinkOpts.Threads = 1;

llvm/tools/llvm-dwarfutil/CMakeLists.txt

 set(LLVM_TARGET_DEFINITIONS Options.td)
 tablegen(LLVM Options.inc -gen-opt-parser-defs)
 add_public_tablegen_target(DwarfutilTableGen)
 
 set(LLVM_LINK_COMPONENTS
   AllTargetsCodeGens
   AllTargetsDescs
   AllTargetsInfos
   CodeGenTypes
   DWARFLinker
+  DWARFLinkerParallel
   DebugInfoDWARF
   MC
   ObjCopy
   Object
   Option
   Support
   Target
   TargetParser

llvm/tools/llvm-dwarfutil/DebugInfoLinker.cpp

 //=== DebugInfoLinker.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 "DebugInfoLinker.h"
 #include "Error.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/DWARFLinker/DWARFLinker.h"
 #include "llvm/DWARFLinker/DWARFStreamer.h"
+#include "llvm/DWARFLinkerParallel/DWARFLinker.h"
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFExpression.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Support/Endian.h"
 #include <memory>
 #include <vector>
 
 namespace llvm {

 //
 // maxpc: (LowPC == -1) or (LowPC == -2 and  DWARF v4 (or less))
 //        That value is assumed to be compatible with
 //        http://www.dwarfstd.org/ShowIssue.php?issue=200609.1
 //
 // exec: [LowPC, HighPC] is not inside address ranges of .text sections
 //
 // universal: maxpc and bfd
-class ObjFileAddressMap : public AddressesMap {
+template <typename AddressMapBase>
+class ObjFileAddressMap : public AddressMapBase {
 public:
   ObjFileAddressMap(DWARFContext &Context, const Options &Options,
                     object::ObjectFile &ObjFile)
       : Opts(Options) {
     // Remember addresses of existing text sections.
     for (const object::SectionRef &Sect : ObjFile.sections()) {
       if (!Sect.isText())
         continue;
return llvm::StringSwitch<bool>(SecName)
       .Case(".debug_str", true)
       .Case(".debug_str_offsets", true)
       .Case(".debug_pubnames", true)
       .Case(".debug_pubtypes", true)
       .Case(".debug_names", true)
       .Default(false);
 }
 
-static std::optional<DwarfLinkerAccelTableKind>
+template <typename AccelTableKind>
+static std::optional<AccelTableKind>
 getAcceleratorTableKind(StringRef SecName) {
-  return llvm::StringSwitch<std::optional<DwarfLinkerAccelTableKind>>(SecName)
-      .Case(".debug_pubnames", DwarfLinkerAccelTableKind::Pub)
-      .Case(".debug_pubtypes", DwarfLinkerAccelTableKind::Pub)
-      .Case(".debug_names", DwarfLinkerAccelTableKind::DebugNames)
+  return llvm::StringSwitch<std::optional<AccelTableKind>>(SecName)
+      .Case(".debug_pubnames", AccelTableKind::Pub)
+      .Case(".debug_pubtypes", AccelTableKind::Pub)
+      .Case(".debug_names", AccelTableKind::DebugNames)
       .Default(std::nullopt);
 }
 
 static std::string getMessageForReplacedAcceleratorTables(
     SmallVector<StringRef> &AccelTableNamesToReplace,
     DwarfUtilAccelKind TargetTable) {
   std::string Message;
 
for (StringRef Name : AccelTableNamesToReplace) {
     Message += Name;
   }
 
   Message += "' will be deleted as no accelerator tables are requested";
 
   return Message;
 }
 
-Error linkDebugInfo(object::ObjectFile &File, const Options &Options,
+template <typename Linker, typename OutDwarfFile, typename AddressMapBase>
+Error linkDebugInfoImpl(object::ObjectFile &File, const Options &Options,
                         raw_pwrite_stream &OutStream) {
-
   auto ReportWarn = [&](const Twine &Message, StringRef Context,
                         const DWARFDie *Die) {
     warning(Message, Context);
 
     if (!Options.Verbose || !Die)
       return;
 
     DIDumpOptions DumpOpts;
     DumpOpts.ChildRecurseDepth = 0;
     DumpOpts.Verbose = Options.Verbose;
 
     WithColor::note() << "    in DIE:\n";
     Die->dump(errs(), /*Indent=*/6, DumpOpts);
   };
   auto ReportErr = [&](const Twine &Message, StringRef Context,
                        const DWARFDie *) {
     WithColor::error(errs(), Context) << Message << '\n';
   };
 
-  // Create output streamer.
-  DwarfStreamer OutStreamer(OutputFileType::Object, OutStream, nullptr,
-                            ReportWarn, ReportWarn);
-  Triple TargetTriple = File.makeTriple();
-  if (!OutStreamer.init(TargetTriple, formatv("cannot create a stream for {0}",
-                                              TargetTriple.getTriple())
-                                          .str()))
-    return createStringError(std::errc::invalid_argument, "");
-
-  std::unique_ptr<DWARFContext> Context = DWARFContext::create(File);
-
   // Create DWARF linker.
-  DWARFLinker DebugInfoLinker(&OutStreamer, DwarfLinkerClient::LLD);
+  std::unique_ptr<Linker> DebugInfoLinker =
+      Linker::createLinker(ReportErr, ReportWarn);
+
+  Triple TargetTriple = File.makeTriple();
+  if (Error Err = DebugInfoLinker->createEmitter(
+          TargetTriple, Linker::OutputFileType::Object, OutStream))
+    return Err;
 
-  DebugInfoLinker.setEstimatedObjfilesAmount(1);
-  DebugInfoLinker.setErrorHandler(ReportErr);
-  DebugInfoLinker.setWarningHandler(ReportWarn);
-  DebugInfoLinker.setNumThreads(Options.NumThreads);
-  DebugInfoLinker.setNoODR(!Options.DoODRDeduplication);
-  DebugInfoLinker.setVerbosity(Options.Verbose);
-  DebugInfoLinker.setUpdate(!Options.DoGarbageCollection);
+  DebugInfoLinker->setEstimatedObjfilesAmount(1);
+  DebugInfoLinker->setNumThreads(Options.NumThreads);
+  DebugInfoLinker->setNoODR(!Options.DoODRDeduplication);
+  DebugInfoLinker->setVerbosity(Options.Verbose);
+  DebugInfoLinker->setUpdateIndexTablesOnly(!Options.DoGarbageCollection);
 
-  std::vector<std::unique_ptr<DWARFFile>> ObjectsForLinking(1);
-  std::vector<std::unique_ptr<AddressesMap>> AddresssMapForLinking(1);
+  std::vector<std::unique_ptr<OutDwarfFile>> ObjectsForLinking(1);
   std::vector<std::string> EmptyWarnings;
 
   // Add object files to the DWARFLinker.
-  AddresssMapForLinking[0] =
-      std::make_unique<ObjFileAddressMap>(*Context, Options, File);
-
-  ObjectsForLinking[0] = std::make_unique<DWARFFile>(
-      File.getFileName(), &*Context, AddresssMapForLinking[0].get(),
-      EmptyWarnings);
+  std::unique_ptr<DWARFContext> Context = DWARFContext::create(File);
+  std::unique_ptr<ObjFileAddressMap<AddressMapBase>> AddressesMap(
+      std::make_unique<ObjFileAddressMap<AddressMapBase>>(*Context, Options,
+                                                          File));
+
+  ObjectsForLinking[0] =
+      std::make_unique<OutDwarfFile>(File.getFileName(), std::move(Context),
+                                     std::move(AddressesMap), EmptyWarnings);
 
   uint16_t MaxDWARFVersion = 0;
   std::function<void(const DWARFUnit &Unit)> OnCUDieLoaded =
       [&MaxDWARFVersion](const DWARFUnit &Unit) {
         MaxDWARFVersion = std::max(Unit.getVersion(), MaxDWARFVersion);
       };
 
   for (size_t I = 0; I < ObjectsForLinking.size(); I++)
-    DebugInfoLinker.addObjectFile(*ObjectsForLinking[I], nullptr,
+    DebugInfoLinker->addObjectFile(*ObjectsForLinking[I], nullptr,
                                    OnCUDieLoaded);
 
   // If we haven't seen any CUs, pick an arbitrary valid Dwarf version anyway.
   if (MaxDWARFVersion == 0)
     MaxDWARFVersion = 3;
 
-  if (Error Err = DebugInfoLinker.setTargetDWARFVersion(MaxDWARFVersion))
+  if (Error Err = DebugInfoLinker->setTargetDWARFVersion(MaxDWARFVersion))
     return Err;
 
-  SmallVector<DwarfLinkerAccelTableKind> AccelTables;
+  SmallVector<typename Linker::AccelTableKind> AccelTables;
 
   switch (Options.AccelTableKind) {
   case DwarfUtilAccelKind::None:
     // Nothing to do.
     break;
   case DwarfUtilAccelKind::DWARF:
     // use .debug_names for all DWARF versions.
-    AccelTables.push_back(DwarfLinkerAccelTableKind::DebugNames);
+    AccelTables.push_back(Linker::AccelTableKind::DebugNames);
     break;
   }
 
   // Add accelerator tables to DWARFLinker.
-  for (DwarfLinkerAccelTableKind Table : AccelTables)
-    DebugInfoLinker.addAccelTableKind(Table);
+  for (typename Linker::AccelTableKind Table : AccelTables)
+    DebugInfoLinker->addAccelTableKind(Table);
 
+  for (std::unique_ptr<OutDwarfFile> &CurFile : ObjectsForLinking) {
     SmallVector<StringRef> AccelTableNamesToReplace;
     SmallVector<StringRef> AccelTableNamesToDelete;
 
     // Unknown debug sections or non-requested accelerator sections would be
     // removed. Display warning for such sections.
-  for (SectionName Sec : Context->getDWARFObj().getSectionNames()) {
+    for (SectionName Sec : CurFile->Dwarf->getDWARFObj().getSectionNames()) {
       if (isDebugSection(Sec.Name)) {
-      std::optional<DwarfLinkerAccelTableKind> SrcAccelTableKind =
-          getAcceleratorTableKind(Sec.Name);
+        std::optional<typename Linker::AccelTableKind> SrcAccelTableKind =
+            getAcceleratorTableKind<typename Linker::AccelTableKind>(Sec.Name);
 
         if (SrcAccelTableKind) {
           assert(knownByDWARFUtil(Sec.Name));
 
           if (Options.AccelTableKind == DwarfUtilAccelKind::None)
             AccelTableNamesToDelete.push_back(Sec.Name);
           else if (std::find(AccelTables.begin(), AccelTables.end(),
                              *SrcAccelTableKind) == AccelTables.end())
             AccelTableNamesToReplace.push_back(Sec.Name);
         } else if (!knownByDWARFUtil(Sec.Name)) {
           assert(!SrcAccelTableKind);
           warning(
-            formatv("'{0}' is not currently supported: section will be skipped",
-                    Sec.Name),
+              formatv(
+                  "'{0}' is not currently supported: section will be skipped",
               Options.InputFileName);
         }
       }
     }
 
     // Display message for the replaced accelerator tables.
     if (!AccelTableNamesToReplace.empty())
       warning(getMessageForReplacedAcceleratorTables(AccelTableNamesToReplace,
                                                      Options.AccelTableKind),
               Options.InputFileName);
 
     // Display message for the removed accelerator tables.
     if (!AccelTableNamesToDelete.empty())
       warning(getMessageForDeletedAcceleratorTables(AccelTableNamesToDelete),
               Options.InputFileName);
+  }
 
   // Link debug info.
-  if (Error Err = DebugInfoLinker.link())
+  if (Error Err = DebugInfoLinker->link())
     return Err;
 
-  OutStreamer.finish();
+  DebugInfoLinker->getEmitter()->finish();
   return Error::success();
 }
 
+Error linkDebugInfo(object::ObjectFile &File, const Options &Options,
+                    raw_pwrite_stream &OutStream) {
+  if (Options.UseLLVMDWARFLinker)
+    return linkDebugInfoImpl<dwarflinker_parallel::DWARFLinker,
+                             dwarflinker_parallel::DWARFFile,
+                             dwarflinker_parallel::AddressesMap>(File, Options,
+                                                                 OutStream);
+  else
+    return linkDebugInfoImpl<DWARFLinker, DWARFFile, AddressesMap>(
+        File, Options, OutStream);
+}
+
 } // end of namespace dwarfutil
 } // end of namespace llvm

llvm/tools/llvm-dwarfutil/Options.h

struct Options {
   std::string OutputFileName;
   bool DoGarbageCollection = false;
   bool DoODRDeduplication = false;
   bool BuildSeparateDebugFile = false;
   TombstoneKind Tombstone = TombstoneKind::Universal;
   bool Verbose = false;
   int NumThreads = 0;
   bool Verify = false;
+  bool UseLLVMDWARFLinker = false;
   DwarfUtilAccelKind AccelTableKind = DwarfUtilAccelKind::None;
 
   std::string getSeparateDebugFileName() const {
     return OutputFileName + ".debug";
   }
 };
 
 } // namespace dwarfutil
 } // namespace llvm
 
 #endif // LLVM_TOOLS_LLVM_DWARFUTIL_OPTIONS_H

llvm/tools/llvm-dwarfutil/Options.td

 
 def help : Flag<["--"], "help">,
   HelpText<"Prints this help output">;
 
 def h : Flag<["-"], "h">,
   Alias<help>,
   HelpText<"Alias for --help">;
 
+def linker: Separate<["--", "-"], "linker">,
+  MetaVarName<"<DWARF linker type>">,
+  HelpText<"Specify the desired type of DWARF linker. Defaults to 'apple'">;
+def: Joined<["--", "-"], "linker=">, Alias<linker>;
+
 defm odr_deduplication : BB<"odr-deduplication",
   "Do ODR deduplication for debug types(default)",
   "Don`t do ODR deduplication for debug types">;
 
 def odr : Flag<["--"], "odr">,
   Alias<odr_deduplication>,
   HelpText<"Alias for --odr-deduplication">;
 

llvm/tools/llvm-dwarfutil/llvm-dwarfutil.cpp

if (opt::Arg *Tombstone = Args.getLastArg(OPT_tombstone)) {
     else if (S == "exec")
       Options.Tombstone = TombstoneKind::Exec;
     else
       return createStringError(
           std::errc::invalid_argument,
           formatv("unknown tombstone value: '{0}'", S).str().c_str());
   }
 
+  if (opt::Arg *LinkerKind = Args.getLastArg(OPT_linker)) {
+    StringRef S = LinkerKind->getValue();
+    if (S == "apple")
+      Options.UseLLVMDWARFLinker = false;
+    else if (S == "llvm")
+      Options.UseLLVMDWARFLinker = true;
+    else
+      return createStringError(
+          std::errc::invalid_argument,
+          formatv("unknown linker kind value: '{0}'", S).str().c_str());
+  }
+
   if (opt::Arg *BuildAccelerator = Args.getLastArg(OPT_build_accelerator)) {
     StringRef S = BuildAccelerator->getValue();
 
     if (S == "none")
       Options.AccelTableKind = DwarfUtilAccelKind::None;
     else if (S == "DWARF")
       Options.AccelTableKind = DwarfUtilAccelKind::DWARF;
     else