[DWARFLinker][DWARFv5] Add handling of DW_OP_addrx and DW_OP_constx expression operands.

[avl]

Summary

This patch adds handling of DW_OP_addrx and DW_OP_constx expression operands.
In --update case these operands are preserved as is. Otherwise they are
converted into the DW_OP_addr and DW_OP_const[*]u correspondingly.

[avl]

friendly ping.

[JDevlieghere]

llvm/include/llvm/DWARFLinker/DWARFLinkerCompileUnit.h

58–72

Instead of wrapping PatchLocation in another struct, would it make sense to add the RelocAdjustment to the PatchLocation itself?

llvm/lib/DWARFLinker/DWARFLinker.cpp

1216

1235

1249

llvm/tools/dsymutil/DwarfLinkerForBinary.cpp

1022–1060

The code to parse the exprloc here is very similar to that in the dsymutil variant. Any chance we could hoist some of this logic into the DWARFLinker?

[avl]

addressed comments. Deleted PatchWithRelocAdjustment. Refactored code parsing the exprloc.

[avl]

ping

[avl]

rebased.

[avl]

friendly ping :-)

[JDevlieghere]

LGTM!

[avl]

Thanks!

[amyk]

Hi, it appears that this patch is causing some failures on the big endian PPC bots, such as:
https://lab.llvm.org/buildbot/#/builders/93/builds/14929
https://lab.llvm.org/buildbot/#/builders/231/builds/11866

If you're able to help take a look at this, that would be greatly appreciated.

[avl]

Thank you for reporting the issue, the https://reviews.llvm.org/rGddf5bfd6e6e2fc5b94718a29e718b4f821a3b853 should fix it.

[avl]

In D147066#4349098, @avl wrote:

Thank you for reporting the issue, the https://reviews.llvm.org/rGddf5bfd6e6e2fc5b94718a29e718b4f821a3b853 should fix it.

It did not fix the problem. Will look more.

[avl]

@amyk finally fixed with https://reviews.llvm.org/rGa0a30965d0a9d42e15a48992f8cefede7ca07b9b

[amyk]

In D147066#4350179, @avl wrote:

@amyk finally fixed with https://reviews.llvm.org/rGa0a30965d0a9d42e15a48992f8cefede7ca07b9b

Thanks so much for the fix! Greatly appreciate it.

[glandium]

FWIW, this caused https://github.com/llvm/llvm-project/issues/62874

[Michael137]

Looks like this broke the lldb matrix bots for DWARFv2: https://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake-matrix/6580/execution/node/54/log/

********************
Failed Tests (2):
  lldb-api :: lang/c/tls_globals/TestTlsGlobals.py
  lldb-api :: lang/cpp/thread_local/TestThreadLocal.py

The problem is that dsymutil strips out thread_local variables when the binary is compiled with -gdwarf-2.

Reproducer:

int storage = 45;                          
thread_local int tl_global_int = 123;      
thread_local int *tl_global_ptr = &storage;
                                           
int main(int argc, char **argv) {          
  thread_local int tl_local_int = 321;     
  thread_local int *tl_local_ptr = nullptr;
  tl_local_ptr = &tl_local_int;            
  tl_local_int++;                          
  return 0; // Set breakpoint here         
}                                          

clang++ -g -O0 -gdwarf-2 -c main.cpp -o main.o -std=c++2a
clang++ main.o -o a.out
dsymutil a.out
dwarfdump a.out.dSYM --find tl_global_ptr

Observe that there is no entry for tl_global_ptr anymore. Compiling with -gdwarf-4 doesn't behave this way.

[avl]

In D147066#4420549, @Michael137 wrote:

Looks like this broke the lldb matrix bots for DWARFv2: https://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake-matrix/6580/execution/node/54/log/

********************
Failed Tests (2):
  lldb-api :: lang/c/tls_globals/TestTlsGlobals.py
  lldb-api :: lang/cpp/thread_local/TestThreadLocal.py

The problem is that dsymutil strips out thread_local variables when the binary is compiled with -gdwarf-2.

Reproducer:

int storage = 45;                          
thread_local int tl_global_int = 123;      
thread_local int *tl_global_ptr = &storage;
                                           
int main(int argc, char **argv) {          
  thread_local int tl_local_int = 321;     
  thread_local int *tl_local_ptr = nullptr;
  tl_local_ptr = &tl_local_int;            
  tl_local_int++;                          
  return 0; // Set breakpoint here         
}                                          

clang++ -g -O0 -gdwarf-2 -c main.cpp -o main.o -std=c++2a
clang++ main.o -o a.out
dsymutil a.out
dwarfdump a.out.dSYM --find tl_global_ptr

Observe that there is no entry for tl_global_ptr anymore. Compiling with -gdwarf-4 doesn't behave this way.

Thank you for reporting the issue. Will take a look.

[aprantl]

FWIW, depending on what the actual problem is, you don't need to go out of your way to fix TLS on dwarf 2. I'd be fine with marking these tests as requiring DWARF 4+ in the LLDB test suite if that makes sense.

[avl]

@Michael137 Should be fixed by D153010

llvm/include/llvm/DWARFLinker/DWARFLinker.h

 #include "llvm/ADT/AddressRanges.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/CodeGen/AccelTable.h"
 #include "llvm/CodeGen/NonRelocatableStringpool.h"
 #include "llvm/DWARFLinker/DWARFLinkerCompileUnit.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugLine.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugRangeList.h"
 #include "llvm/DebugInfo/DWARF/DWARFDie.h"
