[DebugInfo] Process single-location debug values in variadic form when producing DWARF

[StephenTozer]

Summary

Fixes issues raised on: https://reviews.llvm.org/D133926

The patch above enabled using variadic-form debug values to represent single-location, non-stack-value debug values, and a further patch made all DBG_INSTR_REFs use variadic form. Not all code paths were updated correctly to handle the new syntax however, with entry values in still expecting an expression that begins exactly DW_OP_LLVM_entry_value, 1.

A function already exists to select non-variadic-like expressions; this patch adds an extra function to cheaply simplify such cases to non-variadic form, which we use prior to any entry-value processing to put DBG_INSTR_REFs and DBG_VALUEs down the same code path. We also use it for a few DIExpression functions that check for whether the first element(s) of a DIExpression match a particular pattern, so that they will return the same result for DIExpression(DW_OP_LLVM_arg, 0, <ops>) as for DIExpression(<ops>).

[StephenTozer]

Patch broke a test case, which tested that we don't emit locations for dbg.values with constant operands >64 bits as part of a normal DWARF expression, which was appearing in variadic dbg.values. This patch incidentally fixes the specific test by causing the example variadic expression to be interpreted as non-variadic, but slightly modifying the expression fixes that.

[fdeazeve]

Thanks for looking into this! The code itself LGTM, but it might be worth waiting for the review of someone more familiar with this portion of code base

[Orlando]

LGTM too with some inline nits/questions.

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.h

159

style nit: outer if should have braces.

llvm/lib/IR/DebugInfoMetadata.cpp

1347

Can we have DIExpressions where there are two entry_value ops (applied to two DW_OP_LLVM_args)?

Perhaps that's a separate issue or maybe there is special case isEntryValue-equivalent code somewhere for variaidics?

1353

Should these functions be asserting that they're not variadic?

1548

What's the purpose of the Elements[1] != 0 check? Could we ever end up with a variadic dbg intrinsic that has 2 location args, where only the second is referenced in the expression (e.g. DW_OP_LLVM_arg, 1, ... with arg 0 not referenced)?

[fdeazeve]

llvm/lib/IR/DebugInfoMetadata.cpp

1347

This is a tricky one, as I don't think any of the "isX" or "startsWithX" methods were designed with variadics in mind. These methods should only be called when we know we have a single expression?

I wasn't around when the variadic design was made, but my first thought is to think that instead of having variadic expressions it would be cleaner to have multiple expressions, one per value argument. But there are probably a lot of implications I can't see right now!

[StephenTozer]

llvm/lib/IR/DebugInfoMetadata.cpp

1347

my first thought is to think that instead of having variadic expressions it would be cleaner to have multiple expressions, one per value argument

The expression needs to calculate a single value - it's not being used in this case for fragments/DW_OP_piece expressions, but as a function to reproduce a variable's value from a set of input values. For example, if you try to translate %z = add %x, %y into a DIExpression, you can't do so using one expression for %x and one expression for %y - you just need a single expression for %z that takes %x and %y as arguments.

[fdeazeve]

llvm/lib/IR/DebugInfoMetadata.cpp

1347

Ah, this makes perfect sense, thanks! Knew I was missing something fundamental here :)

[fdeazeve]

@StephenTozer have you received any other feedback on this? I've been experimenting with this patch in the swift fork (https://github.com/apple/llvm-project) and it seems to fix all the issues I had found.

[StephenTozer]

In D158185#4614085, @fdeazeve wrote:

I've been experimenting with this patch in the swift fork (https://github.com/apple/llvm-project) and it seems to fix all the issues I had found.

Good to hear! I'm working through a small backlog of patches right now, but should have this merged soon.

[StephenTozer]

llvm/lib/IR/DebugInfoMetadata.cpp

1353

That wasn't the original intent in this patch; the idea is that there's no difference between DW_OP_LLVM_arg, 0, <ops> in a variadic expression and <ops> in a non-variadic expression, so the goal of this patch is to treat those two as the same even if the expression ultimately is "truly" variadic, because we weren't already checking for variadic-ness here (so for correctness' sake we assume this is already being checked elsewhere), and the variadic check is more expensive.

