[DWARFLinker][NFC] Remove usages of "const object::ObjectFile" from DWARFLinker.

[avl]

Summary

DWARFContext has all the required information to access source debug info.
It is not necessary to use "const object::ObjectFile" to create DWARFContext.
Thus this patch removes all usages of "const object::ObjectFile"
from DWARFLinker. Instead, already created DWARFContext is passed
to DWARFLinker. The purpose is to not depend on "const object::ObjectFile".

The patch looks big, but most of changes are renamings and movements.

Testing: it passes "check-all" lit testing. MD5 checksum for clang .dSYM bundle
matches for the dsymutil with/without that patch.

[JDevlieghere]

Seems reasonable. I assume you didn't rename the variable names to limit the churn? How much bigger is the patch if you do?

[avl]

Seems reasonable. I assume you didn't rename the variable names to limit the churn? How much bigger is the patch if you do?

Other than removing references to object::ObjectFile, this patch renames DwarfLinkerObjFile into DwarfFile. there are 57 places which hit by that renaming.

[avl]

@JDevlieghere So, Is it OK or do I need to make changes?

[JDevlieghere]

In D75029#1894876, @avl wrote:

@JDevlieghere So, Is it OK or do I need to make changes?

I meant the variable names like OF in DwarfFile &OF, which used to make sense for ObjectFile but not so much for DwarfFile. If it doesn't cause too much churn I'd like to rename these as well. The change itself looks good.

[avl]

I meant the variable names like OF in DwarfFile &OF, which used to make sense for ObjectFile but not so much for DwarfFile. If it doesn't cause too much churn I'd like to rename these as well. The change itself looks good.

Ah, I see. Will rename them.

[avl]

addressed comments(renamed ObjectFile &OF -> DwarfFile &File).

[JDevlieghere]

Thanks! LGTM

llvm/include/llvm/DWARFLinker/DWARFLinker.h

 /// DwarfEmitter presents interface to generate all debug info tables.
 class DwarfEmitter {
 public:
   virtual ~DwarfEmitter();
 
   /// Emit DIE containing warnings.
   virtual void emitPaperTrailWarningsDie(DIE &Die) = 0;
 
-  /// Emit section named SecName with content equals to
-  /// corresponding section in Obj.
-  virtual void emitSectionContents(const object::ObjectFile &Obj,
-                                   StringRef SecName) = 0;
+  /// Emit section named SecName with data SecData.
+  virtual void emitSectionContents(StringRef SecData, StringRef SecName) = 0;
 
   /// Emit the abbreviation table \p Abbrevs to the debug_abbrev section.
   virtual void
   emitAbbrevs(const std::vector<std::unique_ptr<DIEAbbrev>> &Abbrevs,
               unsigned DwarfVersion) = 0;
 
   /// Emit the string table described by \p Pool.
   virtual void emitStrings(const NonRelocatableStringpool &Pool) = 0;
public:
   virtual uint64_t getRangesSectionSize() const = 0;
 
   /// Returns size of generated .debug_info section.
   virtual uint64_t getDebugInfoSectionSize() const = 0;
 };
 
 using UnitListTy = std::vector<std::unique_ptr<CompileUnit>>;
 
