dsymutil support for DW_OP_convert

[aprantl]

Summary

So far I only got this testcase and it fails...

I'll update this as soon as I'm done implementing the missing pieces in dsymutil. We'll have to scan each DW_AT_location for DW_OP_convert DIE references and mark them as kept and then during cloning ensure to update the relative CU DIE offset if necessary.

[aprantl]

Here's the the first part of the patch: support for inline locations. Support for location lists is still coming.

[aprantl]

Here's a first complete implementation.

In this form a ReleaseAsserts dsymutil run on a ReleaseAsserts+modules clang is about 5% slower:

# trunk
$ time dsymutil clang   # best out of 3 runs

real	0m46.861s
user	0m53.870s
sys	0m4.019s

# with this patch

real	0m48.995s
user	0m55.888s
sys	0m4.174s

[markus]

llvm/tools/dsymutil/DwarfLinker.cpp

723

Check if DWARFExpression::Operation::Encoding is BaseTypeRef instead.

1120

Instead of checking for DW_OP_convert explicitly we could check the DWARFExpression::Operation::Encoding to see if it is BaseTypeRef.

[aprantl]

Thanks for pointing out that DW_OP_convert isn't the only operation that uses a CU-relative type DIE offset!
I went through the DWARF 5 spec once more and it looks like all the operations that require a type parameter also require that that type parameter is a basic type. Since basic types are tiny, we can just keep them all unconditionally and skip the entire scanExpressionDIERefs part. With this change dsymutil gets more than 2 seconds faster on clang, basically almost the original performance.

[aprantl]

Faster version without the first scan expression pass.

Removing the WIP tag; this is now ready for a thorough review!

[friss]

llvm/tools/dsymutil/DwarfLinker.cpp

1159

if you hit the error, then it looks like you're only going to emit NOPs instead of the ULEB. This is going to be badly misinterpreted by a consumer. You really want to NOP-out the whole convert expression.

[markus]

llvm/tools/dsymutil/DwarfLinker.cpp

1159

If the BaseTypeRef ULEB does not fit then I believe that you want to replace it (the BaseTypeRef ULEB) with zeros as that will be interpreted as a reference to the generic type according to the spec. I guess that replacing the entire operation and its operands with several DW_OP_nop would also be an option. Doing the former seems easier though and would arguably be more accurate in my opinion.

[aprantl]

Address review feedback.

[friss]

LGTM on the surface. I wouldn't mind someone else (@JDevlieghere ?) taking a look.

[JDevlieghere]

Few nits in addition to the stuff we discussed offline.

llvm/include/llvm/DebugInfo/DWARF/DWARFAttribute.h

47

nit/subjective: I prefer mayHaveLocationDescription

llvm/tools/dsymutil/DwarfLinker.cpp

1125

Let's do this at the beginning of the functions.

1130

Can we invert this and do a continue?

llvm/tools/dsymutil/DwarfLinker.h

203–204

Can we use the endianness enum from Support/Endian.h?

380

Can you include why these two are different in the doxygen comment?

[probinson]

Drive-by nit.

llvm/lib/DebugInfo/DWARF/DWARFDie.cpp

713

DWARF v5? As this will be yet another place to update in future revisions.

[aprantl]

Got rid of most of the callbacks and per-byte copies.

[aprantl]

llvm/tools/dsymutil/DwarfLinker.cpp

1130

No, there is an else path, too.

[aprantl]

Got rid of the second cloneExpression function.

[aprantl]

Add a comment.

[JDevlieghere]

LGTM

llvm/include/llvm/DebugInfo/DWARF/DWARFAttribute.h

struct DWARFAttribute {
   bool isValid() const {
     return Offset != 0 && Attr != dwarf::Attribute(0);
   }
 
   explicit operator bool() const {
     return isValid();
   }
 
+  /// Identifies DWARF attributes that may contain a reference to a
+  /// DWARF expression.
+  static bool mayHaveLocationDescription(dwarf::Attribute Attr);
+
   void clear() {
     Offset = 0;
     ByteSize = 0;
     Attr = dwarf::Attribute(0);
     Value = DWARFFormValue();
   }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_DWARFATTRIBUTE_H

llvm/lib/DebugInfo/DWARF/DWARFDie.cpp

else if (Attr == DW_AT_high_pc && !DumpOpts.ShowForm && !DumpOpts.Verbose &&
     if (DumpOpts.ShowAddresses) {
       // Print the actual address rather than the offset.
       uint64_t LowPC, HighPC, Index;
       if (Die.getLowAndHighPC(LowPC, HighPC, Index))
         OS << format("0x%016" PRIx64, HighPC);
       else
         formValue.dump(OS, DumpOpts);
     }
-  } else if (Attr == DW_AT_location || Attr == DW_AT_frame_base ||
-             Attr == DW_AT_data_member_location ||
-             Attr == DW_AT_GNU_call_site_value)
+  } else if (DWARFAttribute::mayHaveLocationDescription(Attr))
     dumpLocation(OS, formValue, U, sizeof(BaseIndent) + Indent + 4, DumpOpts);
   else
     formValue.dump(OS, DumpOpts);
 
   std::string Space = DumpOpts.ShowAddresses ? " " : "";
 
   // We have dumped the attribute raw value. For some attributes
   // having both the raw value and the pretty-printed value is
void DWARFDie::attribute_iterator::updateForIndex(
   }
 }
 
 DWARFDie::attribute_iterator &DWARFDie::attribute_iterator::operator++() {
   if (auto AbbrDecl = Die.getAbbreviationDeclarationPtr())
     updateForIndex(*AbbrDecl, Index + 1);
   return *this;
 }