However, I've found the patch triggers some errors when running on the llvm test suite, and the variadic check really isn't that expensive I think, so I'm going to rewrite the patch to do a bit more.

[fdeazeve]

However, I've found the patch triggers some errors when running on the llvm test suite, and the variadic check really isn't that expensive I think, so I'm going to rewrite the patch to do a bit more.

Hi @StephenTozer, could you elaborate on what these failures are? I am concerned because, ever since D133926 was merged, there are some methods that were left with an incorrect implementation, like startsWithDeref or isEntryValue. It would be nice if we could address those.
Is the proposed fix here revealing a larger problem that may cause D133926 to be rethought?

[StephenTozer]

In D158185#4645353, @fdeazeve wrote:

Hi @StephenTozer, could you elaborate on what these failures are? I am concerned because, ever since D133926 was merged, there are some methods that were left with an incorrect implementation, like startsWithDeref or isEntryValue. It would be nice if we could address those.
Is the proposed fix here revealing a larger problem that may cause D133926 to be rethought?

The failures were crashes caused by some expressions being updated incorrectly; the fix I'm uploading is just for this patch, making it a bit more defensive by changing getSingleLocationExpressionElements to actually check whether the expression is variadic, and return an optional, either the single-loc expression or std::nullopt if the expression isn't variadic. I've got the change, I'm running correctness tests again and will upload it shortly.

[StephenTozer]

Check for isSingleLocationExpression in more places and make other checks (isEntryValue() and similar) contingent on that check.

Apologies for the delay on getting this up!

[fdeazeve]

Thanks for the explanation, it makes sense!

[fdeazeve]

I've just noticed that, for reasons I am still investigating, the optimizer produced this expression in some test:

call void @llvm.dbg.value(metadata !DIArgList(ptr %0, i32 %4), metadata !319, metadata !DIExpression(DW_OP_LLVM_entry_value, 1, DW_OP_deref, DW_OP_LLVM_arg, 0, DW_OP_plus_uconst, 16, DW_OP_LLVM_arg, 1, DW_OP_constu, 1, DW_OP_mul, DW_OP_plus, DW_OP_deref, DW_OP_stack_value)), !dbg !344

This is technically an entry value, as entry_value, 1 is referring to %0 here. However, because of the check if (auto singleLocElts = getSingleLocationExpressionElements()) we are going to return false.

I suspect a similar issue happens with the current implementation of the isDeref check. Any thoughts on this? I'm unsure what kind of semantics those isX methods should have in the presence of variadic arg lists

[fdeazeve]

Actually, I think that expression might be invalid? That argument 1 is supposed to mimic the DWARF specification, i.e., it attempts to specify the length of the operations that are evaluated upon function entry. We require it to be 1 because we always want to be just a "register" operation. It's not clear what the meaning would be for a variadic expression

[StephenTozer]

In D158185#4648729, @fdeazeve wrote:

I've just noticed that, for reasons I am still investigating, the optimizer produced this expression in some test:

Are you able to post the test source or an unoptimized reproducer?

I suspect a similar issue happens with the current implementation of the isDeref check. Any thoughts on this? I'm unsure what kind of semantics those isX methods should have in the presence of variadic arg lists

The awkwardness of those functions in the context of a variadic debug value is that they're really meant to refer to a specific value, i.e. "is this expression dereferencing register x?", rather than being a property of the expression as a whole. Rewriting these to make this make sense is another piece of work imo - for the cases other than isEntryValue I don't think this is an issue because iirc they're only being used in cases where we only care about non-variadic debug values anyway. The entry value case should be investigated further (and as you note in your second comment, the expression as written is incorrect).

[fdeazeve]

Are you able to post the test source or an unoptimized reproducer?

Working on it!

for the cases other than isEntryValue I don't think this is an issue because iirc they're only being used in cases where we only care about non-variadic debug values anyway.

The verifier does call "isEntryValue" in order to perform some checks. I'll probably change it so that it also checks the expression is not variadic.

llvm/include/llvm/IR/DebugInfoMetadata.h

public:
   /// it cannot be a simple register location.
   bool isComplex() const;
 
   /// Return whether the evaluated expression makes use of a single location at
   /// the start of the expression, i.e. if it contains only a single
   /// DW_OP_LLVM_arg op as its first operand, or if it contains none.
   bool isSingleLocationExpression() const;
 