+#include "llvm/DebugInfo/DWARF/DWARFExpression.h"
 #include <map>
 
 namespace llvm {
 class DWARFContext;
 class DWARFExpression;
 class DWARFUnit;
 class DataExtractor;
 class DeclContextTree;

 class AddressesMap {
 public:
   virtual ~AddressesMap();
 
   /// Checks that there are valid relocations against a .debug_info
   /// section.
   virtual bool hasValidRelocs() = 0;
 
-  /// Checks that the specified variable \p DIE references the live code
-  /// section and returns the relocation adjustment value (to get the linked
-  /// address this value might be added to the source variable address).
-  /// Allowed kinds of input DIE: DW_TAG_variable, DW_TAG_constant.
+  /// Checks that the specified DWARF expression operand \p Op references live
+  /// code section and returns the relocation adjustment value (to get the
+  /// linked address this value might be added to the source expression operand
+  /// address).
   /// \returns relocation adjustment value or std::nullopt if there is no
   /// corresponding live address.
   virtual std::optional<int64_t>
-  getVariableRelocAdjustment(const DWARFDie &DIE) = 0;
+  getExprOpAddressRelocAdjustment(DWARFUnit &U,
+                                  const DWARFExpression::Operation &Op,
+                                  uint64_t StartOffset, uint64_t EndOffset) = 0;
 
   /// Checks that the specified subprogram \p DIE references the live code
   /// section and returns the relocation adjustment value (to get the linked
   /// address this value might be added to the source subprogram address).
   /// Allowed kinds of input DIE: DW_TAG_subprogram, DW_TAG_label.
   /// \returns relocation adjustment value or std::nullopt if there is no
   /// corresponding live address.
   virtual std::optional<int64_t>
void keepDIEAndDependencies(AddressesMap &RelocMgr, RangesTy &Ranges,
                               const DWARFFile &File, CompileUnit &CU,
                               bool UseODR);
 
   unsigned shouldKeepDIE(AddressesMap &RelocMgr, RangesTy &Ranges,
                          const DWARFDie &DIE, const DWARFFile &File,
                          CompileUnit &Unit, CompileUnit::DIEInfo &MyInfo,
                          unsigned Flags);
 
+  /// This function checks whether variable has DWARF expression containing
+  /// operation referencing live address(f.e. DW_OP_addr, DW_OP_addrx...).
+  /// \returns relocation adjustment value if live address is referenced.
+  std::optional<int64_t> getVariableRelocAdjustment(AddressesMap &RelocMgr,
+                                                    const DWARFDie &DIE);
+
   /// Check if a variable describing DIE should be kept.
   /// \returns updated TraversalFlags.
   unsigned shouldKeepVariableDIE(AddressesMap &RelocMgr, const DWARFDie &DIE,
                                  CompileUnit::DIEInfo &MyInfo, unsigned Flags);
 
   unsigned shouldKeepSubprogramDIE(AddressesMap &RelocMgr, RangesTy &Ranges,
                                    const DWARFDie &DIE, const DWARFFile &File,
                                    CompileUnit &Unit,
unsigned cloneDieReferenceAttribute(DIE &Die, const DWARFDie &InputDIE,
                                         unsigned AttrSize,
                                         const DWARFFormValue &Val,
                                         const DWARFFile &File,
                                         CompileUnit &Unit);
 
     /// Clone a DWARF expression that may be referencing another DIE.
     void cloneExpression(DataExtractor &Data, DWARFExpression Expression,
                          const DWARFFile &File, CompileUnit &Unit,
-                         SmallVectorImpl<uint8_t> &OutputBuffer);
+                         SmallVectorImpl<uint8_t> &OutputBuffer,
+                         int64_t AddrRelocAdjustment);
 
     /// Clone an attribute referencing another DIE and add
     /// it to \p Die.
     /// \returns the size of the new attribute.
-    unsigned cloneBlockAttribute(DIE &Die, const DWARFFile &File,
-                                 CompileUnit &Unit, AttributeSpec AttrSpec,
-                                 const DWARFFormValue &Val, unsigned AttrSize,
+    unsigned cloneBlockAttribute(DIE &Die, const DWARFDie &InputDIE,
+                                 const DWARFFile &File, CompileUnit &Unit,
+                                 AttributeSpec AttrSpec,
+                                 const DWARFFormValue &Val,
                                  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, const DWARFDie &InputDIE,
                                    AttributeSpec AttrSpec, unsigned AttrSize,
                                    const DWARFFormValue &Val,
private:
 
   /// Assign an abbreviation number to \p Abbrev
   void assignAbbrev(DIEAbbrev &Abbrev);
 
   /// Compute and emit debug ranges(.debug_aranges, .debug_ranges,
   /// .debug_rnglists) for \p Unit, patch the attributes referencing it.
   void generateUnitRanges(CompileUnit &Unit, const DWARFFile &File) const;
 
-  using ExpressionHandlerRef = function_ref<void(SmallVectorImpl<uint8_t> &,
-                                                 SmallVectorImpl<uint8_t> &)>;
+  using ExpressionHandlerRef =
+      function_ref<void(SmallVectorImpl<uint8_t> &, SmallVectorImpl<uint8_t> &,
+                        int64_t AddrRelocAdjustment)>;
 
   /// Compute and emit debug locations (.debug_loc, .debug_loclists)
   /// for \p Unit, patch the attributes referencing it.
   void generateUnitLocations(CompileUnit &Unit, const DWARFFile &File,
                              ExpressionHandlerRef ExprHandler) const;
 
   /// Emit the accelerator entries for \p Unit.
   void emitAcceleratorEntriesForUnit(CompileUnit &Unit);

llvm/include/llvm/DWARFLinker/DWARFLinkerCompileUnit.h

 namespace llvm {
 
 class DeclContext;
 
 /// Mapped value in the address map is the offset to apply to the
 /// linked address.
 using RangesTy = AddressRangesMap;
 
-// FIXME: Delete this structure.
+// This structure keeps patch for the attribute and, optionally,
+// the value of relocation which should be applied. Currently,
+// only location attribute needs to have relocation: either to the
+// function ranges if location attribute is of type 'loclist',
+// either to the operand of DW_OP_addr/DW_OP_addrx if location attribute
+// is of type 'exprloc'.
+// ASSUMPTION: Location attributes of 'loclist' type containing 'exprloc'
+//             with address expression operands are not supported yet.
 struct PatchLocation {
   DIE::value_iterator I;
+  int64_t RelocAdjustment = 0;
 
   PatchLocation() = default;
   PatchLocation(DIE::value_iterator I) : I(I) {}
+  PatchLocation(DIE::value_iterator I, int64_t Reloc)
+      : I(I), RelocAdjustment(Reloc) {}
 
   void set(uint64_t New) const {
     assert(I);
     const auto &Old = *I;
     assert(Old.getType() == DIEValue::isInteger);
     *I = DIEValue(Old.getAttribute(), Old.getForm(), DIEInteger(New));
   }
 
   uint64_t get() const {
     assert(I);
     return I->getDIEInteger().getValue();
   }
 };
 
 using RngListAttributesTy = SmallVector<PatchLocation>;
-using LocListAttributesTy = SmallVector<std::pair<PatchLocation, int64_t>>;
+using LocListAttributesTy = SmallVector<PatchLocation>;
 
 /// Stores all information relating to a compile unit, be it in its original
 /// instance in the object file to its brand new cloned and generated DIE tree.
 class CompileUnit {
 public:
   /// Information gathered about a DIE in the object file.
   struct DIEInfo {
     /// Address offset to apply to the described entity.
     int64_t AddrAdjust;
 
     /// ODR Declaration context.
     DeclContext *Ctxt;
 
     /// Cloned version of that DIE.
     DIE *Clone;
 
     /// The index of this DIE's parent.
     uint32_t ParentIdx;
 
     /// Is the DIE part of the linked output?
     bool Keep : 1;
 
     /// Was this DIE's entity found in the map?
#endif // if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
   /// offset \p PCOffset.
   void addFunctionRange(uint64_t LowPC, uint64_t HighPC, int64_t PCOffset);
 
   /// Keep track of a DW_AT_range attribute that we will need to patch up later.
   void noteRangeAttribute(const DIE &Die, PatchLocation Attr);
 
   /// Keep track of a location attribute pointing to a location list in the
   /// debug_loc section.
-  void noteLocationAttribute(PatchLocation Attr, int64_t PcOffset);
+  void noteLocationAttribute(PatchLocation Attr);
 
   /// Add a name accelerator entry for \a Die with \a Name.
   void addNamespaceAccelerator(const DIE *Die, DwarfStringPoolEntryRef Name);
 
   /// Add a name accelerator entry for \a Die with \a Name.
   void addNameAccelerator(const DIE *Die, DwarfStringPoolEntryRef Name,
                           bool SkipPubnamesSection = false);
 
private:
   /// 'rnglist'(DW_AT_ranges, DW_AT_start_scope) attributes to patch after
   /// we have gathered all the unit's function addresses.
   /// @{
   RngListAttributesTy RangeAttributes;
   std::optional<PatchLocation> UnitRangeAttribute;
   /// @}
 
   /// Location attributes that need to be transferred from the
-  /// original debug_loc section to the liked one. They are stored
+  /// original debug_loc section to the linked one. They are stored
   /// along with the PC offset that is to be applied to their
-  /// function's address.
+  /// function's address or to be applied to address operands of
+  /// location expression.
   LocListAttributesTy LocationAttributes;
 
   /// Accelerator entries for the unit, both for the pub*
   /// sections and the apple* ones.
   /// @{
   std::vector<AccelInfo> Pubnames;
   std::vector<AccelInfo> Pubtypes;
   std::vector<AccelInfo> Namespaces;

llvm/include/llvm/DWARFLinkerParallel/AddressesMap.h

 //===- AddressesMap.h -------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DWARFLINKERPARALLEL_ADDRESSESMAP_H
 #define LLVM_DWARFLINKERPARALLEL_ADDRESSESMAP_H
 
 #include "llvm/ADT/AddressRanges.h"
 #include "llvm/DebugInfo/DWARF/DWARFDie.h"
+#include "llvm/DebugInfo/DWARF/DWARFExpression.h"
 #include <cstdint>
 
 namespace llvm {
 namespace dwarflinker_parallel {
 
 /// Mapped value in the address map is the offset to apply to the
 /// linked address.
 using RangesTy = AddressRangesMap;
 
 /// AddressesMap represents information about valid addresses used
 /// by debug information. Valid addresses are those which points to
 /// live code sections. i.e. relocations for these addresses point
 /// into sections which would be/are placed into resulting binary.
 class AddressesMap {
 public:
   virtual ~AddressesMap() = default;
 
   /// Checks that there are valid relocations in the .debug_info
   /// section.
   virtual bool hasValidRelocs() = 0;
 
-  /// Checks that the specified variable \p DIE references the live code
-  /// section and returns the relocation adjustment value (to get the linked
-  /// address this value might be added to the source variable address).
-  /// Allowed kinds of input DIE: DW_TAG_variable, DW_TAG_constant.
+  /// Checks that the specified DWARF expression operand \p Op references live
+  /// code section and returns the relocation adjustment value (to get the
+  /// linked address this value might be added to the source expression operand
+  /// address).
   /// \returns relocation adjustment value or std::nullopt if there is no
   /// corresponding live address.
   virtual std::optional<int64_t>
-  getVariableRelocAdjustment(const DWARFDie &DIE) = 0;
+  getExprOpAddressRelocAdjustment(DWARFUnit &U,
+                                  const DWARFExpression::Operation &Op,
+                                  uint64_t StartOffset, uint64_t EndOffset) = 0;
 
   /// Checks that the specified subprogram \p DIE references the live code
   /// section and returns the relocation adjustment value (to get the linked
   /// address this value might be added to the source subprogram address).
   /// Allowed kinds of input DIE: DW_TAG_subprogram, DW_TAG_label.
   /// \returns relocation adjustment value or std::nullopt if there is no
   /// corresponding live address.
   virtual std::optional<int64_t>

llvm/lib/DWARFLinker/DWARFLinker.cpp

void DWARFLinker::cleanupAuxiliarryData(LinkContext &Context) {
   for (DIELoc *I : DIELocs)
     I->~DIELoc();
 
   DIEBlocks.clear();
   DIELocs.clear();
   DIEAlloc.Reset();
 }
 
+std::optional<int64_t>
+DWARFLinker::getVariableRelocAdjustment(AddressesMap &RelocMgr,
+                                        const DWARFDie &DIE) {
+  assert((DIE.getTag() == dwarf::DW_TAG_variable ||
+          DIE.getTag() == dwarf::DW_TAG_constant) &&
+         "Wrong type of input die");
+
+  const auto *Abbrev = DIE.getAbbreviationDeclarationPtr();
+
+  // Check if DIE has DW_AT_location attribute.
+  DWARFUnit *U = DIE.getDwarfUnit();
+  std::optional<uint32_t> LocationIdx =
+      Abbrev->findAttributeIndex(dwarf::DW_AT_location);
+  if (!LocationIdx)
+    return std::nullopt;
+
+  // Get offset to the DW_AT_location attribute.
+  uint64_t AttrOffset =
+      Abbrev->getAttributeOffsetFromIndex(*LocationIdx, DIE.getOffset(), *U);
+
+  // Get value of the DW_AT_location attribute.
+  std::optional<DWARFFormValue> LocationValue =
+      Abbrev->getAttributeValueFromOffset(*LocationIdx, AttrOffset, *U);
+  if (!LocationValue)
+    return std::nullopt;
+
+  // Check that DW_AT_location attribute is of 'exprloc' class.
+  // Handling value of location expressions for attributes of 'loclist'
+  // class is not implemented yet.
+  std::optional<ArrayRef<uint8_t>> Expr = LocationValue->getAsBlock();
+  if (!Expr)
+    return std::nullopt;
+
+  // Parse 'exprloc' expression.
+  DataExtractor Data(toStringRef(*Expr), U->getContext().isLittleEndian(),
+                     U->getAddressByteSize());
+  DWARFExpression Expression(Data, U->getAddressByteSize(),
+                             U->getFormParams().Format);
+
+  uint64_t CurExprOffset = 0;
+  for (DWARFExpression::iterator It = Expression.begin();
+       It != Expression.end(); ++It) {
+    DWARFExpression::iterator NextIt = It;
+    ++NextIt;
+
+    const DWARFExpression::Operation &Op = *It;
+    switch (Op.getCode()) {
+    case dwarf::DW_OP_const4u:
+    case dwarf::DW_OP_const8u:
+    case dwarf::DW_OP_const4s:
+    case dwarf::DW_OP_const8s:
+      if (NextIt == Expression.end() ||
+          NextIt->getCode() != dwarf::DW_OP_form_tls_address)
+        break;
+      [[fallthrough]];
+    case dwarf::DW_OP_addr: {
+      // Check relocation for the address.
+      if (std::optional<int64_t> RelocAdjustment =
+              RelocMgr.getExprOpAddressRelocAdjustment(
+                  *U, Op, AttrOffset + CurExprOffset,
+                  AttrOffset + Op.getEndOffset()))
+        return *RelocAdjustment;
+    } break;
+    case dwarf::DW_OP_constx:
+    case dwarf::DW_OP_addrx: {
+      if (std::optional<uint64_t> AddrOffsetSectionBase =
+              DIE.getDwarfUnit()->getAddrOffsetSectionBase()) {
+        uint64_t StartOffset = *AddrOffsetSectionBase + Op.getRawOperand(0);
+        uint64_t EndOffset =
+            StartOffset + DIE.getDwarfUnit()->getAddressByteSize();
+
+        // Check relocation for the address.
+        if (std::optional<int64_t> RelocAdjustment =
+                RelocMgr.getExprOpAddressRelocAdjustment(*U, Op, StartOffset,
+                                                         EndOffset))
+          return *RelocAdjustment;
+      }
+    } break;
+    default: {
+      // Nothing to do.
+    } break;
+    }
+    CurExprOffset = Op.getEndOffset();
+  }
+
+  return std::nullopt;
+}
+
 /// Check if a variable describing DIE should be kept.
 /// \returns updated TraversalFlags.
 unsigned DWARFLinker::shouldKeepVariableDIE(AddressesMap &RelocMgr,
                                             const DWARFDie &DIE,
                                             CompileUnit::DIEInfo &MyInfo,
                                             unsigned Flags) {
   const auto *Abbrev = DIE.getAbbreviationDeclarationPtr();
 
   // 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;
   }
 
   // See if there is a relocation to a valid debug map entry inside this
   // variable's location. The order is important here. We want to always check
   // if the variable has a valid relocation, so that the DIEInfo is filled.
   // However, we don't want a static variable in a function to force us to keep
   // the enclosing function, unless requested explicitly.
   std::optional<int64_t> RelocAdjustment =
-      RelocMgr.getVariableRelocAdjustment(DIE);
+      getVariableRelocAdjustment(RelocMgr, DIE);
 
   if (RelocAdjustment) {
     MyInfo.AddrAdjust = *RelocAdjustment;
     MyInfo.InDebugMap = true;
   }
 
   if (!RelocAdjustment || ((Flags & TF_InFunctionScope) &&
                            !LLVM_UNLIKELY(Options.KeepFunctionForStatic)))
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 DWARFFile &File,
-    CompileUnit &Unit, SmallVectorImpl<uint8_t> &OutputBuffer) {
+    CompileUnit &Unit, SmallVectorImpl<uint8_t> &OutputBuffer,
+    int64_t AddrRelocAdjustment) {
   using Encoding = DWARFExpression::Operation::Encoding;
 
+  uint8_t OrigAddressByteSize = Unit.getOrigUnit().getAddressByteSize();
+
   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) ||
if ((Op0 == Encoding::BaseTypeRef && Op1 == Encoding::SizeNA) ||
       if (RealSize > ULEBsize) {
         // Emit the generic type as a fallback.
         RealSize = encodeULEB128(0, ULEB, ULEBsize);
         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 if (!Linker.Options.Update && Op.getCode() == dwarf::DW_OP_addrx) {
+      if (std::optional<object::SectionedAddress> SA =
+              Unit.getOrigUnit().getAddrOffsetSectionItem(
+                  Op.getRawOperand(0))) {
+        // DWARFLinker does not use addrx forms since it generates relocated
+        // addresses. Replace DW_OP_addrx with DW_OP_addr here.
+        // Argument of DW_OP_addrx should be relocated here as it is not
+        // processed by applyValidRelocs.
+        OutputBuffer.push_back(dwarf::DW_OP_addr);
+        uint64_t LinkedAddress = SA->Address + AddrRelocAdjustment;
+        ArrayRef<uint8_t> AddressBytes(
+            reinterpret_cast<const uint8_t *>(&LinkedAddress),
+            OrigAddressByteSize);
+        OutputBuffer.append(AddressBytes.begin(), AddressBytes.end());
+      } else
+        Linker.reportWarning("cannot read DW_OP_addrx operand.", File);
+    } else if (!Linker.Options.Update && Op.getCode() == dwarf::DW_OP_constx) {
+      if (std::optional<object::SectionedAddress> SA =
+              Unit.getOrigUnit().getAddrOffsetSectionItem(
+                  Op.getRawOperand(0))) {
+        // DWARFLinker does not use constx forms since it generates relocated
+        // addresses. Replace DW_OP_constx with DW_OP_const[*]u here.
+        // Argument of DW_OP_constx should be relocated here as it is not
+        // processed by applyValidRelocs.
+        std::optional<uint8_t> OutOperandKind;
+        switch (OrigAddressByteSize) {
+        case 4:
+          OutOperandKind = dwarf::DW_OP_const4u;
+          break;
+        case 8:
+          OutOperandKind = dwarf::DW_OP_const8u;
+          break;
+        default:
+          Linker.reportWarning(
+              formatv(("unsupported address size: {0}."), OrigAddressByteSize),
+              File);
+          break;
+        }
+
+        if (OutOperandKind) {
+          OutputBuffer.push_back(*OutOperandKind);
+          uint64_t LinkedAddress = SA->Address + AddrRelocAdjustment;
+          ArrayRef<uint8_t> AddressBytes(
+              reinterpret_cast<const uint8_t *>(&LinkedAddress),
+              OrigAddressByteSize);
+          OutputBuffer.append(AddressBytes.begin(), AddressBytes.end());
+        }
+      } else
+        Linker.reportWarning("cannot read DW_OP_constx operand.", File);
     } 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 DWARFFile &File, CompileUnit &Unit, AttributeSpec AttrSpec,
-    const DWARFFormValue &Val, unsigned AttrSize, bool IsLittleEndian) {
+    DIE &Die, const DWARFDie &InputDIE, const DWARFFile &File,
+    CompileUnit &Unit, AttributeSpec AttrSpec, const DWARFFormValue &Val,
+    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(
   if (DWARFAttribute::mayHaveLocationExpr(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(),
                          OrigUnit.getFormParams().Format);
-    cloneExpression(Data, Expr, File, Unit, Buffer);
+    cloneExpression(Data, Expr, File, Unit, Buffer,
+                    Unit.getInfo(InputDIE).AddrAdjust);
     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
   // Attr->setSize(Bytes.size()).
   if (Loc)
     Loc->setSize(Bytes.size());
   else
     Block->setSize(Bytes.size());
 
   Die.addValue(DIEAlloc, Value);
-  return AttrSize;
+  return getULEB128Size(Bytes.size()) + Bytes.size();
 }
 
 unsigned DWARFLinker::DIECloner::cloneAddressAttribute(
     DIE &Die, const DWARFDie &InputDIE, AttributeSpec AttrSpec,
     unsigned AttrSize, const DWARFFormValue &Val, const CompileUnit &Unit,
     AttributesInfo &Info) {
   if (AttrSpec.Attr == dwarf::DW_AT_low_pc)
     Info.HasLowPc = true;
else if (auto OptionalValue = Val.getAsUnsignedConstant())
     Value = *OptionalValue;
   else {
     Linker.reportWarning(
         "Unsupported scalar attribute form. Dropping attribute.", File,
         &InputDIE);
     return 0;
   }
 
-  PatchLocation Patch =
+  DIE::value_iterator Patch =
       Die.addValue(DIEAlloc, dwarf::Attribute(AttrSpec.Attr),
                    dwarf::Form(AttrSpec.Form), DIEInteger(Value));
   if (AttrSpec.Attr == dwarf::DW_AT_ranges ||
       AttrSpec.Attr == dwarf::DW_AT_start_scope) {
     Unit.noteRangeAttribute(Die, Patch);
     Info.HasRanges = true;
   } else if (DWARFAttribute::mayHaveLocationList(AttrSpec.Attr) &&
              dwarf::doesFormBelongToClass(AttrSpec.Form,
                                           DWARFFormValue::FC_SectionOffset,
                                           Unit.getOrigUnit().getVersion())) {
-    Unit.noteLocationAttribute(Patch, Info.PCOffset);
+
+    CompileUnit::DIEInfo &LocationDieInfo = Unit.getInfo(InputDIE);
+    Unit.noteLocationAttribute({Patch, LocationDieInfo.InDebugMap
+                                           ? LocationDieInfo.AddrAdjust
+                                           : Info.PCOffset});
   } else if (AttrSpec.Attr == dwarf::DW_AT_declaration && Value)
     Info.IsDeclaration = true;
 
   // check that all dwarf::DW_FORM_rnglistx are handled previously.
   assert((Info.HasRanges || (OriginalForm != dwarf::DW_FORM_rnglistx)) &&
          "Unhandled DW_FORM_rnglistx attribute");
 
   return AttrSize;
unsigned DWARFLinker::DIECloner::cloneAttribute(
   case dwarf::DW_FORM_ref8:
     return cloneDieReferenceAttribute(Die, InputDIE, AttrSpec, AttrSize, Val,
                                       File, Unit);
   case dwarf::DW_FORM_block:
   case dwarf::DW_FORM_block1:
   case dwarf::DW_FORM_block2:
   case dwarf::DW_FORM_block4:
   case dwarf::DW_FORM_exprloc:
-    return cloneBlockAttribute(Die, File, Unit, AttrSpec, Val, AttrSize,
+    return cloneBlockAttribute(Die, InputDIE, File, Unit, AttrSpec, Val,
                                IsLittleEndian);
   case dwarf::DW_FORM_addr:
   case dwarf::DW_FORM_addrx:
   case dwarf::DW_FORM_addrx1:
   case dwarf::DW_FORM_addrx2:
   case dwarf::DW_FORM_addrx3:
   case dwarf::DW_FORM_addrx4:
     return cloneAddressAttribute(Die, InputDIE, AttrSpec, AttrSize, Val, Unit,
void DWARFLinker::generateUnitLocations(
 
   // Emit locations list table header.
   MCSymbol *EndLabel = TheDwarfEmitter->emitDwarfDebugLocListHeader(Unit);
 
   for (auto &CurLocAttr : AllLocListAttributes) {
     // Get location expressions vector corresponding to the current attribute
     // from the source DWARF.
     Expected<DWARFLocationExpressionsVector> OriginalLocations =
-        Unit.getOrigUnit().findLoclistFromOffset((CurLocAttr.first).get());
+        Unit.getOrigUnit().findLoclistFromOffset(CurLocAttr.get());
 
     if (!OriginalLocations) {
       llvm::consumeError(OriginalLocations.takeError());
       reportWarning("Invalid location attribute ignored.", File);
       continue;
     }
 
     DWARFLocationExpressionsVector LinkedLocationExpressions;
     for (DWARFLocationExpression &CurExpression : *OriginalLocations) {
-
       DWARFLocationExpression LinkedExpression;
 
       if (CurExpression.Range) {
         // Relocate address range.
         LinkedExpression.Range = {
-            CurExpression.Range->LowPC + CurLocAttr.second,
-            CurExpression.Range->HighPC + CurLocAttr.second};
+            CurExpression.Range->LowPC + CurLocAttr.RelocAdjustment,
+            CurExpression.Range->HighPC + CurLocAttr.RelocAdjustment};
       }
 
       // Clone expression.
       LinkedExpression.Expr.reserve(CurExpression.Expr.size());
-      ExprHandler(CurExpression.Expr, LinkedExpression.Expr);
+      ExprHandler(CurExpression.Expr, LinkedExpression.Expr,
+                  CurLocAttr.RelocAdjustment);
 
       LinkedLocationExpressions.push_back(LinkedExpression);
     }
 
     // Emit locations list table fragment corresponding to the CurLocAttr.
     TheDwarfEmitter->emitDwarfDebugLocListFragment(
-        Unit, LinkedLocationExpressions, CurLocAttr.first);
+        Unit, LinkedLocationExpressions, CurLocAttr);
   }
 
   // Emit locations list table footer.
   TheDwarfEmitter->emitDwarfDebugLocListFooter(Unit, EndLabel);
 }
 
 /// Insert the new line info sequence \p Seq into the current
 /// set of already linked line info \p Rows.
if (!Linker.Options.NoOutput) {
       Linker.emitAcceleratorEntriesForUnit(*CurrentUnit);
 
       if (LLVM_UNLIKELY(Linker.Options.Update))
         continue;
 
       Linker.generateUnitRanges(*CurrentUnit, File);
 
       auto ProcessExpr = [&](SmallVectorImpl<uint8_t> &SrcBytes,
-                             SmallVectorImpl<uint8_t> &OutBytes) {
+                             SmallVectorImpl<uint8_t> &OutBytes,
+                             int64_t RelocAdjustment) {
         DWARFUnit &OrigUnit = CurrentUnit->getOrigUnit();
         DataExtractor Data(SrcBytes, IsLittleEndian,
                            OrigUnit.getAddressByteSize());
         cloneExpression(Data,
                         DWARFExpression(Data, OrigUnit.getAddressByteSize(),
                                         OrigUnit.getFormParams().Format),
-                        File, *CurrentUnit, OutBytes);
+                        File, *CurrentUnit, OutBytes, RelocAdjustment);
       };
       Linker.generateUnitLocations(*CurrentUnit, File, ProcessExpr);
     }
   }
 
   if (!Linker.Options.NoOutput) {
     assert(Emitter);
     // Emit macro tables.

llvm/lib/DWARFLinker/DWARFLinkerCompileUnit.cpp

 //===- DWARFLinkerCompileUnit.cpp -----------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/DWARFLinker/DWARFLinkerCompileUnit.h"
 #include "llvm/DWARFLinker/DWARFLinkerDeclContext.h"
+#include "llvm/DebugInfo/DWARF/DWARFContext.h"
+#include "llvm/DebugInfo/DWARF/DWARFExpression.h"
 #include "llvm/Support/FormatVariadic.h"
 
 namespace llvm {
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 LLVM_DUMP_METHOD void CompileUnit::DIEInfo::dump() {
   llvm::errs() << "{\n";
   llvm::errs() << "  AddrAdjust: " << AddrAdjust << '\n';

 
 void CompileUnit::markEverythingAsKept() {
   unsigned Idx = 0;
 
   for (auto &I : Info) {
     // Mark everything that wasn't explicit marked for pruning.
     I.Keep = !I.Prune;
     auto DIE = OrigUnit.getDIEAtIndex(Idx++);
+    DWARFUnit *U = DIE.getDwarfUnit();
 
     // Try to guess which DIEs must go to the accelerator tables. We do that
     // just for variables, because functions will be handled depending on
     // whether they carry a DW_AT_low_pc attribute or not.
     if (DIE.getTag() != dwarf::DW_TAG_variable &&
         DIE.getTag() != dwarf::DW_TAG_constant)
       continue;
 
     std::optional<DWARFFormValue> Value;
     if (!(Value = DIE.find(dwarf::DW_AT_location))) {
       if ((Value = DIE.find(dwarf::DW_AT_const_value)) &&
           !inFunctionScope(*this, I.ParentIdx))
         I.InDebugMap = true;
       continue;
     }
-    if (auto Block = Value->getAsBlock()) {
-      if (Block->size() > OrigUnit.getAddressByteSize() &&
-          (*Block)[0] == dwarf::DW_OP_addr)
+
+    if (auto ExprLockBlock = Value->getAsBlock()) {
+      // Parse 'exprloc' expression.
+      DataExtractor Data(toStringRef(*ExprLockBlock),
+                         U->getContext().isLittleEndian(),
+                         U->getAddressByteSize());
+      DWARFExpression Expression(Data, U->getAddressByteSize(),
+                                 U->getFormParams().Format);
+
+      for (DWARFExpression::iterator It = Expression.begin();
+           (It != Expression.end()) && !I.InDebugMap; ++It) {
+        DWARFExpression::iterator NextIt = It;
+        ++NextIt;
+
+        switch (It->getCode()) {
+        case dwarf::DW_OP_const4u:
+        case dwarf::DW_OP_const8u:
+        case dwarf::DW_OP_const4s:
+        case dwarf::DW_OP_const8s:
+          if (NextIt == Expression.end() ||
+              NextIt->getCode() != dwarf::DW_OP_form_tls_address)
+            break;
+          [[fallthrough]];
+        case dwarf::DW_OP_constx:
+        case dwarf::DW_OP_addr:
+        case dwarf::DW_OP_addrx:
           I.InDebugMap = true;
+          break;
+        default:
+          // Nothing to do.
+          break;
+        }
+      }
     }
   }
 }
 
 uint64_t CompileUnit::computeNextUnitOffset(uint16_t DwarfVersion) {
   NextUnitOffset = StartOffset;
   if (NewUnit) {
     NextUnitOffset += (DwarfVersion >= 5) ? 12 : 11; // Header size
void CompileUnit::noteRangeAttribute(const DIE &Die, PatchLocation Attr) {
   if (Die.getTag() == dwarf::DW_TAG_compile_unit) {
     UnitRangeAttribute = Attr;
     return;
   }
 
   RangeAttributes.emplace_back(Attr);
 }
 
-void CompileUnit::noteLocationAttribute(PatchLocation Attr, int64_t PcOffset) {
-  LocationAttributes.emplace_back(Attr, PcOffset);
+void CompileUnit::noteLocationAttribute(PatchLocation Attr) {
+  LocationAttributes.emplace_back(Attr);
 }
 
 void CompileUnit::addNamespaceAccelerator(const DIE *Die,
                                           DwarfStringPoolEntryRef Name) {
   Namespaces.emplace_back(Name, Die);
 }
 
 void CompileUnit::addObjCAccelerator(const DIE *Die,

llvm/lib/DebugInfo/DWARF/DWARFExpression.cpp

static DescVector getDescriptions() {
   Descriptions[DW_OP_call_frame_cfa] = Desc(Op::Dwarf3);
   Descriptions[DW_OP_bit_piece] = Desc(Op::Dwarf3, Op::SizeLEB, Op::SizeLEB);
   Descriptions[DW_OP_implicit_value] =
       Desc(Op::Dwarf3, Op::SizeLEB, Op::SizeBlock);
   Descriptions[DW_OP_stack_value] = Desc(Op::Dwarf3);
   Descriptions[DW_OP_WASM_location] =
       Desc(Op::Dwarf4, Op::SizeLEB, Op::WasmLocationArg);
   Descriptions[DW_OP_GNU_push_tls_address] = Desc(Op::Dwarf3);
-  Descriptions[DW_OP_addrx] = Desc(Op::Dwarf4, Op::SizeLEB);
   Descriptions[DW_OP_GNU_addr_index] = Desc(Op::Dwarf4, Op::SizeLEB);
   Descriptions[DW_OP_GNU_const_index] = Desc(Op::Dwarf4, Op::SizeLEB);
   Descriptions[DW_OP_GNU_entry_value] = Desc(Op::Dwarf4, Op::SizeLEB);
 
+  Descriptions[DW_OP_addrx] = Desc(Op::Dwarf5, Op::SizeLEB);
+  Descriptions[DW_OP_constx] = Desc(Op::Dwarf5, Op::SizeLEB);
   Descriptions[DW_OP_convert] = Desc(Op::Dwarf5, Op::BaseTypeRef);
   Descriptions[DW_OP_entry_value] = Desc(Op::Dwarf5, Op::SizeLEB);
   Descriptions[DW_OP_regval_type] =
       Desc(Op::Dwarf5, Op::SizeLEB, Op::BaseTypeRef);
 
   return Descriptions;
 }
 

llvm/test/tools/dsymutil/X86/dwarf5-dw-op-addrx.test

+## This test checks that DW_OP_addrx expression operand
+## is correctly recognized and converted into the DW_OP_addr
+## operand or just preserved in case --update.
+
+## cat dwarf5-dw-op-addrx.c
+
+## $ clang -gdwarf-5 dwarf5-dw-op-addrx.c -c -O2 -o dwarf5-dw-op-addrx.o
+
+#RUN: dsymutil -oso-prepend-path %p/../Inputs -y %s -o %t.dSYM
+#RUN: llvm-dwarfdump --verify  %t.dSYM | FileCheck %s
+#RUN: llvm-dwarfdump -a --verbose  %t.dSYM | FileCheck %s --check-prefix DWARF-CHECK
+
+#RUN: dsymutil --update -oso-prepend-path %p/../Inputs -y %s -o %t.dSYM
+#RUN: llvm-dwarfdump --verify  %t.dSYM | FileCheck %s
+#RUN: llvm-dwarfdump -a --verbose  %t.dSYM | FileCheck %s --check-prefix UPD-DWARF-CHECK
+
+#CHECK: No errors.
+
+#DWARF-CHECK: DW_TAG_compile_unit
+#DWARF-CHECK: DW_AT_name {{.*}}"dwarf5-dw-op-addrx.c"
+#DWARF-CHECK: DW_AT_low_pc {{.*}}0x0000000100000fb0
+#DWARF-CHECK: DW_TAG_variable
+#DWARF-CHECK:   DW_AT_name {{.*}}"arr"
+#DWARF-CHECK:   DW_AT_location {{.*}}(DW_OP_addr 0x100002000)
+#DWARF-CHECK-NOT: .debug_addr
+
+#UPD-DWARF-CHECK: DW_TAG_compile_unit
+#UPD-DWARF-CHECK: DW_AT_name {{.*}}"dwarf5-dw-op-addrx.c"
+#UPD-DWARF-CHECK: DW_AT_low_pc [DW_FORM_addrx]      (indexed (00000001) address = 0x0000000000000000)
+#UPD-DWARF-CHECK: DW_AT_high_pc [DW_FORM_data4]     (0x00000008)
+#UPD-DWARF-CHECK: DW_AT_addr_base [DW_FORM_sec_offset]      (0x00000008)
+#UPD-DWARF-CHECK: DW_TAG_variable
+#UPD-DWARF-CHECK:   DW_AT_name {{.*}}"arr"
+#UPD-DWARF-CHECK:   DW_AT_location [DW_FORM_exprloc]        (DW_OP_addrx 0x0)
+#UPD-DWARF-CHECK: .debug_addr contents:
+#UPD-DWARF-CHECK: 0x00000000: Address table header: length = 0x00000014, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00
+#UPD-DWARF-CHECK: 0x0000000000000000
+#UPD-DWARF-CHECK: 0x0000000000000000
+
+---
+triple:          'x86_64-apple-darwin'
+objects:
+  - filename:        'dwarf5-dw-op-addrx.o'
+    timestamp:       1676048242
+    symbols:
+      - { sym: _main, objAddr: 0x0000000000000000, binAddr: 0x0000000100000FB0, size: 0x00000008 }
+      - { sym: _arr, binAddr: 0x0000000100002000, size: 0x00000000 }

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

 OBJ:                 DW_AT_encoding  (DW_ATE_unsigned)
 OBJ:                 DW_AT_byte_size (0x01)
 
 OBJ: 0x00000094:     DW_TAG_formal_parameter
 OBJ:                   DW_AT_location        (DW_OP_breg2 RCX+0, DW_OP_constu 0xff, DW_OP_and, DW_OP_convert (0x0000007d) "DW_ATE_unsigned_1", DW_OP_convert (0x00000081) "DW_ATE_unsigned_8", DW_OP_stack_value)
 OBJ:                   DW_AT_name    ("b")
 OBJ:                   DW_AT_type    (0x000000af "_Bool")
 
-DSYM: 0x0000008d:   DW_TAG_base_type
+DSYM: 0x000000ae:   DW_TAG_base_type
 DSYM:                 DW_AT_name      ("DW_ATE_unsigned_1")
 DSYM:                 DW_AT_encoding  (DW_ATE_unsigned)
 DSYM:                 DW_AT_byte_size (0x01)
 
-DSYM: 0x000000b4:     DW_TAG_formal_parameter
-DSYM:                   DW_AT_location        (DW_OP_breg2 RCX+0, DW_OP_constu 0xff, DW_OP_and, DW_OP_convert (0x0000008d) "DW_ATE_unsigned_1", DW_OP_convert (0x00000094) "DW_ATE_unsigned_8", DW_OP_stack_value)
+DSYM: 0x000000d5:     DW_TAG_formal_parameter
+DSYM:                   DW_AT_location        (DW_OP_breg2 RCX+0, DW_OP_constu 0xff, DW_OP_and, DW_OP_convert (0x000000ae) "DW_ATE_unsigned_1", DW_OP_convert (0x000000b5) "DW_ATE_unsigned_8", DW_OP_stack_value)
 DSYM:                   DW_AT_name    ("b")
-DSYM:                   DW_AT_type    (0x000000d2 "_Bool")
+DSYM:                   DW_AT_type    (0x000000f3 "_Bool")

llvm/test/tools/llvm-dwarfutil/ELF/X86/dwarf5-addresses.test

-## Test that DWARFv5 DW_FORM_addrx is correctly recognized
-## and converted into the DW_FORM_addr in --garbage-collection
-## case or correctly preserved in --no-garbage-collection case.
+## Test that DWARFv5 address attributes and address expression operands
+## are handled correctly, specifically:
+## 1. DW_FORM_addrx is correctly recognized and converted into the DW_FORM_addr
+##    in --garbage-collection case or correctly preserved in --no-garbage-collection case.
+## 2. DW_OP_addrx is correctly recognized and converted into the DW_OP_addr
+##    in --garbage-collection case or correctly preserved in --no-garbage-collection case.
+## 3. DW_OP_constx is correctly recognized and converted into the DW_OP_const[*]u
+##    in --garbage-collection case or correctly preserved in --no-garbage-collection case.
 
 # RUN: yaml2obj %s -o %t.o
 
 # RUN: llvm-dwarfutil %t.o %t1
 # RUN: llvm-dwarfdump -verify %t1 | FileCheck %s
 # RUN: llvm-dwarfdump -a --verbose %t1 | FileCheck %s --check-prefix DWARF-CHECK
 #
 # RUN: llvm-dwarfutil --no-garbage-collection %t.o %t1

 #DWARF-CHECK:   DW_TAG_subprogram
 #DWARF-CHECK:     DW_AT_name  [DW_FORM_strp] {{.*}}   "foo5"
 #DWARF-CHECK:     DW_AT_low_pc [DW_FORM_addr]     (0x0000000000001170)
 #DWARF-CHECK:     DW_AT_high_pc [DW_FORM_data8]   (0x0000000000000010)
 #DWARF-CHECK:   DW_TAG_subprogram
 #DWARF-CHECK:     DW_AT_name  [DW_FORM_strp] {{.*}}   "foo6"
 #DWARF-CHECK:     DW_AT_low_pc [DW_FORM_addr]     (0x0000000000001180)
 #DWARF-CHECK:     DW_AT_high_pc [DW_FORM_data8]   (0x0000000000000010)
+#DWARF-CHECK:   DW_TAG_variable
+#DWARF-CHECK:     DW_AT_name  [DW_FORM_strp] {{.*}}   "var1"
+#DWARF-CHECK:     DW_AT_location [DW_FORM_exprloc] (DW_OP_addr 0x2000)
+#DWARF-CHECK:   DW_TAG_variable
+#DWARF-CHECK:     DW_AT_name  [DW_FORM_strp] {{.*}}   "var2"
+#DWARF-CHECK:     DW_AT_location [DW_FORM_exprloc] (DW_OP_addr 0x2000)
+#DWARF-CHECK:   DW_TAG_variable
+#DWARF-CHECK:     DW_AT_name [DW_FORM_strp]  {{.*}}   "var3"
+#DWARF-CHECK:     DW_AT_location [DW_FORM_exprloc] (DW_OP_const8u 0x2000, DW_OP_form_tls_address)
+#DWARF-CHECK:   DW_TAG_variable
+#DWARF-CHECK:     DW_AT_name [DW_FORM_strp]  {{.*}}   "var4"
+#DWARF-CHECK:     DW_AT_location [DW_FORM_exprloc] (DW_OP_const8u 0x2000, DW_OP_form_tls_address)
 #DWARF-CHECK=NOT: .debug_addr contents:
 
 #UPD-DWARF-CHECK: DW_TAG_compile_unit
 #UPD-DWARF-CHECK:   DW_AT_name {{.*}}"CU1"
 #UPD-DWARF-CHECK:   DW_AT_low_pc [DW_FORM_addrx]   (indexed (00000000) address = 0x0000000000001130)
 #UPD-DWARF-CHECK:   DW_AT_high_pc [DW_FORM_data8]   (0x0000000000000060)
 #UPD-DWARF-CHECK:   DW_TAG_subprogram
 #UPD-DWARF-CHECK:     DW_AT_name  {{.*}}"foo1"

 #UPD-DWARF-CHECK:   DW_TAG_subprogram
 #UPD-DWARF-CHECK:     DW_AT_name  {{.*}}"foo5"
 #UPD-DWARF-CHECK:     DW_AT_low_pc [DW_FORM_addrx2]   (indexed (00000004) address = 0x0000000000001170)
 #UPD-DWARF-CHECK:     DW_AT_high_pc [DW_FORM_data8]   (0x0000000000000010)
 #UPD-DWARF-CHECK:   DW_TAG_subprogram
 #UPD-DWARF-CHECK:     DW_AT_name  {{.*}}"foo6"
 #UPD-DWARF-CHECK:     DW_AT_low_pc [DW_FORM_addrx4]   (indexed (00000005) address = 0x0000000000001180)
 #UPD-DWARF-CHECK:     DW_AT_high_pc [DW_FORM_data8]   (0x0000000000000010)
+#UPD-DWARF-CHECK:   DW_TAG_variable
+#UPD-DWARF-CHECK:     DW_AT_name  {{.*}}"var1"
+#UPD-DWARF-CHECK:     DW_AT_location [DW_FORM_exprloc]        (DW_OP_addrx 0x6)
+#UPD-DWARF-CHECK:   DW_TAG_variable
+#UPD-DWARF-CHECK:     DW_AT_name  {{.*}}"var2"
+#UPD-DWARF-CHECK:     DW_AT_location [DW_FORM_exprloc]        (DW_OP_addr 0x2000)
+#UPD-DWARF-CHECK:   DW_TAG_variable
+#UPD-DWARF-CHECK:     DW_AT_name  {{.*}}"var3"
+#UPD-DWARF-CHECK:     DW_AT_location [DW_FORM_exprloc] (DW_OP_constx 0x6, DW_OP_form_tls_address)
+#UPD-DWARF-CHECK:   DW_TAG_variable
+#UPD-DWARF-CHECK:     DW_AT_name  {{.*}}"var4"
+#UPD-DWARF-CHECK:     DW_AT_location [DW_FORM_exprloc] (DW_OP_const8u 0x2000, DW_OP_form_tls_address)
 #UPD-DWARF-CHECK: .debug_addr contents:
-#UPD-DWARF-CHECK: 0x00000000: Address table header: length = 0x00000034, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00
+#UPD-DWARF-CHECK: 0x00000000: Address table header: length = 0x0000003c, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00
 #UPD-DWARF-CHECK: Addrs: [
 #UPD-DWARF-CHECK: 0x0000000000001130
 #UPD-DWARF-CHECK: 0x0000000000001140
 #UPD-DWARF-CHECK: 0x0000000000001150
 #UPD-DWARF-CHECK: 0x0000000000001160
 #UPD-DWARF-CHECK: 0x0000000000001170
 #UPD-DWARF-CHECK: 0x0000000000001180
+#UPD-DWARF-CHECK: 0x0000000000002000
 #UPD-DWARF-CHECK: ]
 
 --- !ELF
 FileHeader:
   Class:    ELFCLASS64
   Data:     ELFDATA2LSB
   Type:     ET_REL
   Machine:  EM_X86_64
 Sections:
   - Name:            .text
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
     Address:         0x1130
-    Size:            0x60
+    Size:            0x1000
 DWARF:
   debug_abbrev:
     - Table:
       - Tag:      DW_TAG_compile_unit
         Children: DW_CHILDREN_yes
         Attributes:
           - Attribute: DW_AT_producer
             Form:      DW_FORM_string
- Table:
             Form:      DW_FORM_data8
           - Attribute: DW_AT_type
             Form:      DW_FORM_ref4
       - Tag:      DW_TAG_base_type
         Children: DW_CHILDREN_no
         Attributes:
           - Attribute: DW_AT_name
             Form:      DW_FORM_string
+      - Tag:      DW_TAG_variable
+        Children: DW_CHILDREN_no
+        Attributes:
+          - Attribute: DW_AT_name
+            Form:      DW_FORM_string
+          - Attribute: DW_AT_type
+            Form:      DW_FORM_ref4
+          - Attribute: DW_AT_location
+            Form:      DW_FORM_exprloc
   debug_info:
     - Version: 5
       UnitType:   DW_UT_compile
       Entries:
         - AbbrCode: 1
           Values:
             - CStr: by_hand
             - Value:  0x04
- Version: 5
             - CStr: foo6
             - Value: 0x05
             - Value: 0x10
             - Value: 0xa4
         - AbbrCode: 0
         - AbbrCode: 6
           Values:
             - CStr: int
+        - AbbrCode: 7
+          Values:
+            - CStr: var1
+            - Value: 0xa4
+            - BlockData:
+                - 0xa1
+                - 0x6
+        - AbbrCode: 7
+          Values:
+            - CStr: var2
+            - Value: 0xa4
+            - BlockData:
+                - 0x03
+                - 0x00
+                - 0x20
+                - 0x00
+                - 0x00
+                - 0x00
+                - 0x00
+                - 0x00
+                - 0x00
+        - AbbrCode: 7
+          Values:
+            - CStr: var3
+            - Value: 0xa4
+            - BlockData:
+                - 0xa2
+                - 0x6
+                - 0x9b
+        - AbbrCode: 7
+          Values:
+            - CStr: var4
+            - Value: 0xa4
+            - BlockData:
+                - 0x0e
+                - 0x00
+                - 0x20
+                - 0x00
+                - 0x00
+                - 0x00
+                - 0x00
+                - 0x00
+                - 0x00
+                - 0x9b
         - AbbrCode: 0
   debug_addr:
     - Version: 5
       AddressSize: 0x08
       Entries:
         - Address: 0x1130
         - Address: 0x1140
         - Address: 0x1150
         - Address: 0x1160
         - Address: 0x1170
         - Address: 0x1180
+        - Address: 0x2000
 ...

llvm/tools/dsymutil/DwarfLinkerForBinary.h

public:
     /// Checks that there is a relocation in the \p Relocs array against a
     /// debug map entry between \p StartOffset and \p NextOffset.
     ///
     /// \returns relocation value if relocation exist, otherwise std::nullopt.
     std::optional<int64_t>
     hasValidRelocationAt(const std::vector<ValidReloc> &Relocs,
                          uint64_t StartOffset, uint64_t EndOffset);
 
-    std::optional<int64_t>
-    getVariableRelocAdjustment(const DWARFDie &DIE) override;
+    std::optional<int64_t> getExprOpAddressRelocAdjustment(
+        DWARFUnit &U, const DWARFExpression::Operation &Op,
+        uint64_t StartOffset, uint64_t EndOffset) override;
     std::optional<int64_t>
     getSubprogramRelocAdjustment(const DWARFDie &DIE) override;
 
     bool applyValidRelocs(MutableArrayRef<char> Data, uint64_t BaseOffset,
                           bool IsLittleEndian) override;
 
     RangesTy &getValidAddressRanges() override { return AddressRanges; }
 

llvm/tools/dsymutil/DwarfLinkerForBinary.cpp

 #include "llvm/DWARFLinker/DWARFLinkerDeclContext.h"
 #include "llvm/DebugInfo/DIContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFAbbreviationDeclaration.h"
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFDataExtractor.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugLine.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugRangeList.h"
 #include "llvm/DebugInfo/DWARF/DWARFDie.h"
+#include "llvm/DebugInfo/DWARF/DWARFExpression.h"
 #include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
 #include "llvm/DebugInfo/DWARF/DWARFSection.h"
 #include "llvm/DebugInfo/DWARF/DWARFUnit.h"
 #include "llvm/MC/MCAsmBackend.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCCodeEmitter.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCDwarf.h"
getAttributeOffsets(const DWARFAbbreviationDeclaration *Abbrev, unsigned Idx,
   uint64_t End = Offset;
   DWARFFormValue::skipValue(Abbrev->getFormByIndex(Idx), Data, &End,
                             Unit.getFormParams());
 
   return std::make_pair(Offset, End);
 }
 
 std::optional<int64_t>
-DwarfLinkerForBinary::AddressManager::getVariableRelocAdjustment(
-    const DWARFDie &DIE) {
-  const auto *Abbrev = DIE.getAbbreviationDeclarationPtr();
+DwarfLinkerForBinary::AddressManager::getExprOpAddressRelocAdjustment(
+    DWARFUnit &U, const DWARFExpression::Operation &Op, uint64_t StartOffset,
+    uint64_t EndOffset) {
+  switch (Op.getCode()) {
+  default: {
+    assert(false && "Specified operation does not have address operand");
+  } break;
+  case dwarf::DW_OP_const4u:
+  case dwarf::DW_OP_const8u:
+  case dwarf::DW_OP_const4s:
+  case dwarf::DW_OP_const8s:
+  case dwarf::DW_OP_addr: {
+    return hasValidRelocationAt(ValidDebugInfoRelocs, StartOffset, EndOffset);
+  } break;
+  case dwarf::DW_OP_constx:
+  case dwarf::DW_OP_addrx: {
+    return hasValidRelocationAt(ValidDebugAddrRelocs, StartOffset, EndOffset);
+  } break;
+  }
 
-  std::optional<uint32_t> LocationIdx =
-      Abbrev->findAttributeIndex(dwarf::DW_AT_location);
-  if (!LocationIdx)
-    return std::nullopt;
-
-  uint64_t Offset = DIE.getOffset() + getULEB128Size(Abbrev->getCode());
-  uint64_t LocationOffset, LocationEndOffset;
-  std::tie(LocationOffset, LocationEndOffset) =
-      getAttributeOffsets(Abbrev, *LocationIdx, Offset, *DIE.getDwarfUnit());
-
-  // FIXME: Support relocations debug_addr.
-  return hasValidRelocationAt(ValidDebugInfoRelocs, LocationOffset,
-                              LocationEndOffset);
 }
 
 std::optional<int64_t>
 DwarfLinkerForBinary::AddressManager::getSubprogramRelocAdjustment(
     const DWARFDie &DIE) {
   const auto *Abbrev = DIE.getAbbreviationDeclarationPtr();
 
   std::optional<uint32_t> LowPcIdx =
       Abbrev->findAttributeIndex(dwarf::DW_AT_low_pc);
   if (!LowPcIdx)
     return std::nullopt;
 
   dwarf::Form Form = Abbrev->getFormByIndex(*LowPcIdx);
 
   switch (Form) {
   case dwarf::DW_FORM_addr: {
     uint64_t Offset = DIE.getOffset() + getULEB128Size(Abbrev->getCode());
     uint64_t LowPcOffset, LowPcEndOffset;
     std::tie(LowPcOffset, LowPcEndOffset) =
         getAttributeOffsets(Abbrev, *LowPcIdx, Offset, *DIE.getDwarfUnit());
     return hasValidRelocationAt(ValidDebugInfoRelocs, LowPcOffset,
                                 LowPcEndOffset);
   }
   case dwarf::DW_FORM_addrx:
   case dwarf::DW_FORM_addrx1:
   case dwarf::DW_FORM_addrx2:
   case dwarf::DW_FORM_addrx3:
   case dwarf::DW_FORM_addrx4: {
     std::optional<DWARFFormValue> AddrValue = DIE.find(dwarf::DW_AT_low_pc);
     if (std::optional<uint64_t> AddrOffsetSectionBase =
             DIE.getDwarfUnit()->getAddrOffsetSectionBase()) {
       uint64_t StartOffset = *AddrOffsetSectionBase + AddrValue->getRawUValue();
       uint64_t EndOffset =
           StartOffset + DIE.getDwarfUnit()->getAddressByteSize();
       return hasValidRelocationAt(ValidDebugAddrRelocs, StartOffset, EndOffset);
     }
 
     Linker.reportWarning("no base offset for address table", SrcFileName);
     return std::nullopt;
   }
   default:
     return std::nullopt;
   }
 }
 
 uint64_t
 DwarfLinkerForBinary::AddressManager::relocate(const ValidReloc &Reloc) const {
   return Reloc.Mapping->getValue().BinaryAddress + Reloc.Addend;
 }
 
 /// Apply the valid relocations found by findValidRelocs() to
 /// the buffer \p Data, taking into account that Data is at \p BaseOffset
 /// in the debug_info section.
 ///
 /// Like for findValidRelocs(), this function must be called with
 /// monotonic \p BaseOffset values.
 ///
 /// \returns whether any reloc has been applied.
 bool DwarfLinkerForBinary::AddressManager::applyValidRelocs(

llvm/tools/llvm-dwarfutil/DebugInfoLinker.cpp

if (std::optional<uint64_t> LowPC =
                          DIE.getDwarfUnit()->getAddressByteSize()))
         // Relocation value for the linked binary is 0.
         return 0;
     }
 
     return std::nullopt;
   }
 
-  std::optional<int64_t>
-  getVariableRelocAdjustment(const DWARFDie &DIE) override {
-    assert((DIE.getTag() == dwarf::DW_TAG_variable ||
-            DIE.getTag() == dwarf::DW_TAG_constant) &&
-           "Wrong type of input die");
-
-    if (Expected<DWARFLocationExpressionsVector> Loc =
-            DIE.getLocations(dwarf::DW_AT_location)) {
-      DWARFUnit *U = DIE.getDwarfUnit();
-      for (const auto &Entry : *Loc) {
-        DataExtractor Data(toStringRef(Entry.Expr),
-                           U->getContext().isLittleEndian(), 0);
-        DWARFExpression Expression(Data, U->getAddressByteSize(),
-                                   U->getFormParams().Format);
-        bool HasLiveAddresses =
-            any_of(Expression, [&](const DWARFExpression::Operation &Op) {
-              // TODO: add handling of dwarf::DW_OP_addrx
-              return !Op.isError() &&
-                     (Op.getCode() == dwarf::DW_OP_addr &&
-                      !isDeadAddress(Op.getRawOperand(0), U->getVersion(),
-                                     Opts.Tombstone,
-                                     DIE.getDwarfUnit()->getAddressByteSize()));
-            });
-
-        if (HasLiveAddresses)
+  std::optional<int64_t> getExprOpAddressRelocAdjustment(
+      DWARFUnit &U, const DWARFExpression::Operation &Op, uint64_t StartOffset,
+      uint64_t EndOffset) override {
+    switch (Op.getCode()) {
+    default: {
+      assert(false && "Specified operation does not have address operand");
+    } break;
+    case dwarf::DW_OP_const4u:
+    case dwarf::DW_OP_const8u:
+    case dwarf::DW_OP_const4s:
+    case dwarf::DW_OP_const8s:
+    case dwarf::DW_OP_addr: {
+      if (!isDeadAddress(Op.getRawOperand(0), U.getVersion(), Opts.Tombstone,
+                         U.getAddressByteSize()))
+        // Relocation value for the linked binary is 0.
+        return 0;
+    } break;
+    case dwarf::DW_OP_constx:
+    case dwarf::DW_OP_addrx: {
+      if (std::optional<object::SectionedAddress> Address =
+              U.getAddrOffsetSectionItem(Op.getRawOperand(0))) {
+        if (!isDeadAddress(Address->Address, U.getVersion(), Opts.Tombstone,
+                           U.getAddressByteSize()))
           // Relocation value for the linked binary is 0.
           return 0;
       }
-    } else {
-      // FIXME: missing DW_AT_location is OK here, but other errors should be
-      // reported to the user.
-      consumeError(Loc.takeError());
+    } break;
     }
 
     return std::nullopt;
   }
 
   bool applyValidRelocs(MutableArrayRef<char>, uint64_t, bool) override {
     // no need to apply relocations to the linked binary.
     return false;