+
+bool DWARFAttribute::mayHaveLocationDescription(dwarf::Attribute Attr) {
+  switch (Attr) {
+  // From the DWARF specification.
+  case DW_AT_location:
+  case DW_AT_byte_size:
+  case DW_AT_bit_size:
+  case DW_AT_string_length:
+  case DW_AT_lower_bound:
+  case DW_AT_return_addr:
+  case DW_AT_bit_stride:
+  case DW_AT_upper_bound:
+  case DW_AT_count:
+  case DW_AT_data_member_location:
+  case DW_AT_frame_base:
+  case DW_AT_segment:
+  case DW_AT_static_link:
+  case DW_AT_use_location:
+  case DW_AT_vtable_elem_location:
+  case DW_AT_allocated:
+  case DW_AT_associated:
+  case DW_AT_byte_stride:
+  case DW_AT_rank:
+  case DW_AT_call_value:
+  case DW_AT_call_origin:
+  case DW_AT_call_target:
+  case DW_AT_call_target_clobbered:
+  case DW_AT_call_data_location:
+  case DW_AT_call_data_value:
+  // Extensions.
+  case DW_AT_GNU_call_site_value:
+    return true;
+  default:
+    return false;
+  }
+}

llvm/test/tools/dsymutil/X86/op-convert.test

 # REQUIRES: object-emission
 # RUN: dsymutil -f -o %t --verify -oso-prepend-path=%p/../Inputs -y %s
-# RUN: llvm-dwarfdump -a %t | FileCheck %s
+# RUN: llvm-dwarfdump %t | FileCheck %s
 
 ---
 triple:          'x86_64-apple-darwin'
 objects:
   - filename: op-convert.macho.x86_64
     symbols:
       - { sym: _foo, objAddr: 0x0, binAddr: 0x1000, size: 0x4 }
 ...
 
 
-CHECK: XXX
+CHECK:      DW_TAG_base_type
+CHECK-NEXT:     DW_AT_name  ("DW_ATE_signed_8")
+CHECK-NEXT:     DW_AT_encoding  (DW_ATE_signed)
+CHECK-NEXT:     DW_AT_byte_size (0x01)
+
+CHECK:   DW_TAG_base_type
+CHECK-NEXT:     DW_AT_name  ("DW_ATE_signed_32")
+CHECK-NEXT:     DW_AT_encoding  (DW_ATE_signed)
+CHECK-NEXT:     DW_AT_byte_size (0x04)
+
+CHECK:     DW_TAG_variable
+
+CHECK:     DW_TAG_variable
+CHECK-NEXT:     DW_AT_location  (0x00000036
+CHECK-NEXT:     [0x0000000000000000,  0x0000000000000002): DW_OP_breg5 RDI+0, DW_OP_constu 0xffffffff, DW_OP_and, DW_OP_convert (0x0000002a) "DW_ATE_signed_8", DW_OP_convert (0x00000031) "DW_ATE_signed_32", DW_OP_stack_value
+CHECK-NEXT:     [0x0000000000000002,  0x0000000000000003): DW_OP_breg0 RAX+0, DW_OP_constu 0xffffffff, DW_OP_and, DW_OP_convert (0x0000002a) "DW_ATE_signed_8", DW_OP_convert (0x00000031) "DW_ATE_signed_32", DW_OP_stack_value)
+CHECK-NEXT:     DW_AT_name  ("y")
+
+CHECK:     DW_TAG_variable
+CHECK-NEXT:     DW_AT_location  (DW_OP_constu 0x2a, DW_OP_convert (0x00000031) "DW_ATE_signed_32", DW_OP_stack_value)
+CHECK-NEXT:     DW_AT_name  ("c")
 

llvm/tools/dsymutil/DwarfLinker.h

void findValidRelocsMachO(const object::SectionRef &Section,
                               const object::MachOObjectFile &Obj,
                               const DebugMapObject &DMO);
     /// @}
 
     bool hasValidRelocation(uint32_t StartOffset, uint32_t EndOffset,
                             CompileUnit::DIEInfo &Info);
 
     bool applyValidRelocs(MutableArrayRef<char> Data, uint32_t BaseOffset,
-                          bool isLittleEndian);
+                          bool IsLittleEndian);
   };
 
   /// Keeps track of data associated with one object during linking.
   struct LinkContext {
     DebugMapObject &DMO;
     const object::ObjectFile *ObjectFile;
     RelocationManager RelocMgr;
     std::unique_ptr<DWARFContext> DwarfContext;
private:
   /// @{
   /// 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(RelocationManager &RelocMgr, RangesTy &Ranges,
                          const UnitListTy &Units, const DWARFDie &DIE,
                          const DebugMapObject &DMO, CompileUnit &CU,
-                         unsigned Flags);
+                         unsigned Flags, bool IsLittleEndian);
 
   /// 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(const DWARFDie &CUDie, const DWARFUnit &Unit,
                                DebugMap &ModuleMap, const DebugMapObject &DMO,
                                RangesTy &Ranges,
                                OffsetsStringPool &OffsetsStringPool,
                                UniquingStringPool &UniquingStringPoolStringPool,
                                DeclContextTree &ODRContexts,
                                uint64_t ModulesEndOffset, unsigned &UnitID,
-                               unsigned Indent = 0, bool Quiet = false);
+                               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(StringRef Filename, StringRef ModulePath,
                         StringRef ModuleName, uint64_t DwoId,
                         DebugMap &ModuleMap, const DebugMapObject &DMO,
                         RangesTy &Ranges, OffsetsStringPool &OffsetsStringPool,
                         UniquingStringPool &UniquingStringPool,
                         DeclContextTree &ODRContexts, uint64_t ModulesEndOffset,
-                        unsigned &UnitID, unsigned Indent = 0,
-                        bool Quiet = false);
+                        unsigned &UnitID, bool IsLittleEndian,
+                        unsigned Indent = 0, bool Quiet = false);
 
   /// Flags passed to DwarfLinker::lookForDIEsToKeep
   enum TraversalFlags {
     TF_Keep = 1 << 0,            ///< Mark the traversed DIEs as kept.
     TF_InFunctionScope = 1 << 1, ///< Current scope is a function scope.
     TF_DependencyWalk = 1 << 2,  ///< Walking the dependencies of a kept DIE.
     TF_ParentWalk = 1 << 3,      ///< Walking up the parents of a kept DIE.
     TF_ODR = 1 << 4,             ///< Use the ODR while keeping dependents.
     TF_SkipPC = 1 << 5,          ///< Skip all location attributes.
   };
 