+  /// Returns a reference to the elements contained in this expression, skipping
+  /// past the leading `DW_OP_LLVM_arg, 0` if one is present.
+  /// Similar to `convertToNonVariadicExpression`, but faster and cheaper - it
+  /// does not check whether the expression is a single-location expression, and
+  /// it returns elements rather than creating a new DIExpression.
+  ArrayRef<uint64_t> getSingleLocationExpressionElements() const;
+
   /// Removes all elements from \p Expr that do not apply to an undef debug
   /// value, which includes every operator that computes the value/location on
   /// the DWARF stack, including any DW_OP_LLVM_arg elements (making the result
   /// of this function always a single-location expression) while leaving
   /// everything that defines what the computed value applies to, i.e. the
   /// fragment information.
   static const DIExpression *convertToUndefExpression(const DIExpression *Expr);
 
   /// If \p Expr is a non-variadic expression (i.e. one that does not contain
   /// DW_OP_LLVM_arg), returns \p Expr converted to variadic form by adding a
   /// leading [DW_OP_LLVM_arg, 0] to the expression; otherwise returns \p Expr.
   static const DIExpression *
   convertToVariadicExpression(const DIExpression *Expr);
 
   /// If \p Expr is a valid single-location expression, i.e. it refers to only a
   /// single debug operand at the start of the expression, then return that
   /// expression in a non-variadic form by removing DW_OP_LLVM_arg from the
   /// expression if it is present; otherwise returns std::nullopt.
+  /// See also `getSingleLocationExpressionElements` above, which skips
+  /// checking `isSingleLocationExpression` and returns a list of elements
+  /// rather than a DIExpression.
   static std::optional<const DIExpression *>
   convertToNonVariadicExpression(const DIExpression *Expr);
 
   /// Inserts the elements of \p Expr into \p Ops modified to a canonical form,
   /// which uses DW_OP_LLVM_arg (i.e. is a variadic expression) and folds the
   /// implied derefence from the \p IsIndirect flag into the expression. This
   /// allows us to check equivalence between expressions with differing
   /// directness or variadicness.

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