-/// this class represents Object File and it`s additional info.
-class DwarfLinkerObjFile {
+/// this class represents DWARF information for source file
+/// and it`s address map.
+class DwarfFile {
 public:
-  DwarfLinkerObjFile(StringRef Name, const object::ObjectFile *File,
-                     const std::vector<std::string> &Warnings)
-      : FileName(Name), ObjFile(File), Warnings(Warnings) {}
+  DwarfFile(StringRef Name, DWARFContext *Dwarf, AddressesMap *Addresses,
+      : FileName(Name), Dwarf(Dwarf), Addresses(Addresses), Warnings(Warnings) {
+  }
 
   /// object file name.
   StringRef FileName;
-  /// object file.
-  const object::ObjectFile *ObjFile;
+  /// source DWARF information.
+  DWARFContext *Dwarf = nullptr;
   /// helpful address information(list of valid address ranges, relocations).
-  std::unique_ptr<AddressesMap> Addresses;
+  AddressesMap *Addresses = nullptr;
   /// warnings for object file.
   const std::vector<std::string> &Warnings;
 };
 
 typedef std::function<void(const Twine &Warning, StringRef Context,
                            const DWARFDie *DIE)>
     messageHandler;
-typedef std::function<ErrorOr<DwarfLinkerObjFile &>(StringRef ContainerName,
-                                                    StringRef Path)>
+typedef std::function<ErrorOr<DwarfFile &>(StringRef ContainerName,
     objFileLoader;
 typedef std::map<std::string, std::string> swiftInterfacesMap;
 
 /// 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) {}
 
   /// Add object file to be linked.
-  void addObjectFile(DwarfLinkerObjFile &ObjFile);
+  void addObjectFile(DwarfFile &File);
 
   /// Link debug info for added objFiles. Object
   /// files are linked all together.
   bool link();
 
   /// A number of methods setting various linking options:
 
   /// Allows to generate log of linking process to the standard output.
struct WorklistItem {
     WorklistItem(unsigned AncestorIdx, CompileUnit &CU, unsigned Flags)
         : Type(WorklistItemType::LookForParentDIEsToKeep), CU(CU), Flags(Flags),
           AncestorIdx(AncestorIdx) {}
   };
 
   /// returns true if we need to translate strings.
   bool needToTranslateStrings() { return StringsTranslator != nullptr; }
 
-  void reportWarning(const Twine &Warning, const DwarfLinkerObjFile &OF,
+  void reportWarning(const Twine &Warning, const DwarfFile &File,
                      const DWARFDie *DIE = nullptr) const {
     if (Options.WarningHandler != nullptr)
-      Options.WarningHandler(Warning, OF.FileName, DIE);
+      Options.WarningHandler(Warning, File.FileName, DIE);
   }
 
-  void reportError(const Twine &Warning, const DwarfLinkerObjFile &OF,
+  void reportError(const Twine &Warning, const DwarfFile &File,
                    const DWARFDie *DIE = nullptr) const {
     if (Options.ErrorHandler != nullptr)
-      Options.ErrorHandler(Warning, OF.FileName, DIE);
+      Options.ErrorHandler(Warning, File.FileName, DIE);
   }
 
   /// Remembers the oldest and newest DWARF version we've seen in a unit.
   void updateDwarfVersion(unsigned Version) {
     MaxDwarfVersion = std::max(MaxDwarfVersion, Version);
     MinDwarfVersion = std::min(MinDwarfVersion, Version);
   }
 
   /// Remembers the kinds of accelerator tables we've seen in a unit.
   void updateAccelKind(DWARFContext &Dwarf);
 
   /// Emit warnings as Dwarf compile units to leave a trail after linking.
-  bool emitPaperTrailWarnings(const DwarfLinkerObjFile &OF,
+  bool emitPaperTrailWarnings(const DwarfFile &File,
                               OffsetsStringPool &StringPool);
 
-  void copyInvariantDebugSection(const object::ObjectFile &Obj);
+  void copyInvariantDebugSection(DWARFContext &Dwarf);
 
   /// Keeps track of data associated with one object during linking.
   struct LinkContext {
-    DwarfLinkerObjFile &ObjectFile;
-    std::unique_ptr<DWARFContext> DwarfContext;
+    DwarfFile &File;
     UnitListTy CompileUnits;
     bool Skip = false;
 
-    LinkContext(DwarfLinkerObjFile &objFile) : ObjectFile(objFile) {
-
-      if (ObjectFile.ObjFile)
-        DwarfContext = DWARFContext::create(*ObjectFile.ObjFile);
-    }
+    LinkContext(DwarfFile &File) : File(File) {}
 
     /// Clear part of the context that's no longer needed when we're done with
     /// the debug object.
     void clear() {
-      DwarfContext.reset(nullptr);
       CompileUnits.clear();
-      ObjectFile.Addresses->clear();
+      File.Addresses->clear();
     }
   };
 
   /// Called before emitting object data
   void cleanupAuxiliarryData(LinkContext &Context);
 
   /// Look at the parent of the given DIE and decide whether they should be
   /// kept.
   void lookForParentDIEsToKeep(unsigned AncestorIdx, CompileUnit &CU,
                                unsigned Flags,
                                SmallVectorImpl<WorklistItem> &Worklist);
 
   /// Look at the children of the given DIE and decide whether they should be
   /// kept.
   void lookForChildDIEsToKeep(const DWARFDie &Die, CompileUnit &CU,
                               unsigned Flags,
                               SmallVectorImpl<WorklistItem> &Worklist);
 
   /// Look at DIEs referenced by the given DIE and decide whether they should be
   /// kept. All DIEs referenced though attributes should be kept.
   void lookForRefDIEsToKeep(const DWARFDie &Die, CompileUnit &CU,
                             unsigned Flags, const UnitListTy &Units,
-                            const DwarfLinkerObjFile &OF,
+                            const DwarfFile &File,
                             SmallVectorImpl<WorklistItem> &Worklist);
 
   /// \defgroup FindRootDIEs Find DIEs corresponding to Address map entries.
   ///
   /// @{
   /// Recursively walk the \p DIE tree and look for DIEs to
   /// keep. Store that information in \p CU's DIEInfo.
   ///
   /// The return value indicates whether the DIE is incomplete.
   void lookForDIEsToKeep(AddressesMap &RelocMgr, RangesTy &Ranges,
                          const UnitListTy &Units, const DWARFDie &DIE,
-                         const DwarfLinkerObjFile &OF, CompileUnit &CU,
+                         const DwarfFile &File, CompileUnit &CU,
                          unsigned Flags);
 
   /// If this compile unit is really a skeleton CU that points to a
   /// clang module, register it in ClangModules and return true.
   ///
   /// A skeleton CU is a CU without children, a DW_AT_gnu_dwo_name
   /// pointing to the module, and a DW_AT_gnu_dwo_id with the module
   /// hash.
   bool registerModuleReference(DWARFDie CUDie, const DWARFUnit &Unit,
-                               const DwarfLinkerObjFile &OF,
+                               const DwarfFile &File,
                                OffsetsStringPool &OffsetsStringPool,
                                UniquingStringPool &UniquingStringPoolStringPool,
                                DeclContextTree &ODRContexts,
                                uint64_t ModulesEndOffset, unsigned &UnitID,
                                bool IsLittleEndian, unsigned Indent = 0,
                                bool Quiet = false);
 
   /// Recursively add the debug info in this clang module .pcm
   /// file (and all the modules imported by it in a bottom-up fashion)
   /// to Units.
   Error loadClangModule(DWARFDie CUDie, StringRef FilePath,
                         StringRef ModuleName, uint64_t DwoId,
-                        const DwarfLinkerObjFile &OF,
+                        const DwarfFile &File,
                         OffsetsStringPool &OffsetsStringPool,
                         UniquingStringPool &UniquingStringPool,
                         DeclContextTree &ODRContexts, uint64_t ModulesEndOffset,
                         unsigned &UnitID, bool IsLittleEndian,
                         unsigned Indent = 0, bool Quiet = false);
 
   /// Mark the passed DIE as well as all the ones it depends on as kept.
   void keepDIEAndDependencies(AddressesMap &RelocMgr, RangesTy &Ranges,
                               const UnitListTy &Units, const DWARFDie &DIE,
                               CompileUnit::DIEInfo &MyInfo,
-                              const DwarfLinkerObjFile &OF, CompileUnit &CU,
+                              const DwarfFile &File, CompileUnit &CU,
                               bool UseODR);
 
   unsigned shouldKeepDIE(AddressesMap &RelocMgr, RangesTy &Ranges,
-                         const DWARFDie &DIE, const DwarfLinkerObjFile &OF,
+                         const DWARFDie &DIE, const DwarfFile &File,
                          CompileUnit &Unit, CompileUnit::DIEInfo &MyInfo,
                          unsigned Flags);
 
   /// Check if a variable describing DIE should be kept.
   /// \returns updated TraversalFlags.
   unsigned shouldKeepVariableDIE(AddressesMap &RelocMgr, const DWARFDie &DIE,
                                  CompileUnit &Unit,
                                  CompileUnit::DIEInfo &MyInfo, unsigned Flags);
 
   unsigned shouldKeepSubprogramDIE(AddressesMap &RelocMgr, RangesTy &Ranges,
-                                   const DWARFDie &DIE,
-                                   const DwarfLinkerObjFile &OF,
+                                   const DWARFDie &DIE, const DwarfFile &File,
                                    CompileUnit &Unit,
                                    CompileUnit::DIEInfo &MyInfo,
                                    unsigned Flags);
 
   /// Resolve the DIE attribute reference that has been extracted in \p
   /// RefValue. The resulting DIE might be in another CompileUnit which is
   /// stored into \p ReferencedCU. \returns null if resolving fails for any
   /// reason.
-  DWARFDie resolveDIEReference(const DwarfLinkerObjFile &OF,
-                               const UnitListTy &Units,
+  DWARFDie resolveDIEReference(const DwarfFile &File, const UnitListTy &Units,
                                const DWARFFormValue &RefValue,
                                const DWARFDie &DIE, CompileUnit *&RefCU);
 
   /// @}
 
   /// \defgroup Methods used to link the debug information
   ///
   /// @{
 
   struct DWARFLinkerOptions;
 
   class DIECloner {
     DWARFLinker &Linker;
     DwarfEmitter *Emitter;
-    DwarfLinkerObjFile &ObjFile;
+    DwarfFile &ObjFile;
 
     /// Allocator used for all the DIEValue objects.
     BumpPtrAllocator &DIEAlloc;
 
     std::vector<std::unique_ptr<CompileUnit>> &CompileUnits;
 
     bool Update;
 
   public:
-    DIECloner(DWARFLinker &Linker, DwarfEmitter *Emitter,
-              DwarfLinkerObjFile &ObjFile, BumpPtrAllocator &DIEAlloc,
+    DIECloner(DWARFLinker &Linker, DwarfEmitter *Emitter, DwarfFile &ObjFile,
+              BumpPtrAllocator &DIEAlloc,
               std::vector<std::unique_ptr<CompileUnit>> &CompileUnits,
               bool Update)
         : Linker(Linker), Emitter(Emitter), ObjFile(ObjFile),
           DIEAlloc(DIEAlloc), CompileUnits(CompileUnits), Update(Update) {}
 
     /// Recursively clone \p InputDIE into an tree of DIE objects
     /// where useless (as decided by lookForDIEsToKeep()) bits have been
     /// stripped out and addresses have been rewritten according to the
     /// address map.
     ///
     /// \param OutOffset is the offset the cloned DIE in the output
     /// compile unit.
     /// \param PCOffset (while cloning a function scope) is the offset
     /// applied to the entry point of the function to get the linked address.
     /// \param Die the output DIE to use, pass NULL to create one.
     /// \returns the root of the cloned tree or null if nothing was selected.
-    DIE *cloneDIE(const DWARFDie &InputDIE, const DwarfLinkerObjFile &OF,
+    DIE *cloneDIE(const DWARFDie &InputDIE, const DwarfFile &File,
                   CompileUnit &U, OffsetsStringPool &StringPool,
                   int64_t PCOffset, uint32_t OutOffset, unsigned Flags,
                   bool IsLittleEndian, DIE *Die = nullptr);
 
     /// Construct the output DIE tree by cloning the DIEs we
     /// chose to keep above. If there are no valid relocs, then there's
     /// nothing to clone/emit.
-    void cloneAllCompileUnits(DWARFContext &DwarfContext,
-                              const DwarfLinkerObjFile &OF,
+    void cloneAllCompileUnits(DWARFContext &DwarfContext, const DwarfFile &File,
                               OffsetsStringPool &StringPool,
                               bool IsLittleEndian);
 
   private:
     using AttributeSpec = DWARFAbbreviationDeclaration::AttributeSpec;
 
     /// Information gathered and exchanged between the various
     /// clone*Attributes helpers about the attributes of a particular DIE.
struct AttributesInfo {
       /// Is this DIE only a declaration?
       bool IsDeclaration = false;
 
       AttributesInfo() = default;
     };
 
     /// Helper for cloneDIE.
     unsigned cloneAttribute(DIE &Die, const DWARFDie &InputDIE,
-                            const DwarfLinkerObjFile &OF, CompileUnit &U,
+                            const DwarfFile &File, CompileUnit &U,
                             OffsetsStringPool &StringPool,
                             const DWARFFormValue &Val,
                             const AttributeSpec AttrSpec, unsigned AttrSize,
                             AttributesInfo &AttrInfo, bool IsLittleEndian);
 
     /// Clone a string attribute described by \p AttrSpec and add
     /// it to \p Die.
     /// \returns the size of the new attribute.
     unsigned cloneStringAttribute(DIE &Die, AttributeSpec AttrSpec,
                                   const DWARFFormValue &Val, const DWARFUnit &U,
                                   OffsetsStringPool &StringPool,
                                   AttributesInfo &Info);
 
     /// Clone an attribute referencing another DIE and add
     /// it to \p Die.
     /// \returns the size of the new attribute.
     unsigned cloneDieReferenceAttribute(DIE &Die, const DWARFDie &InputDIE,
                                         AttributeSpec AttrSpec,
                                         unsigned AttrSize,
                                         const DWARFFormValue &Val,
-                                        const DwarfLinkerObjFile &OF,
+                                        const DwarfFile &File,
                                         CompileUnit &Unit);
 
     /// Clone a DWARF expression that may be referencing another DIE.
     void cloneExpression(DataExtractor &Data, DWARFExpression Expression,
-                         const DwarfLinkerObjFile &OF, CompileUnit &Unit,
+                         const DwarfFile &File, CompileUnit &Unit,
                          SmallVectorImpl<uint8_t> &OutputBuffer);
 
     /// Clone an attribute referencing another DIE and add
     /// it to \p Die.
     /// \returns the size of the new attribute.
-    unsigned cloneBlockAttribute(DIE &Die, const DwarfLinkerObjFile &OF,
+    unsigned cloneBlockAttribute(DIE &Die, const DwarfFile &File,
                                  CompileUnit &Unit, AttributeSpec AttrSpec,
                                  const DWARFFormValue &Val, unsigned AttrSize,
                                  bool IsLittleEndian);
 
     /// Clone an attribute referencing another DIE and add
     /// it to \p Die.
     /// \returns the size of the new attribute.
     unsigned cloneAddressAttribute(DIE &Die, AttributeSpec AttrSpec,
                                    const DWARFFormValue &Val,
                                    const CompileUnit &Unit,
                                    AttributesInfo &Info);
 
     /// Clone a scalar attribute  and add it to \p Die.
     /// \returns the size of the new attribute.
     unsigned cloneScalarAttribute(DIE &Die, const DWARFDie &InputDIE,
-                                  const DwarfLinkerObjFile &OF, CompileUnit &U,
+                                  const DwarfFile &File, CompileUnit &U,
                                   AttributeSpec AttrSpec,
                                   const DWARFFormValue &Val, unsigned AttrSize,
                                   AttributesInfo &Info);
 
     /// Get the potential name and mangled name for the entity
     /// described by \p Die and store them in \Info if they are not
     /// already there.
     /// \returns is a name was found.
     bool getDIENames(const DWARFDie &Die, AttributesInfo &Info,
                      OffsetsStringPool &StringPool, bool StripTemplate = false);
 
     /// Create a copy of abbreviation Abbrev.
     void copyAbbrev(const DWARFAbbreviationDeclaration &Abbrev, bool hasODR);
 
     uint32_t hashFullyQualifiedName(DWARFDie DIE, CompileUnit &U,
-                                    const DwarfLinkerObjFile &OF,
+                                    const DwarfFile &File,
                                     int RecurseDepth = 0);
 
     /// Helper for cloneDIE.
     void addObjCAccelerator(CompileUnit &Unit, const DIE *Die,
                             DwarfStringPoolEntryRef Name,
                             OffsetsStringPool &StringPool, bool SkipPubSection);
   };
 
   /// Assign an abbreviation number to \p Abbrev
   void assignAbbrev(DIEAbbrev &Abbrev);
 
   /// Compute and emit debug_ranges section for \p Unit, and
   /// patch the attributes referencing it.
   void patchRangesForUnit(const CompileUnit &Unit, DWARFContext &Dwarf,
-                          const DwarfLinkerObjFile &OF) const;
+                          const DwarfFile &File) const;
 
   /// Generate and emit the DW_AT_ranges attribute for a compile_unit if it had
   /// one.
   void generateUnitRanges(CompileUnit &Unit) const;
 
   /// Extract the line tables from the original dwarf, extract the relevant
   /// parts according to the linked function ranges and emit the result in the
   /// debug_line section.
   void patchLineTableForUnit(CompileUnit &Unit, DWARFContext &OrigDwarf,
-                             const DwarfLinkerObjFile &OF);
+                             const DwarfFile &File);
 
   /// Emit the accelerator entries for \p Unit.
   void emitAcceleratorEntriesForUnit(CompileUnit &Unit);
   void emitDwarfAcceleratorEntriesForUnit(CompileUnit &Unit);
   void emitAppleAcceleratorEntriesForUnit(CompileUnit &Unit);
 
   /// Patch the frame info for an object file and emit it.
-  void patchFrameInfoForObject(const DwarfLinkerObjFile &, RangesTy &Ranges,
+  void patchFrameInfoForObject(const DwarfFile &, RangesTy &Ranges,
                                DWARFContext &, unsigned AddressSize);
 
   /// FoldingSet that uniques the abbreviations.
   FoldingSet<DIEAbbrev> AbbreviationsSet;
 
   /// Storage for the unique Abbreviations.
   /// This is passed to AsmPrinter::emitDwarfAbbrevs(), thus it cannot be
   /// changed to a vector of unique_ptrs.

llvm/lib/DWARFLinker/DWARFLinker.cpp

 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFDataExtractor.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugLine.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugRangeList.h"
 #include "llvm/DebugInfo/DWARF/DWARFDie.h"
 #include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
 #include "llvm/DebugInfo/DWARF/DWARFSection.h"
 #include "llvm/DebugInfo/DWARF/DWARFUnit.h"
-#include "llvm/Object/ObjectFile.h"
 #include "llvm/Support/DataExtractor.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/ThreadPool.h"
 #include <vector>
auto CU = std::upper_bound(
         return LHS < RHS->getOrigUnit().getNextUnitOffset();
       });
   return CU != Units.end() ? CU->get() : nullptr;
 }
 
 /// Resolve the DIE attribute reference that has been extracted in \p RefValue.
 /// The resulting DIE might be in another CompileUnit which is stored into \p
 /// ReferencedCU. \returns null if resolving fails for any reason.
-DWARFDie DWARFLinker::resolveDIEReference(const DwarfLinkerObjFile &OF,
+DWARFDie DWARFLinker::resolveDIEReference(const DwarfFile &File,
                                           const UnitListTy &Units,
                                           const DWARFFormValue &RefValue,
                                           const DWARFDie &DIE,
                                           CompileUnit *&RefCU) {
   assert(RefValue.isFormClass(DWARFFormValue::FC_Reference));
   uint64_t RefOffset = *RefValue.getAsReference();
   if ((RefCU = getUnitForOffset(Units, RefOffset)))
     if (const auto RefDie = RefCU->getOrigUnit().getDIEForOffset(RefOffset)) {
       // In a file with broken references, an attribute might point to a NULL
       // DIE.
       if (!RefDie.isNULL())
         return RefDie;
     }
 
-  reportWarning("could not find referenced DIE", OF, &DIE);
+  reportWarning("could not find referenced DIE", File, &DIE);
   return DWARFDie();
 }
 
 /// \returns whether the passed \a Attr type might contain a DIE reference
 /// suitable for ODR uniquing.
 static bool isODRAttribute(uint16_t Attr) {
   switch (Attr) {
   default:
unsigned DWARFLinker::shouldKeepVariableDIE(AddressesMap &RelocMgr,
 
   return Flags | TF_Keep;
 }
 
 /// Check if a function describing DIE should be kept.
 /// \returns updated TraversalFlags.
 unsigned DWARFLinker::shouldKeepSubprogramDIE(
     AddressesMap &RelocMgr, RangesTy &Ranges, const DWARFDie &DIE,
-    const DwarfLinkerObjFile &OF, CompileUnit &Unit,
-    CompileUnit::DIEInfo &MyInfo, unsigned Flags) {
+    const DwarfFile &File, CompileUnit &Unit, CompileUnit::DIEInfo &MyInfo,
+    unsigned Flags) {
   const auto *Abbrev = DIE.getAbbreviationDeclarationPtr();
 
   Flags |= TF_InFunctionScope;
 
   Optional<uint32_t> LowPcIdx = Abbrev->findAttributeIndex(dwarf::DW_AT_low_pc);
   if (!LowPcIdx)
     return Flags;
 
if (DIE.getTag() == dwarf::DW_TAG_label) {
     Unit.addLabelLowPc(*LowPc, MyInfo.AddrAdjust);
     return Flags | TF_Keep;
   }
 
   Flags |= TF_Keep;
 
   Optional<uint64_t> HighPc = DIE.getHighPC(*LowPc);
   if (!HighPc) {
-    reportWarning("Function without high_pc. Range will be discarded.\n", OF,
+    reportWarning("Function without high_pc. Range will be discarded.\n", File,
                   &DIE);
     return Flags;
   }
 
   // Replace the debug map range with a more accurate one.
   Ranges[*LowPc] = ObjFileAddressRange(*HighPc, MyInfo.AddrAdjust);
   Unit.addFunctionRange(*LowPc, *HighPc, MyInfo.AddrAdjust);
   return Flags;
 }
 
 /// Check if a DIE should be kept.
 /// \returns updated TraversalFlags.
 unsigned DWARFLinker::shouldKeepDIE(AddressesMap &RelocMgr, RangesTy &Ranges,
-                                    const DWARFDie &DIE,
-                                    const DwarfLinkerObjFile &OF,
+                                    const DWARFDie &DIE, const DwarfFile &File,
                                     CompileUnit &Unit,
                                     CompileUnit::DIEInfo &MyInfo,
                                     unsigned Flags) {
   switch (DIE.getTag()) {
   case dwarf::DW_TAG_constant:
   case dwarf::DW_TAG_variable:
     return shouldKeepVariableDIE(RelocMgr, DIE, Unit, MyInfo, Flags);
   case dwarf::DW_TAG_subprogram:
   case dwarf::DW_TAG_label:
-    return shouldKeepSubprogramDIE(RelocMgr, Ranges, DIE, OF, Unit, MyInfo,
+    return shouldKeepSubprogramDIE(RelocMgr, Ranges, DIE, File, Unit, MyInfo,
                                    Flags);
   case dwarf::DW_TAG_base_type:
     // DWARF Expressions may reference basic types, but scanning them
     // is expensive. Basic types are tiny, so just keep all of them.
   case dwarf::DW_TAG_imported_module:
   case dwarf::DW_TAG_imported_declaration:
   case dwarf::DW_TAG_imported_unit:
     // We always want to keep these.
for (auto Child : reverse(Die.children())) {
     Worklist.emplace_back(Child, CU, Flags);
   }
 }
 
 /// Look at DIEs referenced by the given DIE and decide whether they should be
 /// kept. All DIEs referenced though attributes should be kept.
 void DWARFLinker::lookForRefDIEsToKeep(
     const DWARFDie &Die, CompileUnit &CU, unsigned Flags,
-    const UnitListTy &Units, const DwarfLinkerObjFile &OF,
+    const UnitListTy &Units, const DwarfFile &File,
     SmallVectorImpl<WorklistItem> &Worklist) {
   bool UseOdr = (Flags & DWARFLinker::TF_DependencyWalk)
                     ? (Flags & DWARFLinker::TF_ODR)
                     : CU.hasODR();
   DWARFUnit &Unit = CU.getOrigUnit();
   DWARFDataExtractor Data = Unit.getDebugInfoExtractor();
   const auto *Abbrev = Die.getAbbreviationDeclarationPtr();
   uint64_t Offset = Die.getOffset() + getULEB128Size(Abbrev->getCode());
 
   SmallVector<std::pair<DWARFDie, CompileUnit &>, 4> ReferencedDIEs;
   for (const auto &AttrSpec : Abbrev->attributes()) {
     DWARFFormValue Val(AttrSpec.Form);
     if (!Val.isFormClass(DWARFFormValue::FC_Reference) ||
         AttrSpec.Attr == dwarf::DW_AT_sibling) {
       DWARFFormValue::skipValue(AttrSpec.Form, Data, &Offset,
                                 Unit.getFormParams());
       continue;
     }
 
     Val.extractValue(Data, &Offset, Unit.getFormParams(), &Unit);
     CompileUnit *ReferencedCU;
-    if (auto RefDie = resolveDIEReference(OF, Units, Val, Die, ReferencedCU)) {
+    if (auto RefDie =
+            resolveDIEReference(File, Units, Val, Die, ReferencedCU)) {
       uint32_t RefIdx = ReferencedCU->getOrigUnit().getDIEIndex(RefDie);
       CompileUnit::DIEInfo &Info = ReferencedCU->getInfo(RefIdx);
       bool IsModuleRef = Info.Ctxt && Info.Ctxt->getCanonicalDIEOffset() &&
                          Info.Ctxt->isDefinedInClangModule();
       // If the referenced DIE has a DeclContext that has already been
       // emitted, then do not keep the one in this CU. We'll link to
       // the canonical DIE in cloneDieReferenceAttribute.
       //

 /// algorithm (LookForDIEsToKeep) followed by either looking at more DIEs
 /// (LookForChildDIEsToKeep, LookForRefDIEsToKeep, LookForParentDIEsToKeep) or
 /// fixing up a computed property (UpdateChildIncompleteness,
 /// UpdateRefIncompleteness).
 ///
 /// The return value indicates whether the DIE is incomplete.
 void DWARFLinker::lookForDIEsToKeep(AddressesMap &AddressesMap,
                                     RangesTy &Ranges, const UnitListTy &Units,
-                                    const DWARFDie &Die,
-                                    const DwarfLinkerObjFile &OF,
+                                    const DWARFDie &Die, const DwarfFile &File,
                                     CompileUnit &Cu, unsigned Flags) {
   // LIFO work list.
   SmallVector<WorklistItem, 4> Worklist;
   Worklist.emplace_back(Die, Cu, Flags);
 
   while (!Worklist.empty()) {
     WorklistItem Current = Worklist.back();
     Worklist.pop_back();
 
     // Look at the worklist type to decide what kind of work to perform.
     switch (Current.Type) {
     case WorklistItemType::UpdateChildIncompleteness:
       updateChildIncompleteness(Current.Die, Current.CU, *Current.OtherInfo);
       continue;
     case WorklistItemType::UpdateRefIncompleteness:
       updateRefIncompleteness(Current.Die, Current.CU, *Current.OtherInfo);
       continue;
     case WorklistItemType::LookForChildDIEsToKeep:
       lookForChildDIEsToKeep(Current.Die, Current.CU, Current.Flags, Worklist);
       continue;
     case WorklistItemType::LookForRefDIEsToKeep:
-      lookForRefDIEsToKeep(Current.Die, Current.CU, Current.Flags, Units, OF,
+      lookForRefDIEsToKeep(Current.Die, Current.CU, Current.Flags, Units, File,
                            Worklist);
       continue;
     case WorklistItemType::LookForParentDIEsToKeep:
       lookForParentDIEsToKeep(Current.AncestorIdx, Current.CU, Current.Flags,
                               Worklist);
       continue;
     case WorklistItemType::LookForDIEsToKeep:
       break;
while (!Worklist.empty()) {
     // If our target is already marked as kept, we're all set.
     bool AlreadyKept = MyInfo.Keep;
     if ((Current.Flags & TF_DependencyWalk) && AlreadyKept)
       continue;
 
     // We must not call shouldKeepDIE while called from keepDIEAndDependencies,
     // because it would screw up the relocation finding logic.
     if (!(Current.Flags & TF_DependencyWalk))
-      Current.Flags = shouldKeepDIE(AddressesMap, Ranges, Current.Die, OF,
+      Current.Flags = shouldKeepDIE(AddressesMap, Ranges, Current.Die, File,
                                     Current.CU, MyInfo, Current.Flags);
 
     // Finish by looking for child DIEs. Because of the LIFO worklist we need
     // to schedule that work before any subsequent items are added to the
     // worklist.
     Worklist.emplace_back(Current.Die, Current.CU, Current.Flags,
                           WorklistItemType::LookForChildDIEsToKeep);
 
unsigned DWARFLinker::DIECloner::cloneStringAttribute(
   Die.addValue(DIEAlloc, dwarf::Attribute(AttrSpec.Attr), dwarf::DW_FORM_strp,
                DIEInteger(StringEntry.getOffset()));
 
   return 4;
 }
 
 unsigned DWARFLinker::DIECloner::cloneDieReferenceAttribute(
     DIE &Die, const DWARFDie &InputDIE, AttributeSpec AttrSpec,
-    unsigned AttrSize, const DWARFFormValue &Val, const DwarfLinkerObjFile &OF,
+    unsigned AttrSize, const DWARFFormValue &Val, const DwarfFile &File,
     CompileUnit &Unit) {
   const DWARFUnit &U = Unit.getOrigUnit();
   uint64_t Ref = *Val.getAsReference();
 
   DIE *NewRefDie = nullptr;
   CompileUnit *RefUnit = nullptr;
   DeclContext *Ctxt = nullptr;
 
   DWARFDie RefDie =
-      Linker.resolveDIEReference(OF, CompileUnits, Val, InputDIE, RefUnit);
+      Linker.resolveDIEReference(File, CompileUnits, Val, InputDIE, RefUnit);
 
   // If the referenced DIE is not found,  drop the attribute.
   if (!RefDie || AttrSpec.Attr == dwarf::DW_AT_sibling)
     return 0;
 
   unsigned Idx = RefUnit->getOrigUnit().getDIEIndex(RefDie);
   CompileUnit::DIEInfo &RefInfo = RefUnit->getInfo(Idx);
 
unsigned DWARFLinker::DIECloner::cloneDieReferenceAttribute(
 
   Die.addValue(DIEAlloc, dwarf::Attribute(AttrSpec.Attr),
                dwarf::Form(AttrSpec.Form), DIEEntry(*NewRefDie));
 
   return AttrSize;
 }
 
 void DWARFLinker::DIECloner::cloneExpression(
-    DataExtractor &Data, DWARFExpression Expression,
-    const DwarfLinkerObjFile &OF, CompileUnit &Unit,
-    SmallVectorImpl<uint8_t> &OutputBuffer) {
+    DataExtractor &Data, DWARFExpression Expression, const DwarfFile &File,
+    CompileUnit &Unit, SmallVectorImpl<uint8_t> &OutputBuffer) {
   using Encoding = DWARFExpression::Operation::Encoding;
 
   uint64_t OpOffset = 0;
   for (auto &Op : Expression) {
     auto Description = Op.getDescription();
     // DW_OP_const_type is variable-length and has 3
     // operands. DWARFExpression thus far only supports 2.
     auto Op0 = Description.Op[0];
     auto Op1 = Description.Op[1];
     if ((Op0 == Encoding::BaseTypeRef && Op1 != Encoding::SizeNA) ||
         (Op1 == Encoding::BaseTypeRef && Op0 != Encoding::Size1))
-      Linker.reportWarning("Unsupported DW_OP encoding.", OF);
+      Linker.reportWarning("Unsupported DW_OP encoding.", File);
 
     if ((Op0 == Encoding::BaseTypeRef && Op1 == Encoding::SizeNA) ||
         (Op1 == Encoding::BaseTypeRef && Op0 == Encoding::Size1)) {
       // This code assumes that the other non-typeref operand fits into 1 byte.
       assert(OpOffset < Op.getEndOffset());
       uint32_t ULEBsize = Op.getEndOffset() - OpOffset - 1;
       assert(ULEBsize <= 16);
 
if ((Op0 == Encoding::BaseTypeRef && Op1 == Encoding::SizeNA) ||
       auto RefDie = Unit.getOrigUnit().getDIEForOffset(RefOffset);
       uint32_t RefIdx = Unit.getOrigUnit().getDIEIndex(RefDie);
       CompileUnit::DIEInfo &Info = Unit.getInfo(RefIdx);
       uint32_t Offset = 0;
       if (DIE *Clone = Info.Clone)
         Offset = Clone->getOffset();
       else
         Linker.reportWarning("base type ref doesn't point to DW_TAG_base_type.",
-                             OF);
+                             File);
       uint8_t ULEB[16];
       unsigned RealSize = encodeULEB128(Offset, ULEB, ULEBsize);
       if (RealSize > ULEBsize) {
         // Emit the generic type as a fallback.
         RealSize = encodeULEB128(0, ULEB, ULEBsize);
-        Linker.reportWarning("base type ref doesn't fit.", OF);
+        Linker.reportWarning("base type ref doesn't fit.", File);
       }
       assert(RealSize == ULEBsize && "padding failed");
       ArrayRef<uint8_t> ULEBbytes(ULEB, ULEBsize);
       OutputBuffer.append(ULEBbytes.begin(), ULEBbytes.end());
     } else {
       // Copy over everything else unmodified.
       StringRef Bytes = Data.getData().slice(OpOffset, Op.getEndOffset());
       OutputBuffer.append(Bytes.begin(), Bytes.end());
     }
     OpOffset = Op.getEndOffset();
   }
 }
 
 unsigned DWARFLinker::DIECloner::cloneBlockAttribute(
-    DIE &Die, const DwarfLinkerObjFile &OF, CompileUnit &Unit,
-    AttributeSpec AttrSpec, const DWARFFormValue &Val, unsigned AttrSize,
-    bool IsLittleEndian) {
+    DIE &Die, const DwarfFile &File, CompileUnit &Unit, AttributeSpec AttrSpec,
+    const DWARFFormValue &Val, unsigned AttrSize, bool IsLittleEndian) {
   DIEValueList *Attr;
   DIEValue Value;
   DIELoc *Loc = nullptr;
   DIEBlock *Block = nullptr;
   if (AttrSpec.Form == dwarf::DW_FORM_exprloc) {
     Loc = new (DIEAlloc) DIELoc;
     Linker.DIELocs.push_back(Loc);
   } else {
unsigned DWARFLinker::DIECloner::cloneBlockAttribute(
   ArrayRef<uint8_t> Bytes = *Val.getAsBlock();
   if (DWARFAttribute::mayHaveLocationDescription(AttrSpec.Attr) &&
       (Val.isFormClass(DWARFFormValue::FC_Block) ||
        Val.isFormClass(DWARFFormValue::FC_Exprloc))) {
     DWARFUnit &OrigUnit = Unit.getOrigUnit();
     DataExtractor Data(StringRef((const char *)Bytes.data(), Bytes.size()),
                        IsLittleEndian, OrigUnit.getAddressByteSize());
     DWARFExpression Expr(Data, OrigUnit.getAddressByteSize());
-    cloneExpression(Data, Expr, OF, Unit, Buffer);
+    cloneExpression(Data, Expr, File, Unit, Buffer);
     Bytes = Buffer;
   }
   for (auto Byte : Bytes)
     Attr->addValue(DIEAlloc, static_cast<dwarf::Attribute>(0),
                    dwarf::DW_FORM_data1, DIEInteger(Byte));
 
   // FIXME: If DIEBlock and DIELoc just reuses the Size field of
   // the DIE class, this "if" could be replaced by
unsigned DWARFLinker::DIECloner::cloneAddressAttribute(
   }
 
   Die.addValue(DIEAlloc, static_cast<dwarf::Attribute>(AttrSpec.Attr),
                static_cast<dwarf::Form>(AttrSpec.Form), DIEInteger(Addr));
   return Unit.getOrigUnit().getAddressByteSize();
 }
 
 unsigned DWARFLinker::DIECloner::cloneScalarAttribute(
-    DIE &Die, const DWARFDie &InputDIE, const DwarfLinkerObjFile &OF,
+    DIE &Die, const DWARFDie &InputDIE, const DwarfFile &File,
     CompileUnit &Unit, AttributeSpec AttrSpec, const DWARFFormValue &Val,
     unsigned AttrSize, AttributesInfo &Info) {
   uint64_t Value;
 
   if (LLVM_UNLIKELY(Linker.Options.Update)) {
     if (auto OptionalValue = Val.getAsUnsignedConstant())
       Value = *OptionalValue;
     else if (auto OptionalValue = Val.getAsSignedConstant())
       Value = *OptionalValue;
     else if (auto OptionalValue = Val.getAsSectionOffset())
       Value = *OptionalValue;
     else {
       Linker.reportWarning(
-          "Unsupported scalar attribute form. Dropping attribute.", OF,
+          "Unsupported scalar attribute form. Dropping attribute.", File,
           &InputDIE);
       return 0;
     }
     if (AttrSpec.Attr == dwarf::DW_AT_declaration && Value)
       Info.IsDeclaration = true;
     Die.addValue(DIEAlloc, dwarf::Attribute(AttrSpec.Attr),
                  dwarf::Form(AttrSpec.Form), DIEInteger(Value));
     return AttrSize;
   }
 
   if (AttrSpec.Attr == dwarf::DW_AT_high_pc &&
       Die.getTag() == dwarf::DW_TAG_compile_unit) {
     if (Unit.getLowPc() == -1ULL)
       return 0;
     // Dwarf >= 4 high_pc is an size, not an address.
     Value = Unit.getHighPc() - Unit.getLowPc();
   } else if (AttrSpec.Form == dwarf::DW_FORM_sec_offset)
     Value = *Val.getAsSectionOffset();
   else if (AttrSpec.Form == dwarf::DW_FORM_sdata)
     Value = *Val.getAsSignedConstant();
   else if (auto OptionalValue = Val.getAsUnsignedConstant())
     Value = *OptionalValue;
   else {
     Linker.reportWarning(
-        "Unsupported scalar attribute form. Dropping attribute.", OF,
+        "Unsupported scalar attribute form. Dropping attribute.", File,
         &InputDIE);
     return 0;
   }
   PatchLocation Patch =
       Die.addValue(DIEAlloc, dwarf::Attribute(AttrSpec.Attr),
                    dwarf::Form(AttrSpec.Form), DIEInteger(Value));
   if (AttrSpec.Attr == dwarf::DW_AT_ranges) {
     Unit.noteRangeAttribute(Die, Patch);
unsigned DWARFLinker::DIECloner::cloneScalarAttribute(
 
   return AttrSize;
 }
 
 /// Clone \p InputDIE's attribute described by \p AttrSpec with
 /// value \p Val, and add it to \p Die.
 /// \returns the size of the cloned attribute.
 unsigned DWARFLinker::DIECloner::cloneAttribute(
-    DIE &Die, const DWARFDie &InputDIE, const DwarfLinkerObjFile &OF,
+    DIE &Die, const DWARFDie &InputDIE, const DwarfFile &File,
     CompileUnit &Unit, OffsetsStringPool &StringPool, const DWARFFormValue &Val,
     const AttributeSpec AttrSpec, unsigned AttrSize, AttributesInfo &Info,
     bool IsLittleEndian) {
   const DWARFUnit &U = Unit.getOrigUnit();
 
   switch (AttrSpec.Form) {
   case dwarf::DW_FORM_strp:
   case dwarf::DW_FORM_string:
     return cloneStringAttribute(Die, AttrSpec, Val, U, StringPool, Info);
   case dwarf::DW_FORM_ref_addr:
   case dwarf::DW_FORM_ref1:
   case dwarf::DW_FORM_ref2:
   case dwarf::DW_FORM_ref4:
   case dwarf::DW_FORM_ref8:
     return cloneDieReferenceAttribute(Die, InputDIE, AttrSpec, AttrSize, Val,
-                                      OF, Unit);
+                                      File, Unit);
   case dwarf::DW_FORM_block:
   case dwarf::DW_FORM_block1:
   case dwarf::DW_FORM_block2:
   case dwarf::DW_FORM_block4:
   case dwarf::DW_FORM_exprloc:
-    return cloneBlockAttribute(Die, OF, Unit, AttrSpec, Val, AttrSize,
+    return cloneBlockAttribute(Die, File, Unit, AttrSpec, Val, AttrSize,
                                IsLittleEndian);
   case dwarf::DW_FORM_addr:
     return cloneAddressAttribute(Die, AttrSpec, Val, Unit, Info);
   case dwarf::DW_FORM_data1:
   case dwarf::DW_FORM_data2:
   case dwarf::DW_FORM_data4:
   case dwarf::DW_FORM_data8:
   case dwarf::DW_FORM_udata:
   case dwarf::DW_FORM_sdata:
   case dwarf::DW_FORM_sec_offset:
   case dwarf::DW_FORM_flag:
   case dwarf::DW_FORM_flag_present:
-    return cloneScalarAttribute(Die, InputDIE, OF, Unit, AttrSpec, Val,
+    return cloneScalarAttribute(Die, InputDIE, File, Unit, AttrSpec, Val,
                                 AttrSize, Info);
   default:
     Linker.reportWarning(
-        "Unsupported attribute form in cloneAttribute. Dropping.", OF,
+        "Unsupported attribute form in cloneAttribute. Dropping.", File,
         &InputDIE);
   }
 
   return 0;
 }
 
 static bool isObjCSelector(StringRef Name) {
   return Name.size() > 2 && (Name[0] == '-' || Name[0] == '+') &&
case dwarf::DW_AT_frame_base:
     // harmless for locals, but there is no point in keeping these anyway when
     // the function wasn't linked.
     return (SkipPC || (!InFunctionScope && Tag == dwarf::DW_TAG_variable &&
                        !InDebugMap)) &&
            !DWARFFormValue(AttrSpec.Form).isFormClass(DWARFFormValue::FC_Block);
   }
 }
 
-DIE *DWARFLinker::DIECloner::cloneDIE(
-    const DWARFDie &InputDIE, const DwarfLinkerObjFile &OF, CompileUnit &Unit,
-    OffsetsStringPool &StringPool, int64_t PCOffset, uint32_t OutOffset,
-    unsigned Flags, bool IsLittleEndian, DIE *Die) {
+DIE *DWARFLinker::DIECloner::cloneDIE(const DWARFDie &InputDIE,
+                                      const DwarfFile &File, CompileUnit &Unit,
+                                      OffsetsStringPool &StringPool,
+                                      int64_t PCOffset, uint32_t OutOffset,
+                                      unsigned Flags, bool IsLittleEndian,
+                                      DIE *Die) {
   DWARFUnit &U = Unit.getOrigUnit();
   unsigned Idx = U.getDIEIndex(InputDIE);
   CompileUnit::DIEInfo &Info = Unit.getInfo(Idx);
 
   // Should the DIE appear in the output?
   if (!Unit.getInfo(Idx).Keep)
     return nullptr;
 
if (LLVM_LIKELY(!Update) &&
       continue;
     }
 
     DWARFFormValue Val(AttrSpec.Form);
     uint64_t AttrSize = Offset;
     Val.extractValue(Data, &Offset, U.getFormParams(), &U);
     AttrSize = Offset - AttrSize;
 
-    OutOffset += cloneAttribute(*Die, InputDIE, OF, Unit, StringPool, Val,
+    OutOffset += cloneAttribute(*Die, InputDIE, File, Unit, StringPool, Val,
                                 AttrSpec, AttrSize, AttrInfo, IsLittleEndian);
   }
 
   // Look for accelerator entries.
   uint16_t Tag = InputDIE.getTag();
   // FIXME: This is slightly wrong. An inline_subroutine without a
   // low_pc, but with AT_ranges might be interesting to get into the
   // accelerator tables too. For now stick with dsymutil's behavior.
DIE *DWARFLinker::DIECloner::cloneDIE(const DWARFDie &InputDIE,
 
   } else if (Tag == dwarf::DW_TAG_namespace) {
     if (!AttrInfo.Name)
       AttrInfo.Name = StringPool.getEntry("(anonymous namespace)");
     Unit.addNamespaceAccelerator(Die, AttrInfo.Name);
   } else if (isTypeTag(Tag) && !AttrInfo.IsDeclaration &&
              getDIENames(InputDIE, AttrInfo, StringPool) && AttrInfo.Name &&
              AttrInfo.Name.getString()[0]) {
-    uint32_t Hash = hashFullyQualifiedName(InputDIE, Unit, OF);
+    uint32_t Hash = hashFullyQualifiedName(InputDIE, Unit, File);
     uint64_t RuntimeLang =
         dwarf::toUnsigned(InputDIE.find(dwarf::DW_AT_APPLE_runtime_class))
             .getValueOr(0);
     bool ObjCClassIsImplementation =
         (RuntimeLang == dwarf::DW_LANG_ObjC ||
          RuntimeLang == dwarf::DW_LANG_ObjC_plus_plus) &&
         dwarf::toUnsigned(InputDIE.find(dwarf::DW_AT_APPLE_objc_complete_type))
             .getValueOr(0);
DIE *DWARFLinker::DIECloner::cloneDIE(const DWARFDie &InputDIE,
   if (!HasChildren) {
     // Update our size.
     Die->setSize(OutOffset - Die->getOffset());
     return Die;
   }
 
   // Recursively clone children.
   for (auto Child : InputDIE.children()) {
-    if (DIE *Clone = cloneDIE(Child, OF, Unit, StringPool, PCOffset, OutOffset,
-                              Flags, IsLittleEndian)) {
+    if (DIE *Clone = cloneDIE(Child, File, Unit, StringPool, PCOffset,
+                              OutOffset, Flags, IsLittleEndian)) {
       Die->addChild(Clone);
       OutOffset = Clone->getOffset() + Clone->getSize();
     }
   }
 
   // Account for the end of children marker.
   OutOffset += sizeof(int8_t);
   // Update our size.
   Die->setSize(OutOffset - Die->getOffset());
   return Die;
 }
 
 /// Patch the input object file relevant debug_ranges entries
 /// and emit them in the output file. Update the relevant attributes
 /// to point at the new entries.
 void DWARFLinker::patchRangesForUnit(const CompileUnit &Unit,
                                      DWARFContext &OrigDwarf,
-                                     const DwarfLinkerObjFile &OF) const {
+                                     const DwarfFile &File) const {
   DWARFDebugRangeList RangeList;
   const auto &FunctionRanges = Unit.getFunctionRanges();
   unsigned AddressSize = Unit.getOrigUnit().getAddressByteSize();
   DWARFDataExtractor RangeExtractor(OrigDwarf.getDWARFObj(),
                                     OrigDwarf.getDWARFObj().getRangesSection(),
                                     OrigDwarf.isLittleEndian(), AddressSize);
   auto InvalidRange = FunctionRanges.end(), CurrRange = InvalidRange;
   DWARFUnit &OrigUnit = Unit.getOrigUnit();
   auto OrigUnitDie = OrigUnit.getUnitDIE(false);
   uint64_t OrigLowPc =
       dwarf::toAddress(OrigUnitDie.find(dwarf::DW_AT_low_pc), -1ULL);
   // Ranges addresses are based on the unit's low_pc. Compute the
   // offset we need to apply to adapt to the new unit's low_pc.
   int64_t UnitPcOffset = 0;
   if (OrigLowPc != -1ULL)
     UnitPcOffset = int64_t(OrigLowPc) - Unit.getLowPc();
 
   for (const auto &RangeAttribute : Unit.getRangesAttributes()) {
     uint64_t Offset = RangeAttribute.get();
     RangeAttribute.set(TheDwarfEmitter->getRangesSectionSize());
     if (Error E = RangeList.extract(RangeExtractor, &Offset)) {
       llvm::consumeError(std::move(E));
-      reportWarning("invalid range list ignored.", OF);
+      reportWarning("invalid range list ignored.", File);
       RangeList.clear();
     }
     const auto &Entries = RangeList.getEntries();
     if (!Entries.empty()) {
       const DWARFDebugRangeList::RangeListEntry &First = Entries.front();
 
       if (CurrRange == InvalidRange ||
           First.StartAddress + OrigLowPc < CurrRange.start() ||
           First.StartAddress + OrigLowPc >= CurrRange.stop()) {
         CurrRange = FunctionRanges.find(First.StartAddress + OrigLowPc);
         if (CurrRange == InvalidRange ||
             CurrRange.start() > First.StartAddress + OrigLowPc) {
-          reportWarning("no mapping for range.", OF);
+          reportWarning("no mapping for range.", File);
           continue;
         }
       }
     }
 
     TheDwarfEmitter->emitRangesEntries(UnitPcOffset, OrigLowPc, CurrRange,
                                        Entries, AddressSize);
   }
static void patchStmtList(DIE &Die, DIEInteger Offset) {
   llvm_unreachable("Didn't find DW_AT_stmt_list in cloned DIE!");
 }
 
 /// Extract the line table for \p Unit from \p OrigDwarf, and
 /// recreate a relocated version of these for the address ranges that
 /// are present in the binary.
 void DWARFLinker::patchLineTableForUnit(CompileUnit &Unit,
                                         DWARFContext &OrigDwarf,
-                                        const DwarfLinkerObjFile &OF) {
+                                        const DwarfFile &File) {
   DWARFDie CUDie = Unit.getOrigUnit().getUnitDIE();
   auto StmtList = dwarf::toSectionOffset(CUDie.find(dwarf::DW_AT_stmt_list));
   if (!StmtList)
     return;
 
   // Update the cloned DW_AT_stmt_list with the correct debug_line offset.
   if (auto *OutputDIE = Unit.getOutputUnitDIE())
     patchStmtList(*OutputDIE,
                   DIEInteger(TheDwarfEmitter->getLineSectionSize()));
 
-  RangesTy &Ranges = OF.Addresses->getValidAddressRanges();
+  RangesTy &Ranges = File.Addresses->getValidAddressRanges();
 
   // Parse the original line info for the unit.
   DWARFDebugLine::LineTable LineTable;
   uint64_t StmtOffset = *StmtList;
   DWARFDataExtractor LineExtractor(
       OrigDwarf.getDWARFObj(), OrigDwarf.getDWARFObj().getLineSection(),
       OrigDwarf.isLittleEndian(), Unit.getOrigUnit().getAddressByteSize());
   if (needToTranslateStrings())
void DWARFLinker::patchLineTableForUnit(CompileUnit &Unit,
   // FIXME: LLVM hard-codes its prologue values. We just copy the
   // prologue over and that works because we act as both producer and
   // consumer. It would be nicer to have a real configurable line
   // table emitter.
   if (LineTable.Prologue.getVersion() < 2 ||
       LineTable.Prologue.getVersion() > 5 ||
       LineTable.Prologue.DefaultIsStmt != DWARF2_LINE_DEFAULT_IS_STMT ||
       LineTable.Prologue.OpcodeBase > 13)
-    reportWarning("line table parameters mismatch. Cannot emit.", OF);
+    reportWarning("line table parameters mismatch. Cannot emit.", File);
   else {
     uint32_t PrologueEnd = *StmtList + 10 + LineTable.Prologue.PrologueLength;
     // DWARF v5 has an extra 2 bytes of information before the header_length
     // field.
     if (LineTable.Prologue.getVersion() == 5)
       PrologueEnd += 2;
     StringRef LineData = OrigDwarf.getDWARFObj().getLineSection().Data;
     MCDwarfLineTableParams Params;

 }
 
 /// Read the frame info stored in the object, and emit the
 /// patched frame descriptions for the resulting file.
 ///
 /// This is actually pretty easy as the data of the CIEs and FDEs can
 /// be considered as black boxes and moved as is. The only thing to do
 /// is to patch the addresses in the headers.
-void DWARFLinker::patchFrameInfoForObject(const DwarfLinkerObjFile &OF,
+void DWARFLinker::patchFrameInfoForObject(const DwarfFile &File,
                                           RangesTy &Ranges,
                                           DWARFContext &OrigDwarf,
                                           unsigned AddrSize) {
   StringRef FrameData = OrigDwarf.getDWARFObj().getFrameSection().Data;
   if (FrameData.empty())
     return;
 
   DataExtractor Data(FrameData, OrigDwarf.isLittleEndian(), 0);
   uint64_t InputOffset = 0;
 
   // Store the data of the CIEs defined in this object, keyed by their
   // offsets.
   DenseMap<uint64_t, StringRef> LocalCIES;
 
   while (Data.isValidOffset(InputOffset)) {
     uint64_t EntryOffset = InputOffset;
     uint32_t InitialLength = Data.getU32(&InputOffset);
     if (InitialLength == 0xFFFFFFFF)
-      return reportWarning("Dwarf64 bits no supported", OF);
+      return reportWarning("Dwarf64 bits no supported", File);
 
     uint32_t CIEId = Data.getU32(&InputOffset);
     if (CIEId == 0xFFFFFFFF) {
       // This is a CIE, store it.
       StringRef CIEData = FrameData.substr(EntryOffset, InitialLength + 4);
       LocalCIES[EntryOffset] = CIEData;
       // The -4 is to account for the CIEId we just read.
       InputOffset += InitialLength - 4;
if (Range == Ranges.end() || Range->first > Loc ||
       InputOffset = EntryOffset + InitialLength + 4;
       continue;
     }
 
     // This is an FDE, and we have a mapping.
     // Have we already emitted a corresponding CIE?
     StringRef CIEData = LocalCIES[CIEId];
     if (CIEData.empty())
-      return reportWarning("Inconsistent debug_frame content. Dropping.", OF);
+      return reportWarning("Inconsistent debug_frame content. Dropping.", File);
 
     // Look if we already emitted a CIE that corresponds to the
     // referenced one (the CIE data is the key of that lookup).
     auto IteratorInserted = EmittedCIEs.insert(
         std::make_pair(CIEData, TheDwarfEmitter->getFrameSectionSize()));
     // If there is no CIE yet for this ID, emit it.
     if (IteratorInserted.second ||
         // FIXME: dsymutil-classic only caches the last used CIE for
for (const auto &Attr : Abbrev.attributes()) {
     if (HasODR && isODRAttribute(Attr.Attr))
       Form = dwarf::DW_FORM_ref_addr;
     Copy.AddAttribute(dwarf::Attribute(Attr.Attr), dwarf::Form(Form));
   }
 
   Linker.assignAbbrev(Copy);
 }
 
-uint32_t
-DWARFLinker::DIECloner::hashFullyQualifiedName(DWARFDie DIE, CompileUnit &U,
-                                               const DwarfLinkerObjFile &OF,
+uint32_t DWARFLinker::DIECloner::hashFullyQualifiedName(DWARFDie DIE,
+                                                        CompileUnit &U,
+                                                        const DwarfFile &File,
                                                         int ChildRecurseDepth) {
   const char *Name = nullptr;
   DWARFUnit *OrigUnit = &U.getOrigUnit();
   CompileUnit *CU = &U;
   Optional<DWARFFormValue> Ref;
 
   while (1) {
     if (const char *CurrentName = DIE.getName(DINameKind::ShortName))
       Name = CurrentName;
 
     if (!(Ref = DIE.find(dwarf::DW_AT_specification)) &&
         !(Ref = DIE.find(dwarf::DW_AT_abstract_origin)))
       break;
 
     if (!Ref->isFormClass(DWARFFormValue::FC_Reference))
       break;
 
     CompileUnit *RefCU;
     if (auto RefDIE =
-            Linker.resolveDIEReference(OF, CompileUnits, *Ref, DIE, RefCU)) {
+            Linker.resolveDIEReference(File, CompileUnits, *Ref, DIE, RefCU)) {
       CU = RefCU;
       OrigUnit = &RefCU->getOrigUnit();
       DIE = RefDIE;
     }
   }
 
   unsigned Idx = OrigUnit->getDIEIndex(DIE);
   if (!Name && DIE.getTag() == dwarf::DW_TAG_namespace)
     Name = "(anonymous namespace)";
 
   if (CU->getInfo(Idx).ParentIdx == 0 ||
       // FIXME: dsymutil-classic compatibility. Ignore modules.
       CU->getOrigUnit().getDIEAtIndex(CU->getInfo(Idx).ParentIdx).getTag() ==
           dwarf::DW_TAG_module)
     return djbHash(Name ? Name : "", djbHash(ChildRecurseDepth ? "" : "::"));
 
   DWARFDie Die = OrigUnit->getDIEAtIndex(CU->getInfo(Idx).ParentIdx);
   return djbHash(
       (Name ? Name : ""),
       djbHash((Name ? "::" : ""),
-              hashFullyQualifiedName(Die, *CU, OF, ++ChildRecurseDepth)));
+              hashFullyQualifiedName(Die, *CU, File, ++ChildRecurseDepth)));
 }
 
 static uint64_t getDwoId(const DWARFDie &CUDie, const DWARFUnit &Unit) {
   auto DwoId = dwarf::toUnsigned(
       CUDie.find({dwarf::DW_AT_dwo_id, dwarf::DW_AT_GNU_dwo_id}));
   if (DwoId)
     return *DwoId;
   return 0;
 }
 
 bool DWARFLinker::registerModuleReference(
-    DWARFDie CUDie, const DWARFUnit &Unit, const DwarfLinkerObjFile &OF,
+    DWARFDie CUDie, const DWARFUnit &Unit, const DwarfFile &File,
     OffsetsStringPool &StringPool, UniquingStringPool &UniquingStringPool,
     DeclContextTree &ODRContexts, uint64_t ModulesEndOffset, unsigned &UnitID,
     bool IsLittleEndian, unsigned Indent, bool Quiet) {
   std::string PCMfile = dwarf::toString(
       CUDie.find({dwarf::DW_AT_dwo_name, dwarf::DW_AT_GNU_dwo_name}), "");
   if (PCMfile.empty())
     return false;
 
   // Clang module DWARF skeleton CUs abuse this for the path to the module.
   uint64_t DwoId = getDwoId(CUDie, Unit);
 
   std::string Name = dwarf::toString(CUDie.find(dwarf::DW_AT_name), "");
   if (Name.empty()) {
     if (!Quiet)
-      reportWarning("Anonymous module skeleton CU for " + PCMfile, OF);
+      reportWarning("Anonymous module skeleton CU for " + PCMfile, File);
     return true;
   }
 
   if (!Quiet && Options.Verbose) {
     outs().indent(Indent);
     outs() << "Found clang module reference " << PCMfile;
   }
 
   auto Cached = ClangModules.find(PCMfile);
   if (Cached != ClangModules.end()) {
     // FIXME: Until PR27449 (https://llvm.org/bugs/show_bug.cgi?id=27449) is
     // fixed in clang, only warn about DWO_id mismatches in verbose mode.
     // ASTFileSignatures will change randomly when a module is rebuilt.
     if (!Quiet && Options.Verbose && (Cached->second != DwoId))
       reportWarning(Twine("hash mismatch: this object file was built against a "
                           "different version of the module ") +
                         PCMfile,
-                    OF);
+                    File);
     if (!Quiet && Options.Verbose)
       outs() << " [cached].\n";
     return true;
   }
   if (!Quiet && Options.Verbose)
     outs() << " ...\n";
 
   // Cyclic dependencies are disallowed by Clang, but we still
   // shouldn't run into an infinite loop, so mark it as processed now.
   ClangModules.insert({PCMfile, DwoId});
 
   if (Error E =
-          loadClangModule(CUDie, PCMfile, Name, DwoId, OF, StringPool,
+          loadClangModule(CUDie, PCMfile, Name, DwoId, File, StringPool,
                           UniquingStringPool, ODRContexts, ModulesEndOffset,
                           UnitID, IsLittleEndian, Indent + 2, Quiet)) {
     consumeError(std::move(E));
     return false;
   }
   return true;
 }
 
 Error DWARFLinker::loadClangModule(
     DWARFDie CUDie, StringRef Filename, StringRef ModuleName, uint64_t DwoId,
-    const DwarfLinkerObjFile &OF, OffsetsStringPool &StringPool,
+    const DwarfFile &File, OffsetsStringPool &StringPool,
     UniquingStringPool &UniquingStringPool, DeclContextTree &ODRContexts,
     uint64_t ModulesEndOffset, unsigned &UnitID, bool IsLittleEndian,
     unsigned Indent, bool Quiet) {
   /// Using a SmallString<0> because loadClangModule() is recursive.
   SmallString<0> Path(Options.PrependPath);
   if (sys::path::is_relative(Filename))
     resolveRelativeObjectPath(Path, CUDie);
   sys::path::append(Path, Filename);
   // Don't use the cached binary holder because we have no thread-safety
   // guarantee and the lifetime is limited.
 
   if (Options.ObjFileLoader == nullptr)
     return Error::success();
 
-  auto ErrOrObj = Options.ObjFileLoader(OF.FileName, Path);
+  auto ErrOrObj = Options.ObjFileLoader(File.FileName, Path);
   if (!ErrOrObj)
     return Error::success();
 
   std::unique_ptr<CompileUnit> Unit;
 
-  // Setup access to the debug info.
-  auto DwarfContext = DWARFContext::create(*ErrOrObj->ObjFile);
-
-  for (const auto &CU : DwarfContext->compile_units()) {
+  for (const auto &CU : ErrOrObj->Dwarf->compile_units()) {
     updateDwarfVersion(CU->getVersion());
     // Recursively get all modules imported by this one.
     auto CUDie = CU->getUnitDIE(false);
     if (!CUDie)
       continue;
-    if (!registerModuleReference(CUDie, *CU, OF, StringPool, UniquingStringPool,
-                                 ODRContexts, ModulesEndOffset, UnitID,
-                                 IsLittleEndian, Indent, Quiet)) {
+    if (!registerModuleReference(
+            CUDie, *CU, File, StringPool, UniquingStringPool, ODRContexts,
+            ModulesEndOffset, UnitID, IsLittleEndian, Indent, Quiet)) {
       if (Unit) {
         std::string Err =
             (Filename +
              ": Clang modules are expected to have exactly 1 compile unit.\n")
                 .str();
-        reportError(Err, OF);
+        reportError(Err, File);
         return make_error<StringError>(Err, inconvertibleErrorCode());
       }
       // FIXME: Until PR27449 (https://llvm.org/bugs/show_bug.cgi?id=27449) is
       // fixed in clang, only warn about DWO_id mismatches in verbose mode.
       // ASTFileSignatures will change randomly when a module is rebuilt.
       uint64_t PCMDwoId = getDwoId(CUDie, *CU);
       if (PCMDwoId != DwoId) {
         if (!Quiet && Options.Verbose)
           reportWarning(
               Twine("hash mismatch: this object file was built against a "
                     "different version of the module ") +
                   Filename,
-              OF);
+              File);
         // Update the cache entry with the DwoId of the module loaded from disk.
         ClangModules[Filename] = PCMDwoId;
       }
 
       // Add this module.
       Unit = std::make_unique<CompileUnit>(*CU, UnitID++, !Options.NoODR,
                                            ModuleName);
       Unit->setHasInterestingContent();
       analyzeContextInfo(CUDie, 0, *Unit, &ODRContexts.getRoot(),
                          UniquingStringPool, ODRContexts, ModulesEndOffset,
                          Options.ParseableSwiftInterfaces,
                          [&](const Twine &Warning, const DWARFDie &DIE) {
-                           reportWarning(Warning, OF, &DIE);
+                           reportWarning(Warning, File, &DIE);
                          });
       // Keep everything.
       Unit->markEverythingAsKept();
     }
   }
   if (!Unit->getOrigUnit().getUnitDIE().hasChildren())
     return Error::success();
   if (!Quiet && Options.Verbose) {
     outs().indent(Indent);
     outs() << "cloning .debug_info from " << Filename << "\n";
   }
 
   UnitListTy CompileUnits;
   CompileUnits.push_back(std::move(Unit));
   assert(TheDwarfEmitter);
   DIECloner(*this, TheDwarfEmitter, *ErrOrObj, DIEAlloc, CompileUnits,
             Options.Update)
-      .cloneAllCompileUnits(*DwarfContext, OF, StringPool, IsLittleEndian);
+      .cloneAllCompileUnits(*(ErrOrObj->Dwarf), File, StringPool,
+                            IsLittleEndian);
   return Error::success();
 }
 
 void DWARFLinker::DIECloner::cloneAllCompileUnits(DWARFContext &DwarfContext,
-                                                  const DwarfLinkerObjFile &OF,
+                                                  const DwarfFile &File,
                                                   OffsetsStringPool &StringPool,
                                                   bool IsLittleEndian) {
   uint64_t OutputDebugInfoSize =
       Linker.Options.NoOutput ? 0 : Emitter->getDebugInfoSectionSize();
   for (auto &CurrentUnit : CompileUnits) {
     auto InputDIE = CurrentUnit->getOrigUnit().getUnitDIE();
     CurrentUnit->setStartOffset(OutputDebugInfoSize);
     if (!InputDIE) {
       OutputDebugInfoSize = CurrentUnit->computeNextUnitOffset();
       continue;
     }
     if (CurrentUnit->getInfo(0).Keep) {
       // Clone the InputDIE into your Unit DIE in our compile unit since it
       // already has a DIE inside of it.
       CurrentUnit->createOutputDIE();
-      cloneDIE(InputDIE, OF, *CurrentUnit, StringPool, 0 /* PC offset */,
+      cloneDIE(InputDIE, File, *CurrentUnit, StringPool, 0 /* PC offset */,
                11 /* Unit Header size */, 0, IsLittleEndian,
                CurrentUnit->getOutputUnitDIE());
     }
 
     OutputDebugInfoSize = CurrentUnit->computeNextUnitOffset();
 
     if (!Linker.Options.NoOutput) {
       assert(Emitter);
 
       if (LLVM_LIKELY(!Linker.Options.Update) ||
           Linker.needToTranslateStrings())
-        Linker.patchLineTableForUnit(*CurrentUnit, DwarfContext, OF);
+        Linker.patchLineTableForUnit(*CurrentUnit, DwarfContext, File);
 
       Linker.emitAcceleratorEntriesForUnit(*CurrentUnit);
 
       if (LLVM_UNLIKELY(Linker.Options.Update))
         continue;
 
-      Linker.patchRangesForUnit(*CurrentUnit, DwarfContext, OF);
+      Linker.patchRangesForUnit(*CurrentUnit, DwarfContext, File);
       auto ProcessExpr = [&](StringRef Bytes,
                              SmallVectorImpl<uint8_t> &Buffer) {
         DWARFUnit &OrigUnit = CurrentUnit->getOrigUnit();
         DataExtractor Data(Bytes, IsLittleEndian,
                            OrigUnit.getAddressByteSize());
         cloneExpression(Data,
                         DWARFExpression(Data, OrigUnit.getAddressByteSize()),
-                        OF, *CurrentUnit, Buffer);
+                        File, *CurrentUnit, Buffer);
       };
       Emitter->emitLocationsForUnit(*CurrentUnit, DwarfContext, ProcessExpr);
     }
   }
 
   if (!Linker.Options.NoOutput) {
     assert(Emitter);
     // Emit all the compile unit's debug information.
if (!AtLeastOneDwarfAccelTable &&
     AtLeastOneAppleAccelTable = true;
   }
 
   if (!AtLeastOneDwarfAccelTable && !DwarfObj.getNamesSection().Data.empty()) {
     AtLeastOneDwarfAccelTable = true;
   }
 }
 
-bool DWARFLinker::emitPaperTrailWarnings(const DwarfLinkerObjFile &OF,
+bool DWARFLinker::emitPaperTrailWarnings(const DwarfFile &File,
                                          OffsetsStringPool &StringPool) {
 
-  if (OF.Warnings.empty() || (OF.ObjFile && (OF.ObjFile->symbols().begin() !=
-                                             OF.ObjFile->symbols().end())))
+  if (File.Warnings.empty())
     return false;
 
   DIE *CUDie = DIE::get(DIEAlloc, dwarf::DW_TAG_compile_unit);
   CUDie->setOffset(11);
   StringRef Producer;
   StringRef WarningHeader;
 
   switch (DwarfLinkerClientID) {
   case DwarfLinkerClient::Dsymutil:
     Producer = StringPool.internString("dsymutil");
     WarningHeader = "dsymutil_warning";
     break;
 
   default:
     Producer = StringPool.internString("dwarfopt");
     WarningHeader = "dwarfopt_warning";
     break;
   }
 
-  StringRef File = StringPool.internString(OF.FileName);
+  StringRef FileName = StringPool.internString(File.FileName);
   CUDie->addValue(DIEAlloc, dwarf::DW_AT_producer, dwarf::DW_FORM_strp,
                   DIEInteger(StringPool.getStringOffset(Producer)));
   DIEBlock *String = new (DIEAlloc) DIEBlock();
   DIEBlocks.push_back(String);
-  for (auto &C : File)
+  for (auto &C : FileName)
     String->addValue(DIEAlloc, dwarf::Attribute(0), dwarf::DW_FORM_data1,
                      DIEInteger(C));
   String->addValue(DIEAlloc, dwarf::Attribute(0), dwarf::DW_FORM_data1,
                    DIEInteger(0));
 
   CUDie->addValue(DIEAlloc, dwarf::DW_AT_name, dwarf::DW_FORM_string, String);
-  for (const auto &Warning : OF.Warnings) {
+  for (const auto &Warning : File.Warnings) {
     DIE &ConstDie = CUDie->addChild(DIE::get(DIEAlloc, dwarf::DW_TAG_constant));
     ConstDie.addValue(DIEAlloc, dwarf::DW_AT_name, dwarf::DW_FORM_strp,
                       DIEInteger(StringPool.getStringOffset(WarningHeader)));
     ConstDie.addValue(DIEAlloc, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag,
                       DIEInteger(1));
     ConstDie.addValue(DIEAlloc, dwarf::DW_AT_const_value, dwarf::DW_FORM_strp,
                       DIEInteger(StringPool.getStringOffset(Warning)));
   }
-  unsigned Size = 4 /* FORM_strp */ + File.size() + 1 +
-                  OF.Warnings.size() * (4 + 1 + 4) + 1 /* End of children */;
+  unsigned Size = 4 /* FORM_strp */ + FileName.size() + 1 +
+                  File.Warnings.size() * (4 + 1 + 4) + 1 /* End of children */;
   DIEAbbrev Abbrev = CUDie->generateAbbrev();
   assignAbbrev(Abbrev);
   CUDie->setAbbrevNumber(Abbrev.getNumber());
   Size += getULEB128Size(Abbrev.getNumber());
   // Abbreviation ordering needed for classic compatibility.
   for (auto &Child : CUDie->children()) {
     Abbrev = Child.generateAbbrev();
     assignAbbrev(Abbrev);
     Child.setAbbrevNumber(Abbrev.getNumber());
     Size += getULEB128Size(Abbrev.getNumber());
   }
   CUDie->setSize(Size);
   TheDwarfEmitter->emitPaperTrailWarningsDie(*CUDie);
 
   return true;
 }
 
-void DWARFLinker::copyInvariantDebugSection(const object::ObjectFile &Obj) {
+void DWARFLinker::copyInvariantDebugSection(DWARFContext &Dwarf) {
   if (!needToTranslateStrings())
-    TheDwarfEmitter->emitSectionContents(Obj, "debug_line");
-  TheDwarfEmitter->emitSectionContents(Obj, "debug_loc");
-  TheDwarfEmitter->emitSectionContents(Obj, "debug_ranges");
-  TheDwarfEmitter->emitSectionContents(Obj, "debug_frame");
-  TheDwarfEmitter->emitSectionContents(Obj, "debug_aranges");
+    TheDwarfEmitter->emitSectionContents(
+        Dwarf.getDWARFObj().getLineSection().Data, "debug_line");
+  TheDwarfEmitter->emitSectionContents(Dwarf.getDWARFObj().getLocSection().Data,
+                                       "debug_loc");
+  TheDwarfEmitter->emitSectionContents(
+      Dwarf.getDWARFObj().getRangesSection().Data, "debug_ranges");
+  TheDwarfEmitter->emitSectionContents(
+      Dwarf.getDWARFObj().getFrameSection().Data, "debug_frame");
+  TheDwarfEmitter->emitSectionContents(Dwarf.getDWARFObj().getArangesSection(),
+                                       "debug_aranges");
 }
 
-void DWARFLinker::addObjectFile(DwarfLinkerObjFile &ObjFile) {
-  ObjectContexts.emplace_back(LinkContext(ObjFile));
+void DWARFLinker::addObjectFile(DwarfFile &File) {
+  ObjectContexts.emplace_back(LinkContext(File));
 
-  if (ObjectContexts.back().DwarfContext)
-    updateAccelKind(*ObjectContexts.back().DwarfContext);
+  if (ObjectContexts.back().File.Dwarf)
+    updateAccelKind(*ObjectContexts.back().File.Dwarf);
 }
 
 bool DWARFLinker::link() {
   assert(Options.NoOutput || TheDwarfEmitter);
 
   // A unique ID that identifies each compile unit.
   unsigned UnitID = 0;
 
if (AtLeastOneDwarfAccelTable && !AtLeastOneAppleAccelTable)
       Options.TheAccelTableKind = AccelTableKind::Dwarf;
     else
       Options.TheAccelTableKind = AccelTableKind::Apple;
   }
 
   for (LinkContext &OptContext : ObjectContexts) {
     if (Options.Verbose) {
       if (DwarfLinkerClientID == DwarfLinkerClient::Dsymutil)
-        outs() << "DEBUG MAP OBJECT: " << OptContext.ObjectFile.FileName
-               << "\n";
+        outs() << "DEBUG MAP OBJECT: " << OptContext.File.FileName << "\n";
       else
-        outs() << "OBJECT FILE: " << OptContext.ObjectFile.FileName << "\n";
+        outs() << "OBJECT FILE: " << OptContext.File.FileName << "\n";
     }
 
-    if (emitPaperTrailWarnings(OptContext.ObjectFile, OffsetsStringPool))
+    if (emitPaperTrailWarnings(OptContext.File, OffsetsStringPool))
       continue;
 
-    if (!OptContext.ObjectFile.ObjFile)
+    if (!OptContext.File.Dwarf)
       continue;
     // Look for relocations that correspond to address map entries.
 
     // there was findvalidrelocations previously ... probably we need to gather
     // info here
     if (LLVM_LIKELY(!Options.Update) &&
-        !OptContext.ObjectFile.Addresses->hasValidRelocs()) {
+        !OptContext.File.Addresses->hasValidRelocs()) {
       if (Options.Verbose)
         outs() << "No valid relocations found. Skipping.\n";
 
       // Set "Skip" flag as a signal to other loops that we should not
       // process this iteration.
       OptContext.Skip = true;
       continue;
     }
 
     // Setup access to the debug info.
-    if (!OptContext.DwarfContext)
+    if (!OptContext.File.Dwarf)
       continue;
 
     // In a first phase, just read in the debug info and load all clang modules.
     OptContext.CompileUnits.reserve(
-        OptContext.DwarfContext->getNumCompileUnits());
+        OptContext.File.Dwarf->getNumCompileUnits());
 
-    for (const auto &CU : OptContext.DwarfContext->compile_units()) {
+    for (const auto &CU : OptContext.File.Dwarf->compile_units()) {
       updateDwarfVersion(CU->getVersion());
       auto CUDie = CU->getUnitDIE(false);
       if (Options.Verbose) {
         outs() << "Input compilation unit:";
         DIDumpOptions DumpOpts;
         DumpOpts.ChildRecurseDepth = 0;
         DumpOpts.Verbose = Options.Verbose;
         CUDie.dump(outs(), 0, DumpOpts);
       }
       if (CUDie && !LLVM_UNLIKELY(Options.Update))
-        registerModuleReference(CUDie, *CU, OptContext.ObjectFile,
-                                OffsetsStringPool, UniquingStringPool,
-                                ODRContexts, 0, UnitID,
-                                OptContext.DwarfContext->isLittleEndian());
+        registerModuleReference(CUDie, *CU, OptContext.File, OffsetsStringPool,
+                                UniquingStringPool, ODRContexts, 0, UnitID,
+                                OptContext.File.Dwarf->isLittleEndian());
     }
   }
 
   // If we haven't seen any CUs, pick an arbitrary valid Dwarf version anyway.
   if (MaxDwarfVersion == 0)
     MaxDwarfVersion = 3;
 
   // At this point we know how much data we have emitted. We use this value to
bool DWARFLinker::link() {
   std::condition_variable ProcessedFilesConditionVariable;
   BitVector ProcessedFiles(NumObjects, false);
 
   //  Analyzing the context info is particularly expensive so it is executed in
   //  parallel with emitting the previous compile unit.
   auto AnalyzeLambda = [&](size_t I) {
     auto &Context = ObjectContexts[I];
 
-    if (Context.Skip || !Context.DwarfContext)
+    if (Context.Skip || !Context.File.Dwarf)
       return;
 
-    for (const auto &CU : Context.DwarfContext->compile_units()) {
+    for (const auto &CU : Context.File.Dwarf->compile_units()) {
       updateDwarfVersion(CU->getVersion());
       // The !registerModuleReference() condition effectively skips
       // over fully resolved skeleton units. This second pass of
       // registerModuleReferences doesn't do any new work, but it
       // will collect top-level errors, which are suppressed. Module
       // warnings were already displayed in the first iteration.
       bool Quiet = true;
       auto CUDie = CU->getUnitDIE(false);
       if (!CUDie || LLVM_UNLIKELY(Options.Update) ||
-          !registerModuleReference(CUDie, *CU, Context.ObjectFile,
-                                   OffsetsStringPool, UniquingStringPool,
-                                   ODRContexts, ModulesEndOffset, UnitID,
-                                   Quiet)) {
+          !registerModuleReference(CUDie, *CU, Context.File, OffsetsStringPool,
+                                   UniquingStringPool, ODRContexts,
+                                   ModulesEndOffset, UnitID, Quiet)) {
         Context.CompileUnits.push_back(std::make_unique<CompileUnit>(
             *CU, UnitID++, !Options.NoODR && !Options.Update, ""));
       }
     }
 
     // Now build the DIE parent links that we will use during the next phase.
     for (auto &CurrentUnit : Context.CompileUnits) {
       auto CUDie = CurrentUnit->getOrigUnit().getUnitDIE();
       if (!CUDie)
         continue;
       analyzeContextInfo(CurrentUnit->getOrigUnit().getUnitDIE(), 0,
                          *CurrentUnit, &ODRContexts.getRoot(),
                          UniquingStringPool, ODRContexts, ModulesEndOffset,
                          Options.ParseableSwiftInterfaces,
                          [&](const Twine &Warning, const DWARFDie &DIE) {
-                           reportWarning(Warning, Context.ObjectFile, &DIE);
+                           reportWarning(Warning, Context.File, &DIE);
                          });
     }
   };
 
   // And then the remaining work in serial again.
   // Note, although this loop runs in serial, it can run in parallel with
   // the analyzeContextInfo loop so long as we process files with indices >=
   // than those processed by analyzeContextInfo.
   auto CloneLambda = [&](size_t I) {
     auto &OptContext = ObjectContexts[I];
-    if (OptContext.Skip || !OptContext.ObjectFile.ObjFile)
+    if (OptContext.Skip || !OptContext.File.Dwarf)
       return;
 
     // Then mark all the DIEs that need to be present in the generated output
     // and collect some information about them.
     // Note that this loop can not be merged with the previous one because
     // cross-cu references require the ParentIdx to be setup for every CU in
     // the object file before calling this.
     if (LLVM_UNLIKELY(Options.Update)) {
       for (auto &CurrentUnit : OptContext.CompileUnits)
         CurrentUnit->markEverythingAsKept();
-      copyInvariantDebugSection(*OptContext.ObjectFile.ObjFile);
+      copyInvariantDebugSection(*OptContext.File.Dwarf);
     } else {
       for (auto &CurrentUnit : OptContext.CompileUnits)
-        lookForDIEsToKeep(
-            *OptContext.ObjectFile.Addresses,
-            OptContext.ObjectFile.Addresses->getValidAddressRanges(),
-            OptContext.CompileUnits, CurrentUnit->getOrigUnit().getUnitDIE(),
-            OptContext.ObjectFile, *CurrentUnit, 0);
+        lookForDIEsToKeep(*OptContext.File.Addresses,
+                          OptContext.File.Addresses->getValidAddressRanges(),
+                          OptContext.CompileUnits,
+                          CurrentUnit->getOrigUnit().getUnitDIE(),
+                          OptContext.File, *CurrentUnit, 0);
     }
 
     // The calls to applyValidRelocs inside cloneDIE will walk the reloc
     // array again (in the same way findValidRelocsInDebugInfo() did). We
     // need to reset the NextValidReloc index to the beginning.
-    if (OptContext.ObjectFile.Addresses->hasValidRelocs() ||
+    if (OptContext.File.Addresses->hasValidRelocs() ||
         LLVM_UNLIKELY(Options.Update)) {
-      DIECloner(*this, TheDwarfEmitter, OptContext.ObjectFile, DIEAlloc,
+      DIECloner(*this, TheDwarfEmitter, OptContext.File, DIEAlloc,
                 OptContext.CompileUnits, Options.Update)
-          .cloneAllCompileUnits(*OptContext.DwarfContext, OptContext.ObjectFile,
+          .cloneAllCompileUnits(*OptContext.File.Dwarf, OptContext.File,
                                 OffsetsStringPool,
-                                OptContext.DwarfContext->isLittleEndian());
+                                OptContext.File.Dwarf->isLittleEndian());
     }
     if (!Options.NoOutput && !OptContext.CompileUnits.empty() &&
         LLVM_LIKELY(!Options.Update))
       patchFrameInfoForObject(
-          OptContext.ObjectFile,
-          OptContext.ObjectFile.Addresses->getValidAddressRanges(),
-          *OptContext.DwarfContext,
+          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.

llvm/tools/dsymutil/DwarfLinkerForBinary.h

private:
   /// \defgroup Helpers Various helper methods.
   ///
   /// @{
   bool createStreamer(const Triple &TheTriple, raw_fd_ostream &OutFile);
 
   /// Attempt to load a debug object from disk.
   ErrorOr<const object::ObjectFile &> loadObject(const DebugMapObject &Obj,
                                                  const Triple &triple);
-  ErrorOr<DwarfLinkerObjFile &> loadObject(const DebugMapObject &Obj,
-                                           const DebugMap &DebugMap,
-                                           remarks::RemarkLinker &RL);
+  ErrorOr<DwarfFile &> loadObject(const DebugMapObject &Obj,
 
   raw_fd_ostream &OutFile;
   BinaryHolder &BinHolder;
   LinkOptions Options;
   std::unique_ptr<DwarfStreamer> Streamer;
-  std::vector<std::unique_ptr<DwarfLinkerObjFile>> ObjectsForLinking;
+  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;
 
   bool ModuleCacheHintDisplayed = false;
   bool ArchiveHintDisplayed = false;
 };
 
 } // end namespace dsymutil
 } // end namespace llvm
 
 #endif // LLVM_TOOLS_DSYMUTIL_DWARFLINKER_H

llvm/tools/dsymutil/DwarfLinkerForBinary.cpp

if (EC)
     return errorCodeToError(EC);
 
   if (Error E = RL.serialize(OS, Options.RemarksFormat))
     return E;
 
   return Error::success();
 }
 
-ErrorOr<DwarfLinkerObjFile &>
+ErrorOr<DwarfFile &>
 DwarfLinkerForBinary::loadObject(const DebugMapObject &Obj,
                                  const DebugMap &DebugMap,
                                  remarks::RemarkLinker &RL) {
   auto ErrorOrObj = loadObject(Obj, DebugMap.getTriple());
 
   if (ErrorOrObj) {
-    ObjectsForLinking.push_back(
-        std::unique_ptr<DwarfLinkerObjFile>(new DwarfLinkerObjFile(
-            Obj.getObjectFilename(), &*ErrorOrObj, Obj.getWarnings())));
+    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));
 
-    ObjectsForLinking.back()->Addresses.reset(
-        new AddressManager(*this, *ErrorOrObj, Obj));
-
-    Error E = RL.link(*ObjectsForLinking.back()->ObjFile);
+    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 ErrorOrObj.getError();
 }
 
 bool DwarfLinkerForBinary::link(const DebugMap &Map) {
   if (!createStreamer(Map.getTriple(), OutFile))
     return false;
 
   ObjectsForLinking.clear();
+  ContextForLinking.clear();
+  AddressMapForLinking.clear();
 
   DebugMap DebugMap(Map.getTriple(), Map.getBinaryPath());
 
   DWARFLinker GeneralLinker(Streamer.get(), DwarfLinkerClient::Dsymutil);
 
   remarks::RemarkLinker RL;
   if (!Options.RemarksPrependPath.empty())
     RL.setExternalFilePrependPath(Options.RemarksPrependPath);
GeneralLinker.setWarningHandler(
         reportWarning(Warning, Context, DIE);
       });
   GeneralLinker.setErrorHandler(
       [&](const Twine &Error, StringRef Context, const DWARFDie *DIE) {
         error(Error, Context);
       });
   GeneralLinker.setObjFileLoader(
       [&DebugMap, &RL, this](StringRef ContainerName,
-                             StringRef Path) -> ErrorOr<DwarfLinkerObjFile &> {
+                             StringRef Path) -> ErrorOr<DwarfFile &> {
         auto &Obj = DebugMap.addDebugMapObject(
             Path, sys::TimePoint<std::chrono::seconds>(), MachO::N_OSO);
 
         if (auto ErrorOrObj = loadObject(Obj, DebugMap, RL)) {
           return *ErrorOrObj;
         } else {
           // Try and emit more helpful warnings by applying some heuristics.
           StringRef ObjFile = ContainerName;
if (Obj->getType() == MachO::N_AST) {
         Streamer->emitSwiftAST((*ErrorOrMem)->getBuffer());
 
       continue;
     }
 
     if (auto ErrorOrObj = loadObject(*Obj, Map, RL))
       GeneralLinker.addObjectFile(*ErrorOrObj);
     else {
-      ObjectsForLinking.push_back(
-          std::unique_ptr<DwarfLinkerObjFile>(new DwarfLinkerObjFile(
-              Obj->getObjectFilename(), nullptr, Obj->getWarnings())));
+      ObjectsForLinking.push_back(std::make_unique<DwarfFile>(
+          Obj->getObjectFilename(), nullptr, nullptr,
+          Obj->empty() ? Obj->getWarnings() : EmptyWarnings));
       GeneralLinker.addObjectFile(*ObjectsForLinking.back());
     }
   }
 
   // link debug info for loaded object files.
   GeneralLinker.link();
 
   StringRef ArchName = Map.getTriple().getArchName();

llvm/tools/dsymutil/DwarfStreamer.h

public:
   /// Emit the abbreviation table \p Abbrevs to the debug_abbrev section.
   void emitAbbrevs(const std::vector<std::unique_ptr<DIEAbbrev>> &Abbrevs,
                    unsigned DwarfVersion) override;
 
   /// Emit DIE containing warnings.
   void emitPaperTrailWarningsDie(DIE &Die) override;
 
   /// Emit contents of section SecName From Obj.
-  void emitSectionContents(const object::ObjectFile &Obj,
-                           StringRef SecName) override;
+  void emitSectionContents(StringRef SecData, StringRef SecName) override;
 
   /// Emit the string table described by \p Pool.
   void emitStrings(const NonRelocatableStringpool &Pool) override;
 
   /// Emit the swift_ast section stored in \p Buffer.
   void emitSwiftAST(StringRef Buffer);
 
   /// Emit debug_ranges for \p FuncRange by translating the
void emitLineTableForUnit(MCDwarfLineTableParams Params,
                             StringRef PrologueBytes, unsigned MinInstLength,
                             std::vector<DWARFDebugLine::Row> &Rows,
                             unsigned AdddressSize) override;
 
   /// Copy the debug_line over to the updated binary while unobfuscating the
   /// file names and directories.
   void translateLineTable(DataExtractor LineData, uint64_t Offset) override;
 
-  /// Copy over the debug sections that are not modified when updating.
-  void copyInvariantDebugSection(const object::ObjectFile &Obj);
-
   uint64_t getLineSectionSize() const override { return LineSectionSize; }
 
   /// Emit the .debug_pubnames contribution for \p Unit.
   void emitPubNamesForUnit(const CompileUnit &Unit) override;
 
   /// Emit the .debug_pubtypes contribution for \p Unit.
   void emitPubTypesForUnit(const CompileUnit &Unit) override;
 

llvm/tools/dsymutil/DwarfStreamer.cpp

 /// Recursively emit the DIE tree rooted at \p Die.
 void DwarfStreamer::emitDIE(DIE &Die) {
   MS->SwitchSection(MOFI->getDwarfInfoSection());
   Asm->emitDwarfDIE(Die);
   DebugInfoSectionSize += Die.getSize();
 }
 
 /// Emit contents of section SecName From Obj.
-void DwarfStreamer::emitSectionContents(const object::ObjectFile &Obj,
-                                        StringRef SecName) {
+void DwarfStreamer::emitSectionContents(StringRef SecData, StringRef SecName) {
   MCSection *Section =
       StringSwitch<MCSection *>(SecName)
           .Case("debug_line", MC->getObjectFileInfo()->getDwarfLineSection())
           .Case("debug_loc", MC->getObjectFileInfo()->getDwarfLocSection())
           .Case("debug_ranges",
                 MC->getObjectFileInfo()->getDwarfRangesSection())
           .Case("debug_frame", MC->getObjectFileInfo()->getDwarfFrameSection())
           .Case("debug_aranges",
                 MC->getObjectFileInfo()->getDwarfARangesSection())
           .Default(nullptr);
 
   if (Section) {
     MS->SwitchSection(Section);
 
-    if (auto Sec = getSectionByName(Obj, SecName)) {
-      if (Expected<StringRef> E = Sec->getContents())
-        MS->emitBytes(*E);
-      else
-        consumeError(E.takeError());
-    }
+    MS->emitBytes(SecData);
   }
 }
 
 /// Emit DIE containing warnings.
 void DwarfStreamer::emitPaperTrailWarningsDie(DIE &Die) {
   switchToDebugInfoSection(/* Version */ 2);
   auto &Asm = getAsmPrinter();
   Asm.emitInt32(11 + Die.getSize() - 4);
void DwarfStreamer::translateLineTable(DataExtractor Data, uint64_t Offset) {
   // Copy the actual line table program over.
   Asm->OutStreamer->emitBytes(Contents.slice(Offset, UnitEnd));
   LineSectionSize += UnitEnd - Offset;
 
   Asm->OutStreamer->emitLabel(EndLabel);
   Offset = UnitEnd;
 }
 
-void DwarfStreamer::copyInvariantDebugSection(const object::ObjectFile &Obj) {
-  if (!Options.Translator) {
-    MS->SwitchSection(MC->getObjectFileInfo()->getDwarfLineSection());
-    emitSectionContents(Obj, "debug_line");
-  }
-
-  MS->SwitchSection(MC->getObjectFileInfo()->getDwarfLocSection());
-  emitSectionContents(Obj, "debug_loc");
-
-  MS->SwitchSection(MC->getObjectFileInfo()->getDwarfRangesSection());
-  emitSectionContents(Obj, "debug_ranges");
-
-  MS->SwitchSection(MC->getObjectFileInfo()->getDwarfFrameSection());
-  emitSectionContents(Obj, "debug_frame");
-
-  MS->SwitchSection(MC->getObjectFileInfo()->getDwarfARangesSection());
-  emitSectionContents(Obj, "debug_aranges");
-}
-
 /// Emit the pubnames or pubtypes section contribution for \p
 /// Unit into \p Sec. The data is provided in \p Names.
 void DwarfStreamer::emitPubSectionForUnit(
     MCSection *Sec, StringRef SecName, const CompileUnit &Unit,
     const std::vector<CompileUnit::AccelInfo> &Names) {
   if (Names.empty())
     return;