+  void scanExpressionDIERefs(RelocationManager &RelocMgr, RangesTy &Ranges,
+                             const UnitListTy &Units, const DWARFDie &DIE,
+                             DWARFExpression Expression,
+                             const DebugMapObject &DMO, CompileUnit &CU,
+                             bool IsLittleEndian);
+
+  void scanExpressionDIERefs(RelocationManager &RelocMgr, RangesTy &Ranges,
+                             const UnitListTy &Units, const DWARFDie &DIE,
+                             const DWARFFormValue &AttrValue,
+                             const DebugMapObject &DMO, CompileUnit &CU,
+                             bool IsLittleEndian);
+
   /// Mark the passed DIE as well as all the ones it depends on as kept.
   void keepDIEAndDependencies(RelocationManager &RelocMgr, RangesTy &Ranges,
                               const UnitListTy &Units, const DWARFDie &DIE,
                               CompileUnit::DIEInfo &MyInfo,
                               const DebugMapObject &DMO, CompileUnit &CU,
-                              bool UseODR);
+                              bool UseODR, bool IsLittleEndian);
 
   unsigned shouldKeepDIE(RelocationManager &RelocMgr, RangesTy &Ranges,
                          const DWARFDie &DIE, const DebugMapObject &DMO,
                          CompileUnit &Unit, CompileUnit::DIEInfo &MyInfo,
                          unsigned Flags);
 
+  /// Check if a variable describing DIE should be kept.
+  /// \returns updated TraversalFlags.
   unsigned shouldKeepVariableDIE(RelocationManager &RelocMgr,
                                  const DWARFDie &DIE, CompileUnit &Unit,
                                  CompileUnit::DIEInfo &MyInfo, unsigned Flags);
 
   unsigned shouldKeepSubprogramDIE(RelocationManager &RelocMgr,
                                    RangesTy &Ranges, const DWARFDie &DIE,
                                    const DebugMapObject &DMO, CompileUnit &Unit,
                                    CompileUnit::DIEInfo &MyInfo,
public:
     /// 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 DebugMapObject &DMO,
                   CompileUnit &U, OffsetsStringPool &StringPool,
                   int64_t PCOffset, uint32_t OutOffset, unsigned Flags,
-                  DIE *Die = nullptr);
+                  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 DebugMapObject &DMO, RangesTy &Ranges,
-                              OffsetsStringPool &StringPool);
+                              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 {
       /// Names.
private:
     };
 
     /// Helper for cloneDIE.
     unsigned cloneAttribute(DIE &Die, const DWARFDie &InputDIE,
                             const DebugMapObject &DMO, CompileUnit &U,
                             OffsetsStringPool &StringPool,
                             const DWARFFormValue &Val,
                             const AttributeSpec AttrSpec, unsigned AttrSize,
-                            AttributesInfo &AttrInfo);
+                            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 DebugMapObject &DMO,
                                         CompileUnit &Unit);
 
+    /// Clone a DWARF expression that may be referencing another DIE.
+    void cloneExpression(DIEValueList *Attr, DataExtractor &Data,
+                         const DWARFDie &InputDIE, DWARFExpression Expression,
+                         const DebugMapObject &DMO, CompileUnit &Unit);
+
+    /// Clone a DWARF expression that may be referencing another DIE.
+    void cloneExpression(DIEValueList *Attr, ArrayRef<uint8_t> Expr,
+                         const DWARFDie &InputDIE, const DebugMapObject &DMO,
+                         CompileUnit &Unit, bool IsLittleEndian);
+
     /// Clone an attribute referencing another DIE and add
     /// it to \p Die.
     /// \returns the size of the new attribute.
-    unsigned cloneBlockAttribute(DIE &Die, AttributeSpec AttrSpec,
-                                 const DWARFFormValue &Val, unsigned AttrSize);
+    unsigned cloneBlockAttribute(DIE &Die, const DWARFDie &InputDIE,
+                                 const DebugMapObject &DMO, 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);

llvm/tools/dsymutil/DwarfLinker.cpp

 }
 
 /// Resolve the DIE attribute reference that has been extracted in \p RefValue.
 /// The resulting DIE might be in another CompileUnit which is stored into \p
 /// ReferencedCU. \returns null if resolving fails for any reason.
 static DWARFDie resolveDIEReference(const DwarfLinker &Linker,
                                     const DebugMapObject &DMO,
                                     const UnitListTy &Units,
-                                    const DWARFFormValue &RefValue,
+                                    uint64_t RefOffset,
                                     const DWARFUnit &Unit, 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;
     }
 
   Linker.reportWarning("could not find referenced DIE", DMO, &DIE);
   return DWARFDie();
 }
 
+static DWARFDie resolveDIEReference(const DwarfLinker &Linker,
+                                    const DebugMapObject &DMO,
+                                    const UnitListTy &Units,
+                                    const DWARFFormValue &RefValue,
+                                    const DWARFUnit &Unit, const DWARFDie &DIE,
+                                    CompileUnit *&RefCU) {
+  assert(RefValue.isFormClass(DWARFFormValue::FC_Reference));
+  uint64_t RefOffset = *RefValue.getAsReference();
+  return resolveDIEReference(Linker, DMO, Units, RefOffset, Unit, DIE, RefCU);
+}
+
 /// \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:
     return false;
   case dwarf::DW_AT_type:
   case dwarf::DW_AT_containing_type:
unsigned DwarfLinker::shouldKeepVariableDIE(RelocationManager &RelocMgr,
   const auto *Abbrev = DIE.getAbbreviationDeclarationPtr();
 
   // Global variables with constant value can always be kept.
   if (!(Flags & TF_InFunctionScope) &&
       Abbrev->findAttributeIndex(dwarf::DW_AT_const_value)) {
     MyInfo.InDebugMap = true;
     return Flags | TF_Keep;
   }
   
   Optional<uint32_t> LocationIdx =
       Abbrev->findAttributeIndex(dwarf::DW_AT_location);
   if (!LocationIdx)
     return Flags;
 
   uint32_t Offset = DIE.getOffset() + getULEB128Size(Abbrev->getCode());
   const DWARFUnit &OrigUnit = Unit.getOrigUnit();
   uint32_t LocationOffset, LocationEndOffset;
case dwarf::DW_TAG_imported_unit:
     return Flags | TF_Keep;
   default:
     break;
   }
 
   return Flags;
 }
 
+void DwarfLinker::scanExpressionDIERefs(
+    RelocationManager &RelocMgr, RangesTy &Ranges, const UnitListTy &Units,
+    const DWARFDie &DIE, DWARFExpression Expression, const DebugMapObject &DMO,
+    CompileUnit &CU, bool IsLittleEndian) {
+  uint32_t OpOffset = 0;
+  for (auto &Op : Expression) {
+    if (Op.getCode() == dwarf::DW_OP_convert) {
+      assert(OpOffset < Op.getEndOffset());
+      uint64_t RefOffset = Op.getRawOperand(0);
+      CompileUnit *ReferencedCU;
+      auto RefDie = resolveDIEReference(*this, DMO, Units, RefOffset,
+                                        CU.getOrigUnit(), DIE, ReferencedCU);
+      if (!RefDie)
+        continue;
+      assert(ReferencedCU == &CU);
+      lookForDIEsToKeep(RelocMgr, Ranges, Units, RefDie, DMO, *ReferencedCU,
+                        TF_Keep | TF_DependencyWalk, IsLittleEndian);
+      bool UseODR = false;
+      uint32_t RefIdx = ReferencedCU->getOrigUnit().getDIEIndex(RefDie);
+      CompileUnit::DIEInfo &Info = ReferencedCU->getInfo(RefIdx);
+      keepDIEAndDependencies(RelocMgr, Ranges, Units, RefDie, Info, DMO, CU,
+                             UseODR, IsLittleEndian);
+    }
+    OpOffset = Op.getEndOffset();
+  }
+}
+
+void DwarfLinker::scanExpressionDIERefs(
+    RelocationManager &RelocMgr, RangesTy &Ranges, const UnitListTy &Units,
+    const DWARFDie &DIE, const DWARFFormValue &AttrValue,
+    const DebugMapObject &DMO, CompileUnit &CU, bool IsLittleEndian) {
+  if (AttrValue.isFormClass(DWARFFormValue::FC_Block) ||
+      AttrValue.isFormClass(DWARFFormValue::FC_Exprloc)) {
+    ArrayRef<uint8_t> Expr = *AttrValue.getAsBlock();
+    DataExtractor Data(StringRef((const char *)Expr.data(), Expr.size()),
+                       IsLittleEndian, 0);
+    DWARFUnit &Unit = CU.getOrigUnit();
+    scanExpressionDIERefs(
+        RelocMgr, Ranges, Units, DIE,
+        DWARFExpression(Data, Unit.getVersion(), Unit.getAddressByteSize()),
+        DMO, CU, IsLittleEndian);
+    return;
+  }
+  // TODO: Implement DWARF 5 forms.
+}
+
 /// Mark the passed DIE as well as all the ones it depends on
 /// as kept.
 ///
 /// This function is called by lookForDIEsToKeep on DIEs that are
 /// newly discovered to be needed in the link. It recursively calls
 /// back to lookForDIEsToKeep while adding TF_DependencyWalk to the
 /// TraversalFlags to inform it that it's not doing the primary DIE
 /// tree walk.
 void DwarfLinker::keepDIEAndDependencies(
     RelocationManager &RelocMgr, RangesTy &Ranges, const UnitListTy &Units,
     const DWARFDie &Die, CompileUnit::DIEInfo &MyInfo,
-    const DebugMapObject &DMO, CompileUnit &CU, bool UseODR) {
+    const DebugMapObject &DMO, CompileUnit &CU, bool UseODR,
+    bool IsLittleEndian) {
   DWARFUnit &Unit = CU.getOrigUnit();
   MyInfo.Keep = true;
 
   // We're looking for incomplete types.
   MyInfo.Incomplete = Die.getTag() != dwarf::DW_TAG_subprogram &&
                       Die.getTag() != dwarf::DW_TAG_member &&
                       dwarf::toUnsigned(Die.find(dwarf::DW_AT_declaration), 0);
 
   // First mark all the parent chain as kept.
   unsigned AncestorIdx = MyInfo.ParentIdx;
   while (!CU.getInfo(AncestorIdx).Keep) {
     unsigned ODRFlag = UseODR ? TF_ODR : 0;
-    lookForDIEsToKeep(RelocMgr, Ranges, Units, Unit.getDIEAtIndex(AncestorIdx),
-                      DMO, CU,
-                      TF_ParentWalk | TF_Keep | TF_DependencyWalk | ODRFlag);
+    lookForDIEsToKeep(
+        RelocMgr, Ranges, Units, Unit.getDIEAtIndex(AncestorIdx), DMO, CU,
+        TF_ParentWalk | TF_Keep | TF_DependencyWalk | ODRFlag, IsLittleEndian);
     AncestorIdx = CU.getInfo(AncestorIdx).ParentIdx;
   }
 
   // Then we need to mark all the DIEs referenced by this DIE's
   // attributes as kept.
   DWARFDataExtractor Data = Unit.getDebugInfoExtractor();
   const auto *Abbrev = Die.getAbbreviationDeclarationPtr();
   uint32_t Offset = Die.getOffset() + getULEB128Size(Abbrev->getCode());
 
   // Mark all DIEs referenced through attributes as kept.
   for (const auto &AttrSpec : Abbrev->attributes()) {
     DWARFFormValue Val(AttrSpec.Form);
 
+    // Scan for DIE references in location descriptions.
+    if (DWARFAttribute::mayHaveLocationDescription(AttrSpec.Attr))
+      scanExpressionDIERefs(RelocMgr, Ranges, Units, Die,
+                            *Die.find(AttrSpec.Attr), DMO, CU, IsLittleEndian);
+
     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);
if (auto RefDie = resolveDIEReference(*this, DMO, Units, Val, Unit, Die,
 
       // Keep a module forward declaration if there is no definition.
       if (!(isODRAttribute(AttrSpec.Attr) && Info.Ctxt &&
             Info.Ctxt->getCanonicalDIEOffset()))
         Info.Prune = false;
 
       unsigned ODRFlag = UseODR ? TF_ODR : 0;
       lookForDIEsToKeep(RelocMgr, Ranges, Units, RefDie, DMO, *ReferencedCU,
-                        TF_Keep | TF_DependencyWalk | ODRFlag);
+                        TF_Keep | TF_DependencyWalk | ODRFlag, IsLittleEndian);
 
       // The incomplete property is propagated if the current DIE is complete
       // but references an incomplete DIE.
       if (Info.Incomplete && !MyInfo.Incomplete &&
           (Die.getTag() == dwarf::DW_TAG_typedef ||
            Die.getTag() == dwarf::DW_TAG_member ||
            Die.getTag() == dwarf::DW_TAG_reference_type ||
            Die.getTag() == dwarf::DW_TAG_ptr_to_member_type ||

 /// not respected. The TF_DependencyWalk flag tells us which kind of
 /// traversal we are currently doing.
 ///
 /// The return value indicates whether the DIE is incomplete.
 void DwarfLinker::lookForDIEsToKeep(RelocationManager &RelocMgr,
                                     RangesTy &Ranges, const UnitListTy &Units,
                                     const DWARFDie &Die,
                                     const DebugMapObject &DMO, CompileUnit &CU,
-                                    unsigned Flags) {
+                                    unsigned Flags, bool IsLittleEndian) {
   // LIFO work list.
   SmallVector<WorklistItem, 4> Worklist;
   Worklist.emplace_back(Die, Flags);
 
   while (!Worklist.empty()) {
     WorklistItem Current = Worklist.back();
     Worklist.pop_back();
 
while (!Worklist.empty()) {
 
     // If it is a newly kept DIE mark it as well as all its dependencies as
     // kept.
     if (!AlreadyKept && (Current.Flags & TF_Keep)) {
       bool UseOdr = (Current.Flags & TF_DependencyWalk)
                         ? (Current.Flags & TF_ODR)
                         : CU.hasODR();
       keepDIEAndDependencies(RelocMgr, Ranges, Units, Current.Die, MyInfo, DMO,
-                             CU, UseOdr);
+                             CU, UseOdr, IsLittleEndian);
     }
 
     // The TF_ParentWalk flag tells us that we are currently walking up
     // the parent chain of a required DIE, and we don't want to mark all
     // the children of the parents as kept (consider for example a
     // DW_TAG_namespace node in the parent chain). There are however a
     // set of DIE types for which we want to ignore that directive and still
     // walk their children.
if (AttrSpec.Form == dwarf::DW_FORM_ref_addr ||
     return U.getRefAddrByteSize();
   }
 
   Die.addValue(DIEAlloc, dwarf::Attribute(AttrSpec.Attr),
                dwarf::Form(AttrSpec.Form), DIEEntry(*NewRefDie));
   return AttrSize;
 }
 
-unsigned DwarfLinker::DIECloner::cloneBlockAttribute(DIE &Die,
-                                                     AttributeSpec AttrSpec,
-                                                     const DWARFFormValue &Val,
-                                                     unsigned AttrSize) {
+void DwarfLinker::DIECloner::cloneExpression(
+    DIEValueList *Attr, DataExtractor &Data, const DWARFDie &InputDIE,
+    DWARFExpression Expression, const DebugMapObject &DMO, CompileUnit &Unit) {
+  auto pushByte = [&](uint8_t Byte) {
+    Attr->addValue(DIEAlloc, static_cast<dwarf::Attribute>(0),
+                   dwarf::DW_FORM_data1, DIEInteger(Byte));
+  };
+
+  uint32_t OpOffset = 0;
+  for (auto &Op : Expression) {
+    if (Op.getCode() == dwarf::DW_OP_convert) {
+      assert(OpOffset < Op.getEndOffset());
+      uint32_t ULEBsize = Op.getEndOffset() - OpOffset - 1;
+      assert(ULEBsize <= 16);
+
+      uint64_t RefOffset = Op.getRawOperand(0);
+      auto RefDie = Unit.getOrigUnit().getDIEForOffset(RefOffset);
+      uint32_t RefIdx = Unit.getOrigUnit().getDIEIndex(RefDie);
+      CompileUnit::DIEInfo &Info = Unit.getInfo(RefIdx);
+      DIE *Clone = Info.Clone;
+      assert(Clone && "base type not created at beginning of CU");
+      uint32_t Offset = Clone->getOffset();
+      pushByte(dwarf::DW_OP_convert);
+      uint8_t Buffer[16];
+      unsigned RealSize = encodeULEB128(Offset, Buffer, ULEBsize);
+      if (RealSize > ULEBsize) {
+        memset(Buffer, dwarf::DW_OP_nop, ULEBsize);
+        Linker.reportWarning("DW_OP_convert type ref doesn't fit.", DMO,
+                             &InputDIE);
+      }
+      for (unsigned I = 0; I < ULEBsize; ++I)
+        pushByte(Buffer[I]);
+    } else {
+      // Copy over everything else unmodified.
+      for (unsigned I = OpOffset; I < Op.getEndOffset(); ++I)
+        pushByte(Data.getData()[I]);
+    }
+    OpOffset = Op.getEndOffset();
+  }
+}
+
+void DwarfLinker::DIECloner::cloneExpression(
+    DIEValueList *Attr, ArrayRef<uint8_t> Expr, const DWARFDie &InputDIE,
+    const DebugMapObject &DMO, CompileUnit &Unit, bool IsLittleEndian) {
+  DataExtractor Data(StringRef((const char *)Expr.data(), Expr.size()),
+                     IsLittleEndian, 0);
+  DWARFUnit &OrigUnit = Unit.getOrigUnit();
+  cloneExpression(Attr, Data, InputDIE,
+                  DWARFExpression(Data, OrigUnit.getVersion(),
+                                  OrigUnit.getAddressByteSize()),
+                  DMO, Unit);
+  // TODO: Implement DWARF 5 forms.
+}
+
+unsigned DwarfLinker::DIECloner::cloneBlockAttribute(
+    DIE &Die, const DWARFDie &InputDIE, const DebugMapObject &DMO,
+    CompileUnit &Unit, AttributeSpec AttrSpec, const DWARFFormValue &Val,
+    unsigned AttrSize, bool IsLittleEndian) {
   DIEValueList *Attr;
   DIEValue Value;
   DIELoc *Loc = nullptr;
   DIEBlock *Block = nullptr;
   // Just copy the block data over.
   if (AttrSpec.Form == dwarf::DW_FORM_exprloc) {
     Loc = new (DIEAlloc) DIELoc;
     Linker.DIELocs.push_back(Loc);
   } else {
     Block = new (DIEAlloc) DIEBlock;
     Linker.DIEBlocks.push_back(Block);
   }
   Attr = Loc ? static_cast<DIEValueList *>(Loc)
              : static_cast<DIEValueList *>(Block);
 
   if (Loc)
     Value = DIEValue(dwarf::Attribute(AttrSpec.Attr),
                      dwarf::Form(AttrSpec.Form), Loc);
   else
     Value = DIEValue(dwarf::Attribute(AttrSpec.Attr),
                      dwarf::Form(AttrSpec.Form), Block);
   ArrayRef<uint8_t> Bytes = *Val.getAsBlock();
+  if (DWARFAttribute::mayHaveLocationDescription(AttrSpec.Attr) &&
+      (Val.isFormClass(DWARFFormValue::FC_Block) ||
+       Val.isFormClass(DWARFFormValue::FC_Exprloc))) {
+    cloneExpression(Attr, Bytes, InputDIE, DMO, Unit, IsLittleEndian);
+  } else {
     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
   // Attr->setSize(Bytes.size()).
   if (Linker.Streamer) {
     auto *AsmPrinter = &Linker.Streamer->getAsmPrinter();
     if (Loc)
       Loc->ComputeSize(AsmPrinter);
     else
unsigned DwarfLinker::DIECloner::cloneScalarAttribute(
   if (AttrSpec.Attr == dwarf::DW_AT_ranges) {
     Unit.noteRangeAttribute(Die, Patch);
     Info.HasRanges = true;
   }
 
   // A more generic way to check for location attributes would be
   // nice, but it's very unlikely that any other attribute needs a
   // location list.
+  // FIXME: use DWARFAttribute::mayHaveLocationDescription().
   else if (AttrSpec.Attr == dwarf::DW_AT_location ||
-           AttrSpec.Attr == dwarf::DW_AT_frame_base)
     Unit.noteLocationAttribute(Patch, Info.PCOffset);
   else if (AttrSpec.Attr == dwarf::DW_AT_declaration && Value)
     Info.IsDeclaration = true;
 
   return AttrSize;
 }
 
 /// Clone \p InputDIE's attribute described by \p AttrSpec with
 /// value \p Val, and add it to \p Die.
 /// \returns the size of the cloned attribute.
 unsigned DwarfLinker::DIECloner::cloneAttribute(
     DIE &Die, const DWARFDie &InputDIE, const DebugMapObject &DMO,
     CompileUnit &Unit, OffsetsStringPool &StringPool, const DWARFFormValue &Val,
-    const AttributeSpec AttrSpec, unsigned AttrSize, AttributesInfo &Info) {
+    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,
                                       DMO, 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, AttrSpec, Val, AttrSize);
+    return cloneBlockAttribute(Die, InputDIE, DMO, 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:

 /// the buffer \p Data, taking into account that Data is at \p BaseOffset
 /// in the debug_info section.
 ///
 /// Like for findValidRelocs(), this function must be called with
 /// monotonic \p BaseOffset values.
 ///
 /// \returns whether any reloc has been applied.
 bool DwarfLinker::RelocationManager::applyValidRelocs(
-    MutableArrayRef<char> Data, uint32_t BaseOffset, bool isLittleEndian) {
+    MutableArrayRef<char> Data, uint32_t BaseOffset, bool IsLittleEndian) {
   assert((NextValidReloc == 0 ||
           BaseOffset > ValidRelocs[NextValidReloc - 1].Offset) &&
          "BaseOffset should only be increasing.");
   if (NextValidReloc >= ValidRelocs.size())
     return false;
 
   // Skip relocs that haven't been applied.
   while (NextValidReloc < ValidRelocs.size() &&
          ValidRelocs[NextValidReloc].Offset < BaseOffset)
     ++NextValidReloc;
 
   bool Applied = false;
   uint64_t EndOffset = BaseOffset + Data.size();
   while (NextValidReloc < ValidRelocs.size() &&
          ValidRelocs[NextValidReloc].Offset >= BaseOffset &&
          ValidRelocs[NextValidReloc].Offset < EndOffset) {
     const auto &ValidReloc = ValidRelocs[NextValidReloc++];
     assert(ValidReloc.Offset - BaseOffset < Data.size());
     assert(ValidReloc.Offset - BaseOffset + ValidReloc.Size <= Data.size());
     char Buf[8];
     uint64_t Value = ValidReloc.Mapping->getValue().BinaryAddress;
     Value += ValidReloc.Addend;
     for (unsigned i = 0; i != ValidReloc.Size; ++i) {
-      unsigned Index = isLittleEndian ? i : (ValidReloc.Size - i - 1);
+      unsigned Index = IsLittleEndian ? i : (ValidReloc.Size - i - 1);
       Buf[i] = uint8_t(Value >> (Index * 8));
     }
     assert(ValidReloc.Size <= sizeof(Buf));
     memcpy(&Data[ValidReloc.Offset - BaseOffset], Buf, ValidReloc.Size);
     Applied = true;
   }
 
   return Applied;
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 DebugMapObject &DMO,
-                                      CompileUnit &Unit,
-                                      OffsetsStringPool &StringPool,
-                                      int64_t PCOffset, uint32_t OutOffset,
-                                      unsigned Flags, DIE *Die) {
+DIE *DwarfLinker::DIECloner::cloneDIE(
+    const DWARFDie &InputDIE, const DebugMapObject &DMO, CompileUnit &Unit,
+    OffsetsStringPool &StringPool, int64_t PCOffset, uint32_t OutOffset,
+    unsigned Flags, bool IsLittleEndian, DIE *Die) {
   DWARFUnit &U = Unit.getOrigUnit();
   unsigned Idx = U.getDIEIndex(InputDIE);
   CompileUnit::DIEInfo &Info = Unit.getInfo(Idx);
 
   // Should the DIE appear in the output?
   if (!Unit.getInfo(Idx).Keep)
     return nullptr;
 
for (const auto &AttrSpec : Abbrev->attributes()) {
     }
 
     DWARFFormValue Val(AttrSpec.Form);
     uint32_t AttrSize = Offset;
     Val.extractValue(Data, &Offset, U.getFormParams(), &U);
     AttrSize = Offset - AttrSize;
 
     OutOffset += cloneAttribute(*Die, InputDIE, DMO, Unit, StringPool, Val,
-                                AttrSpec, AttrSize, AttrInfo);
+                                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.
   if ((Info.InDebugMap || AttrInfo.HasLowPc || AttrInfo.HasRanges) &&
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, DMO, Unit, StringPool, PCOffset, OutOffset,
-                              Flags)) {
+                              Flags, IsLittleEndian)) {
       Die->addChild(Clone);
       OutOffset = Clone->getOffset() + Clone->getSize();
     }
   }
 
   // Account for the end of children marker.
   OutOffset += sizeof(int8_t);
   // Update our size.
if (DwoId)
     return *DwoId;
   return 0;
 }
 
 bool DwarfLinker::registerModuleReference(
     const DWARFDie &CUDie, const DWARFUnit &Unit, DebugMap &ModuleMap,
     const DebugMapObject &DMO, RangesTy &Ranges, OffsetsStringPool &StringPool,
     UniquingStringPool &UniquingStringPool, DeclContextTree &ODRContexts,
-    uint64_t ModulesEndOffset, unsigned &UnitID, unsigned Indent, bool Quiet) {
+    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.
   std::string PCMpath = dwarf::toString(CUDie.find(dwarf::DW_AT_comp_dir), "");
   uint64_t DwoId = getDwoId(CUDie, Unit);
if (Cached != ClangModules.end()) {
     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(PCMfile, PCMpath, Name, DwoId, ModuleMap, DMO, Ranges,
-                          StringPool, UniquingStringPool, ODRContexts,
-                          ModulesEndOffset, UnitID, Indent + 2, Quiet)) {
+  if (Error E = loadClangModule(PCMfile, PCMpath, Name, DwoId, ModuleMap, DMO,
+                                Ranges, StringPool, UniquingStringPool,
+                                ODRContexts, ModulesEndOffset, UnitID,
+                                IsLittleEndian, Indent + 2, Quiet)) {
     consumeError(std::move(E));
     return false;
   }
   return true;
 }
 
 ErrorOr<const object::ObjectFile &>
 DwarfLinker::loadObject(const DebugMapObject &Obj, const DebugMap &Map) {
DwarfLinker::loadObject(const DebugMapObject &Obj, const DebugMap &Map) {
   return *Object;
 }
 
 Error DwarfLinker::loadClangModule(
     StringRef Filename, StringRef ModulePath, StringRef ModuleName,
     uint64_t DwoId, DebugMap &ModuleMap, const DebugMapObject &DMO,
     RangesTy &Ranges, OffsetsStringPool &StringPool,
     UniquingStringPool &UniquingStringPool, DeclContextTree &ODRContexts,
-    uint64_t ModulesEndOffset, unsigned &UnitID, unsigned Indent, bool Quiet) {
+    uint64_t ModulesEndOffset, unsigned &UnitID, bool IsLittleEndian,
+    unsigned Indent, bool Quiet) {
   SmallString<80> Path(Options.PrependPath);
   if (sys::path::is_relative(Filename))
     sys::path::append(Path, ModulePath, Filename);
   else
     sys::path::append(Path, Filename);
   // Don't use the cached binary holder because we have no thread-safety
   // guarantee and the lifetime is limited.
   auto &Obj = ModuleMap.addDebugMapObject(
Error DwarfLinker::loadClangModule(
   for (const auto &CU : DwarfContext->compile_units()) {
     updateDwarfVersion(CU->getVersion());
     // Recursively get all modules imported by this one.
     auto CUDie = CU->getUnitDIE(false);
     if (!CUDie)
       continue;
     if (!registerModuleReference(CUDie, *CU, ModuleMap, DMO, Ranges, StringPool,
                                  UniquingStringPool, ODRContexts,
-                                 ModulesEndOffset, UnitID, Indent, Quiet)) {
+                                 ModulesEndOffset, UnitID, IsLittleEndian,
+                                 Indent, Quiet)) {
       if (Unit) {
         std::string Err =
             (Filename +
              ": Clang modules are expected to have exactly 1 compile unit.\n")
                 .str();
         error(Err);
         return make_error<StringError>(Err, inconvertibleErrorCode());
       }
Error DwarfLinker::loadClangModule(
   if (!Quiet && Options.Verbose) {
     outs().indent(Indent);
     outs() << "cloning .debug_info from " << Filename << "\n";
   }
 
   UnitListTy CompileUnits;
   CompileUnits.push_back(std::move(Unit));
   DIECloner(*this, RelocMgr, DIEAlloc, CompileUnits, Options)
-      .cloneAllCompileUnits(*DwarfContext, DMO, Ranges, StringPool);
+      .cloneAllCompileUnits(*DwarfContext, DMO, Ranges, StringPool,
+                            IsLittleEndian);
   return Error::success();
 }
 
 void DwarfLinker::DIECloner::cloneAllCompileUnits(
     DWARFContext &DwarfContext, const DebugMapObject &DMO, RangesTy &Ranges,
-    OffsetsStringPool &StringPool) {
+    OffsetsStringPool &StringPool, bool IsLittleEndian) {
   if (!Linker.Streamer)
     return;
 
   for (auto &CurrentUnit : CompileUnits) {
     auto InputDIE = CurrentUnit->getOrigUnit().getUnitDIE();
     CurrentUnit->setStartOffset(Linker.OutputDebugInfoSize);
     if (!InputDIE) {
       Linker.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, DMO, *CurrentUnit, StringPool, 0 /* PC offset */,
-               11 /* Unit Header size */, 0, CurrentUnit->getOutputUnitDIE());
+               11 /* Unit Header size */, 0, IsLittleEndian,
+               CurrentUnit->getOutputUnitDIE());
     }
 
     Linker.OutputDebugInfoSize = CurrentUnit->computeNextUnitOffset();
 
     if (Linker.Options.NoOutput)
       continue;
 
     // FIXME: for compatibility with the classic dsymutil, we emit
for (const auto &CU : LinkContext.DwarfContext->compile_units()) {
         DIDumpOptions DumpOpts;
         DumpOpts.RecurseDepth = 0;
         DumpOpts.Verbose = Options.Verbose;
         CUDie.dump(outs(), 0, DumpOpts);
       }
       if (CUDie && !LLVM_UNLIKELY(Options.Update))
         registerModuleReference(CUDie, *CU, ModuleMap, LinkContext.DMO,
                                 LinkContext.Ranges, OffsetsStringPool,
-                                UniquingStringPool, ODRContexts, 0, UnitID);
+                                UniquingStringPool, ODRContexts, 0, UnitID,
+                                LinkContext.DwarfContext->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
auto CloneLambda = [&](size_t i) {
     // cross-cu references require the ParentIdx to be setup for every CU in
     // the object file before calling this.
     if (LLVM_UNLIKELY(Options.Update)) {
       for (auto &CurrentUnit : LinkContext.CompileUnits)
         CurrentUnit->markEverythingAsKept();
       Streamer->copyInvariantDebugSection(*LinkContext.ObjectFile);
     } else {
       for (auto &CurrentUnit : LinkContext.CompileUnits)
-        lookForDIEsToKeep(LinkContext.RelocMgr, LinkContext.Ranges,
-                          LinkContext.CompileUnits,
-                          CurrentUnit->getOrigUnit().getUnitDIE(),
-                          LinkContext.DMO, *CurrentUnit, 0);
+        lookForDIEsToKeep(
+            LinkContext.RelocMgr, LinkContext.Ranges, LinkContext.CompileUnits,
+            CurrentUnit->getOrigUnit().getUnitDIE(), LinkContext.DMO,
+            *CurrentUnit, 0, LinkContext.DwarfContext->isLittleEndian());
     }
 
     // The calls to applyValidRelocs inside cloneDIE will walk the reloc
     // array again (in the same way findValidRelocsInDebugInfo() did). We
     // need to reset the NextValidReloc index to the beginning.
     LinkContext.RelocMgr.resetValidRelocs();
     if (LinkContext.RelocMgr.hasValidRelocs() || LLVM_UNLIKELY(Options.Update))
       DIECloner(*this, LinkContext.RelocMgr, DIEAlloc, LinkContext.CompileUnits,
                 Options)
           .cloneAllCompileUnits(*LinkContext.DwarfContext, LinkContext.DMO,
-                                LinkContext.Ranges, OffsetsStringPool);
+                                LinkContext.Ranges, OffsetsStringPool,
+                                LinkContext.DwarfContext->isLittleEndian());
     if (!Options.NoOutput && !LinkContext.CompileUnits.empty() &&
         LLVM_LIKELY(!Options.Update))
       patchFrameInfoForObject(
           LinkContext.DMO, LinkContext.Ranges, *LinkContext.DwarfContext,
           LinkContext.CompileUnits[0]->getOrigUnit().getAddressByteSize());
 
     // Clean-up before starting working on the next object.
     endDebugObject(LinkContext);