DIE *DwarfCompileUnit::constructVariableDIEImpl(const DbgVariable &DV,
 
   // Check if variable has a single location description.
   if (auto *DVal = DV.getValueLoc()) {
     if (!DVal->isVariadic()) {
       const DbgValueLocEntry *Entry = DVal->getLocEntries().begin();
       if (Entry->isLocation()) {
         addVariableAddress(DV, *VariableDie, Entry->getLoc());
       } else if (Entry->isInt()) {
-        auto *Expr = DV.getSingleExpression();
+        auto *Expr = DVal->getExpression();
         if (Expr && Expr->getNumElements()) {
           DIELoc *Loc = new (DIEValueAllocator) DIELoc;
           DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
           // If there is an expression, emit raw unsigned bytes.
           DwarfExpr.addFragmentOffset(Expr);
           DwarfExpr.addUnsignedConstant(Entry->getInt());
           DwarfExpr.addExpression(Expr);
           addBlock(*VariableDie, dwarf::DW_AT_location, DwarfExpr.finalize());
if (!DVal->isVariadic()) {
       return VariableDie;
     }
     // If any of the location entries are registers with the value 0, then the
     // location is undefined.
     if (any_of(DVal->getLocEntries(), [](const DbgValueLocEntry &Entry) {
           return Entry.isLocation() && !Entry.getLoc().getReg();
         }))
       return VariableDie;
-    const DIExpression *Expr = DV.getSingleExpression();
+    const DIExpression *Expr = DVal->getExpression();
     assert(Expr && "Variadic Debug Value must have an Expression.");
     DIELoc *Loc = new (DIEValueAllocator) DIELoc;
     DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
     DwarfExpr.addFragmentOffset(Expr);
     DIExpressionCursor Cursor(Expr);
     const TargetRegisterInfo &TRI = *Asm->MF->getSubtarget().getRegisterInfo();
 
     auto AddEntry = [&](const DbgValueLocEntry &Entry,

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.h

public:
 
   // Initialize variable's location.
   void initializeDbgValue(DbgValueLoc Value) {
     assert(FrameIndexExprs.empty() && "Already initialized?");
     assert(!ValueLoc && "Already initialized?");
     assert(!Value.getExpression()->isFragment() && "Fragments not supported.");
 
     ValueLoc = std::make_unique<DbgValueLoc>(Value);
-    if (auto *E = ValueLoc->getExpression())
-      if (E->getNumElements())
-        FrameIndexExprs.push_back({0, E});
+    // Use the DbgValueLoc's expression as a FrameIndexExpr iff it is suitable,
+    // which requires it to be non-variadic.
+    if (auto E = DIExpression::convertToNonVariadicExpression(
+            ValueLoc->getExpression()))
+      if ((*E)->getNumElements())
+        FrameIndexExprs.push_back({0, *E});
   }
 
   /// Initialize from a DBG_VALUE instruction.
   void initializeDbgValue(const MachineInstr *DbgValue);
 
   // Accessors.
   const DILocalVariable *getVariable() const {
     return cast<DILocalVariable>(getEntity());

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

 
 const DIType *DbgVariable::getType() const {
   return getVariable()->getType();
 }
 
 /// Get .debug_loc entry for the instruction range starting at MI.
 static DbgValueLoc getDebugLocValue(const MachineInstr *MI) {
   const DIExpression *Expr = MI->getDebugExpression();
-  const bool IsVariadic = MI->isDebugValueList();
+  const bool IsVariadic = !Expr->isSingleLocationExpression();
+  // If we have a variadic debug value instruction that is equivalent to a
+  // non-variadic instruction, then convert it to non-variadic form here.
+  if (!IsVariadic && !MI->isNonListDebugValue()) {
+    assert(MI->getNumDebugOperands() == 1 &&
+           "Mismatched DIExpression and debug operands for debug instruction.");
+    Expr = DIExpression::get(Expr->getContext(),
+                             Expr->getSingleLocationExpressionElements());
+  }
   assert(MI->getNumOperands() >= 3);
   SmallVector<DbgValueLocEntry, 4> DbgValueLocEntries;
   for (const MachineOperand &Op : MI->debug_operands()) {
     if (Op.isReg()) {
       MachineLocation MLoc(Op.getReg(),
                            MI->isNonListDebugValue() && MI->isDebugOffsetImm());
       DbgValueLocEntries.push_back(DbgValueLocEntry(MLoc));
     } else if (Op.isTargetIndex()) {
void DbgVariable::initializeDbgValue(const MachineInstr *DbgValue) {
   assert(FrameIndexExprs.empty() && "Already initialized?");
   assert(!ValueLoc.get() && "Already initialized?");
 
   assert(getVariable() == DbgValue->getDebugVariable() && "Wrong variable");
   assert(getInlinedAt() == DbgValue->getDebugLoc()->getInlinedAt() &&
          "Wrong inlined-at");
 
   ValueLoc = std::make_unique<DbgValueLoc>(getDebugLocValue(DbgValue));
-  if (auto *E = DbgValue->getDebugExpression())
-    if (E->getNumElements())
-      FrameIndexExprs.push_back({0, E});
+  // Use the debug value's expression as a FrameIndexExpr iff it is suitable,
+  // which requires it to be non-variadic.
+  if (auto E = DIExpression::convertToNonVariadicExpression(
+          DbgValue->getDebugExpression()))
+    if ((*E)->getNumElements())
+      FrameIndexExprs.push_back({0, *E});
 }
 
 ArrayRef<DbgVariable::FrameIndexExpr> DbgVariable::getFrameIndexExprs() const {
   if (FrameIndexExprs.size() == 1)
     return FrameIndexExprs;
 
   assert(llvm::all_of(FrameIndexExprs,
                       [](const FrameIndexExpr &A) {

llvm/lib/IR/DebugInfoMetadata.cpp

 }
 
 DIExpression *DIExpression::getImpl(LLVMContext &Context,
                                     ArrayRef<uint64_t> Elements,
                                     StorageType Storage, bool ShouldCreate) {
   DEFINE_GETIMPL_LOOKUP(DIExpression, (Elements));
   DEFINE_GETIMPL_STORE_NO_OPS(DIExpression, (Elements));
 }
 bool DIExpression::isEntryValue() const {
-  return getNumElements() > 0 && getElement(0) == dwarf::DW_OP_LLVM_entry_value;
+  auto singleLocElts = getSingleLocationExpressionElements();
+  return singleLocElts.size() > 0 &&
+         singleLocElts[0] == dwarf::DW_OP_LLVM_entry_value;
 }
 bool DIExpression::startsWithDeref() const {
-  return getNumElements() > 0 && getElement(0) == dwarf::DW_OP_deref;
+  auto singleLocElts = getSingleLocationExpressionElements();
+  return singleLocElts.size() > 0 && singleLocElts[0] == dwarf::DW_OP_deref;
 }
 bool DIExpression::isDeref() const {
-  return getNumElements() == 1 && startsWithDeref();
+  auto singleLocElts = getSingleLocationExpressionElements();
+  return singleLocElts.size() == 1 && singleLocElts[0] == dwarf::DW_OP_deref;
 }
 
 DIAssignID *DIAssignID::getImpl(LLVMContext &Context, StorageType Storage,
                                 bool ShouldCreate) {
   // Uniqued DIAssignID are not supported as the instance address *is* the ID.
   assert(Storage != StorageType::Uniqued && "uniqued DIAssignID unsupported");
   return storeImpl(new (0u, Storage) DIAssignID(Context, Storage), Storage);
 }
bool DIExpression::isSingleLocationExpression() const {
   if (!isValid())
     return false;
 
   if (getNumElements() == 0)
     return true;
 
   auto ExprOpBegin = expr_ops().begin();
   auto ExprOpEnd = expr_ops().end();
-  if (ExprOpBegin->getOp() == dwarf::DW_OP_LLVM_arg)
+  if (ExprOpBegin->getOp() == dwarf::DW_OP_LLVM_arg) {
+    if (ExprOpBegin->getArg(0) != 0)
+      return false;
     ++ExprOpBegin;
+  }
 
   return !std::any_of(ExprOpBegin, ExprOpEnd, [](auto Op) {
     return Op.getOp() == dwarf::DW_OP_LLVM_arg;
   });
 }
 
+ArrayRef<uint64_t> DIExpression::getSingleLocationExpressionElements() const {
+  if (getNumElements() < 2 || Elements[0] != dwarf::DW_OP_LLVM_arg ||
+      Elements[1] != 0)
+    return Elements;
+  return getElements().drop_front(2);
+}
+
 const DIExpression *
 DIExpression::convertToUndefExpression(const DIExpression *Expr) {
   SmallVector<uint64_t, 3> UndefOps;
   if (auto FragmentInfo = Expr->getFragmentInfo()) {
     UndefOps.append({dwarf::DW_OP_LLVM_fragment, FragmentInfo->OffsetInBits,
                      FragmentInfo->SizeInBits});
   }
   return DIExpression::get(Expr->getContext(), UndefOps);
DIExpression::convertToVariadicExpression(const DIExpression *Expr) {
   NewOps.reserve(Expr->getNumElements() + 2);
   NewOps.append({dwarf::DW_OP_LLVM_arg, 0});
   NewOps.append(Expr->elements_begin(), Expr->elements_end());
   return DIExpression::get(Expr->getContext(), NewOps);
 }
 
 std::optional<const DIExpression *>
 DIExpression::convertToNonVariadicExpression(const DIExpression *Expr) {
+  if (!Expr)
+    return std::nullopt;
+
   // Check for `isValid` covered by `isSingleLocationExpression`.
   if (!Expr->isSingleLocationExpression())
     return std::nullopt;
 
   // An empty expression is already non-variadic.
   if (!Expr->getNumElements())
     return Expr;
 
   auto ElementsBegin = Expr->elements_begin();
   // If Expr does not have a leading DW_OP_LLVM_arg then we don't need to do
   // anything.
   if (*ElementsBegin != dwarf::DW_OP_LLVM_arg)
     return Expr;
 
-  SmallVector<uint64_t> NonVariadicOps(
-      make_range(ElementsBegin + 2, Expr->elements_end()));
-  return DIExpression::get(Expr->getContext(), NonVariadicOps);
+  return DIExpression::get(Expr->getContext(),
+                           Expr->getElements().drop_front(2));
 }
 
 void DIExpression::canonicalizeExpressionOps(SmallVectorImpl<uint64_t> &Ops,
                                              const DIExpression *Expr,
                                              bool IsIndirect) {
   // If Expr is not already variadic, insert the implied `DW_OP_LLVM_arg 0`
   // to the existing expression ops.
   if (none_of(Expr->expr_ops(), [](auto ExprOp) {
if (Offset > 0) {
     // abs(LLONG_MIN) is LLONG_MAX+1.
     uint64_t AbsMinusOne = -(Offset+1);
     Ops.push_back(AbsMinusOne + 1);
     Ops.push_back(dwarf::DW_OP_minus);
   }
 }
 
 bool DIExpression::extractIfOffset(int64_t &Offset) const {
-  if (getNumElements() == 0) {
+  auto SingleLocElts = getSingleLocationExpressionElements();
+  if (SingleLocElts.size() == 0) {
     Offset = 0;
     return true;
   }
 
-  if (getNumElements() == 2 && Elements[0] == dwarf::DW_OP_plus_uconst) {
-    Offset = Elements[1];
+  if (SingleLocElts.size() == 2 &&
+      SingleLocElts[0] == dwarf::DW_OP_plus_uconst) {
+    Offset = SingleLocElts[1];
     return true;
   }
 
-  if (getNumElements() == 3 && Elements[0] == dwarf::DW_OP_constu) {
-    if (Elements[2] == dwarf::DW_OP_plus) {
-      Offset = Elements[1];
+  if (SingleLocElts.size() == 3 && SingleLocElts[0] == dwarf::DW_OP_constu) {
+    if (SingleLocElts[2] == dwarf::DW_OP_plus) {
+      Offset = SingleLocElts[1];
       return true;
     }
-    if (Elements[2] == dwarf::DW_OP_minus) {
-      Offset = -Elements[1];
+    if (SingleLocElts[2] == dwarf::DW_OP_minus) {
+      Offset = -SingleLocElts[1];
       return true;
     }
   }
 
   return false;
 }
 
 bool DIExpression::hasAllLocationOps(unsigned N) const {
   SmallDenseSet<uint64_t, 4> SeenOps;
   for (auto ExprOp : expr_ops())
     if (ExprOp.getOp() == dwarf::DW_OP_LLVM_arg)
       SeenOps.insert(ExprOp.getArg(0));
   for (uint64_t Idx = 0; Idx < N; ++Idx)
     if (!SeenOps.contains(Idx))
       return false;
   return true;
 }
 
 const DIExpression *DIExpression::extractAddressClass(const DIExpression *Expr,
                                                       unsigned &AddrClass) {
   // FIXME: This seems fragile. Nothing that verifies that these elements
   // actually map to ops and not operands.
+  auto SingleLocElts = Expr->getSingleLocationExpressionElements();
   const unsigned PatternSize = 4;
-  if (Expr->Elements.size() >= PatternSize &&
-      Expr->Elements[PatternSize - 4] == dwarf::DW_OP_constu &&
-      Expr->Elements[PatternSize - 2] == dwarf::DW_OP_swap &&
-      Expr->Elements[PatternSize - 1] == dwarf::DW_OP_xderef) {
-    AddrClass = Expr->Elements[PatternSize - 3];
+  if (SingleLocElts.size() >= PatternSize &&
+      SingleLocElts[PatternSize - 4] == dwarf::DW_OP_constu &&
+      SingleLocElts[PatternSize - 2] == dwarf::DW_OP_swap &&
+      SingleLocElts[PatternSize - 1] == dwarf::DW_OP_xderef) {
+    AddrClass = SingleLocElts[PatternSize - 3];
 
-    if (Expr->Elements.size() == PatternSize)
+    if (SingleLocElts.size() == PatternSize)
       return nullptr;
-    return DIExpression::get(Expr->getContext(),
-                             ArrayRef(&*Expr->Elements.begin(),
-                                      Expr->Elements.size() - PatternSize));
+    return DIExpression::get(
+        Expr->getContext(),
+        ArrayRef(&*SingleLocElts.begin(), SingleLocElts.size() - PatternSize));
   }
   return Expr;
 }
 
 DIExpression *DIExpression::prepend(const DIExpression *Expr, uint8_t Flags,
                                     int64_t Offset) {
   SmallVector<uint64_t, 8> Ops;
   if (Flags & DIExpression::DerefBefore)

llvm/test/DebugInfo/X86/debug-value-list-entry-value.mir

+# RUN: llc %s --start-after=livedebugvalues --filetype=obj -o - \
+# RUN:     | llvm-dwarfdump - --name=test-var -o - | FileCheck %s
+
+# Test that when an entry value expression appears in a DBG_VALUE_LIST, we are
+# able to produce a valid entry value location in DWARF.
+
+# CHECK: DW_OP_entry_value(DW_OP_reg14 R14), DW_OP_plus_uconst 0x10, DW_OP_plus_uconst 0x10, DW_OP_deref
+
+--- |
+  source_filename = "test.ll"
+  target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+  target triple = "x86_64-apple-macosx12.1.0"
+  
+  declare void @llvm.dbg.value(metadata, metadata, metadata)
+  
+  define swifttailcc void @blah(ptr swiftasync %0) !dbg !15 {
+    %use = getelementptr i8, ptr %0, i64 9
+    call void @llvm.dbg.value(metadata ptr %0, metadata !18, metadata !DIExpression(DW_OP_LLVM_entry_value, 1, DW_OP_plus_uconst, 16, DW_OP_plus_uconst, 16, DW_OP_deref, DW_OP_deref)), !dbg !22
+    %use1 = load i32, ptr null, align 4, !dbg !27
+    %use2 = sext i32 %use1 to i64
+    %use3 = getelementptr i8, ptr null, i64 %use2
+    store ptr %use3, ptr %0, align 8
+    ret void
+  }
+
+  !llvm.module.flags = !{!0}
+  !llvm.dbg.cu = !{!1}
+
+  !0 = !{i32 2, !"Debug Info Version", i32 3}
+  !1 = distinct !DICompileUnit(language: DW_LANG_Swift, file: !2, producer: "blah", isOptimized: true, flags: "blah", runtimeVersion: 5, emissionKind: FullDebug, globals: !3, imports: !9, sysroot: "blah", sdk: "blah")
+  !2 = !DIFile(filename: "blah", directory: "blah")
+  !3 = !{!4, !10}
+  !4 = !DIGlobalVariableExpression(var: !5, expr: !DIExpression())
+  !5 = distinct !DIGlobalVariable(name: "blah", linkageName: "blah", scope: !6, file: !2, line: 49, type: !7, isLocal: true, isDefinition: true)
+  !6 = !DIModule(scope: null, name: "blah", includePath: "blah")
+  !7 = !DIDerivedType(tag: DW_TAG_const_type, baseType: !8)
+  !8 = !DICompositeType(tag: DW_TAG_structure_type, name: "blah", scope: !6, file: !2, size: 64, elements: !9, runtimeLang: DW_LANG_Swift, identifier: "blah")
+  !9 = !{}
+  !10 = !DIGlobalVariableExpression(var: !11, expr: !DIExpression())
+  !11 = distinct !DIGlobalVariable(name: "blah", linkageName: "blah", scope: !6, file: !2, line: 44, type: !12, isLocal: false, isDefinition: true)
+  !12 = !DIDerivedType(tag: DW_TAG_const_type, baseType: !13)
+  !13 = !DICompositeType(tag: DW_TAG_structure_type, name: "blah", scope: !14, file: !2, size: 64, elements: !9, runtimeLang: DW_LANG_Swift, identifier: "blah")
+  !14 = !DIModule(scope: null, name: "blah", configMacros: "blah", includePath: "blah")
+  !15 = distinct !DISubprogram(name: "blah", linkageName: "blah", scope: !16, file: !2, line: 115, type: !17, scopeLine: 117, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !1, retainedNodes: !9, thrownTypes: !9)
+  !16 = !DICompositeType(tag: DW_TAG_structure_type, name: "blah", scope: !6, file: !2, elements: !9, runtimeLang: DW_LANG_Swift, identifier: "blah")
+  !17 = !DISubroutineType(types: !9)
+  !18 = !DILocalVariable(name: "test-var", arg: 1, scope: !19, file: !2, line: 95, type: !21, flags: DIFlagArtificial)
+  !19 = distinct !DISubprogram(name: "blah", linkageName: "blah", scope: !16, file: !2, line: 95, type: !20, scopeLine: 95, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !1, retainedNodes: !9)
+  !20 = distinct !DISubroutineType(types: !9)
+  !21 = !DIDerivedType(tag: DW_TAG_const_type, baseType: !16)
+  !22 = !DILocation(line: 95, column: 9, scope: !19, inlinedAt: !23)
+  !23 = distinct !DILocation(line: 0, scope: !24, inlinedAt: !25)
+  !24 = distinct !DISubprogram(name: "blah", linkageName: "blah", scope: !16, file: !2, type: !20, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !1)
+  !25 = distinct !DILocation(line: 121, column: 36, scope: !26)
+  !26 = distinct !DILexicalBlock(scope: !15, file: !2, line: 116, column: 7)
+  !27 = !DILocation(line: 0, scope: !28, inlinedAt: !23)
+  !28 = !DILexicalBlockFile(scope: !19, file: !2, discriminator: 0)
+
+...
+---
+name:            blah
+alignment:       16
+tracksRegLiveness: true
+debugInstrRef:   true
+tracksDebugUserValues: true
+registers:       []
+liveins:
+  - { reg: '$r14', virtual-reg: '' }
+frameInfo:
+  maxAlignment:    1
+body:             |
+  bb.0 (%ir-block.1):
+    liveins: $r14
+  
+    DBG_PHI $r14, 1
+    DBG_INSTR_REF !18, !DIExpression(DW_OP_LLVM_arg, 0, DW_OP_LLVM_entry_value, 1, DW_OP_plus_uconst, 16, DW_OP_plus_uconst, 16, DW_OP_deref, DW_OP_deref), dbg-instr-ref(1, 0), debug-location !22
+    DBG_VALUE_LIST !18, !DIExpression(DW_OP_LLVM_arg, 0, DW_OP_LLVM_entry_value, 1, DW_OP_plus_uconst, 16, DW_OP_plus_uconst, 16, DW_OP_deref, DW_OP_deref), $r14, debug-location !DILocation(line: 0, scope: !19, inlinedAt: !23)
+    renamable $rax = MOVSX64rm32 $noreg, 1, $noreg, 0, $noreg, debug-location !27 :: (load (s32) from `ptr null`)
+    MOV64mr killed renamable $r14, 1, $noreg, 0, $noreg, killed renamable $rax :: (store (s64) into %ir.0)
+    RETI64 8
+
+...

llvm/test/DebugInfo/X86/pr52584.ll

 ; RUN: llc -mtriple=x86_64-unknown-linux-gnu -filetype=obj -o - %s \
 ; RUN:     | llvm-dwarfdump - \
 ; RUN:     | FileCheck %s
 
 ; CHECK:      DW_TAG_variable
 ; CHECK-NOT:    DW_AT_location
 ; CHECK-NEXT:   DW_AT_name  ("arr")
 ; CHECK-NOT:    DW_AT_location
 ; CHECK:      DW_TAG
 define dso_local void @test() !dbg !4 {
 entry:
-  call void @llvm.dbg.value(metadata !DIArgList(i128 0), metadata !7, metadata !DIExpression(DW_OP_LLVM_arg, 0, DW_OP_stack_value, DW_OP_LLVM_fragment, 0, 127)), !dbg !12
+  call void @llvm.dbg.value(metadata !DIArgList(i128 0), metadata !7, metadata !DIExpression(DW_OP_LLVM_arg, 0, DW_OP_LLVM_arg, 0, DW_OP_plus, DW_OP_stack_value, DW_OP_LLVM_fragment, 0, 127)), !dbg !12
   ret void, !dbg !12
 }
 
 declare void @llvm.dbg.value(metadata, metadata, metadata)
 
 !llvm.dbg.cu = !{!0}
 !llvm.module.flags = !{!2, !3}