[SelectionDAG][DebugInfo] Use entry-values to recover variables values

[djtodoro]

Summary

Use the entry values to salvage some params dbg.values. It is based on D87233.

[aprantl]

I think this looks mostly good.

llvm/lib/CodeGen/SelectionDAG/InstrEmitter.cpp

710

Can you add a comment that explains what's happening here?

718

Would ValueMap.lookup() work here?

[djtodoro]

@aprantl thanks for your comments.

llvm/lib/CodeGen/SelectionDAG/InstrEmitter.cpp

710

Sure.

718

It'd work, thanks.

[djtodoro]

• addressing comments
• refactoring
• fixing tests
• adding RegState::Debug to the Reg from the dbg_value

[djtodoro]

• Rebase

[aprantl]

llvm/include/llvm/CodeGen/FunctionLoweringInfo.h

80

Nit: remove ArgValueMap -. This used to be part of the comment style, but is completely redundant in non-ancient versions of Doxygen.

[Orlando]

llvm/lib/CodeGen/SelectionDAG/InstrEmitter.cpp

718

I think this we should only be doing this for immutable parameters (and mutable parameters which are never assigned to), right?

I.e. the entry_value of a parameter register is only a valid location for a parameter variable if that variable is never assigned another value.

[djtodoro]

llvm/lib/CodeGen/SelectionDAG/InstrEmitter.cpp

718

We are expressing the modification in terms of its entry value here.

[StephenTozer]

llvm/lib/CodeGen/SelectionDAG/InstrEmitter.cpp

718

As far as I understand, we want to recover variables by describing them in relation to the initial values of the parameters. In that case, it only makes sense to consider variables whose values can be expressed in relation to that; this may include variables that aren't parameters themselves, and may exclude dbg.values for parameters. For example:

void foo(int param) {
  int x = param + 2;
  param = SomeInt();
  ...
}

In this example it should be possible to describe x in terms of param's initial value, while param itself could not be described by an entry value after its assignment within the function. In that case, I believe it would make more sense to look for dbg.values that use a parameter Value, or can be expressed in terms of one, rather than using DILocalVariable::isParameter. Does that seem correct, or have I misunderstood the work or the purpose of this block?

[djtodoro]

llvm/include/llvm/CodeGen/FunctionLoweringInfo.h

80

Thanks, sure.

llvm/lib/CodeGen/SelectionDAG/InstrEmitter.cpp

718

Hi @StephenTozer.
Yes, but is a more complex use case, so we do not cover it (yet). There is a TODO marker within the findEntryValue() for that.
The debug entry values feature is complex, relying on various things, so we've initially implemented the support for simple registers locations as entry values of *unmodified* parameters *only*, during the LiveDebugValues phase. Currently, we are extending the support onto IR level, for some (simple) cases, but there is space for improvements for sure, since the potential goes beyond the current usage.

718

I think this we should only be doing this for immutable parameters (and mutable parameters which are never assigned to), right?

I.e. the entry_value of a parameter register is only a valid location for a parameter variable if that variable is never assigned another value.

Hi @Orlando.
I might have needed to add some more context here. You are right, and all of that has been already checked within the main debug-entry-values place of the production, within LiveDebugValues. We perform analysis there, and at the moment, use entry values for unmodified params (since it is the basic case). There is space for improvements, by using the entry values for describing/expressing the modification in terms of its entry value, but we do not support it (yet), there.

On the IR level, at the moment, we are trying to extend this support for unused arguments, since it seems to be safe/simple use case. First place for that is the DeadArgElimination pass, and we are working on sorting out all the pieces for that purpose (but it takes some additional magic in order to get it working for both callee and caller sides). The next spot this could be used is here, where we also have unused parameters, that are not being copied into any register, so the SelectionDAG marks them as invalid/unable to track it location anymore. Please comment on this, since I might have missed something.

[djtodoro]

• addressing comment

[StephenTozer]

llvm/lib/CodeGen/SelectionDAG/InstrEmitter.cpp

718

Not handling the x case is fine then, since it will be much easier to get the basic change completed and then extend it to cover more cases later. I'm still not sure how this new extension avoids the second case however. Because we only use the variable to determine what entry value (if any) to produce, this code would still produce entry value DBG_VALUEs for a parameter even after an assignment to that parameter. Is there anything I've missed that would prevent us producing invalid entry values right here, such as for param's post-assignment value in the example code above?

[djtodoro]

llvm/lib/CodeGen/SelectionDAG/InstrEmitter.cpp

718

Probably we need some additional/stronger statements here. Can you please share the test case, so I can reproduce it?

[djtodoro]

llvm/lib/CodeGen/SelectionDAG/InstrEmitter.cpp

718

statements -- in the code/extension implementation terms

[Orlando]

llvm/lib/CodeGen/SelectionDAG/InstrEmitter.cpp

718

Hi @Orlando.
I might have needed to add some more context here. You are right, and all of that has been already checked within the main debug-entry-values place of the production, within LiveDebugValues. We perform analysis there, and at the moment, use entry values for unmodified params (since it is the basic case). There is space for improvements, by using the entry values for describing/expressing the modification in terms of its entry value, but we do not support it (yet), there.

On the IR level, at the moment, we are trying to extend this support for unused arguments, since it seems to be safe/simple use case. First place for that is the DeadArgElimination pass, and we are working on sorting out all the pieces for that purpose (but it takes some additional magic in order to get it working for both callee and caller sides). The next spot this could be used is here, where we also have unused parameters, that are not being copied into any register, so the SelectionDAG marks them as invalid/unable to track it location anymore. Please comment on this, since I might have missed something.

Thank you for this explanation, it has helped me understand.

The significance of ArgValueMap - in filtering the invalidated SDDbgValues for parameter variables down to just those using argument values - hadn't quite hit me until now, but looking again this all makes sense to me now.

I'm not really familiar with how LiveDebugValues handles entry_values currently. I'll take a close look soon as I can though as I'm interested in keeping up with this work!

[djtodoro]

llvm/lib/CodeGen/SelectionDAG/InstrEmitter.cpp

718

No problem, thanks for your comments!

I've described the intention of this patch, but I might have missed some pieces, so I think we'll cover that with more tests (e.g. with the one @StephenTozer will provide).

[dstenb]

llvm/lib/CodeGen/SelectionDAG/InstrEmitter.cpp

718

I don't want to derail this discussion, but I just wanted to add that when I played around with this patch I encountered cases where we incorrectly emit entry values, even after the parameter has been modified, on trunk without this patch. I wrote a PR for that: https://bugs.llvm.org/show_bug.cgi?id=47628.

[StephenTozer]

llvm/lib/CodeGen/SelectionDAG/InstrEmitter.cpp

718

incorrect_entry-value_isel.ll2 KBDownload

Here is a test case which demonstrates the behaviour I'm talking about. I think the easiest way to summarize the underlying issue is that you're using the DILocalVariable to determine what entry value we should emit, if any. This is incorrect: it makes no fundamental difference whether or not the variable we're describing is a parameter, what matters is whether we use one of the SSA parameters. It might make more sense to track this information in the SDDbgValue directly, but in any case we can't rely on the variable to give us that information.

Full disclosure, I've also discussed this with Orlando directly, and he retracts his comment about ArgValueMap solving the issue; since EntryValue is equal to the parameter value for the variable rather than the current dbg.value.

[djtodoro]

llvm/lib/CodeGen/SelectionDAG/InstrEmitter.cpp

718

Oh... it makes sense to me. Thanks! I've tried a few tests, and it all seemed to be working fine...

I'll try to propose a solution for this. I think it would be nice if we can make it working outside of the SelectionDAG (like a general solution for IR), and that is why I thought the variable would be enough/nice way to implement it, but it may not be sufficient...

[StephenTozer]

llvm/lib/CodeGen/SelectionDAG/InstrEmitter.cpp

718

My suggestion would be to use the SSA values. The properties of SSA form ensure that whenever we have a reference to an SSA value %param that is a parameter to a function, that value will be available as an entry value. This information should be readily available throughout IR. Once we get to ISel it gets a bit more complicated, but since each dbg.value is associated with a SDDbgValue it should be possible to store some identifying information in the SDDbgValue that can be referred back to here.

My naive thought is that you could simply store a Value* or Value Handle pointing to the original instruction, and use that instead of findEntryValue. If this doesn't work, it may be possible to store some information externally, as with ArgValueMap, that can be combined with the identifier to find the corresponding Entry Value (if any).

[djtodoro]

llvm/lib/CodeGen/SelectionDAG/InstrEmitter.cpp

718

At first, I proposed/thought extending the instructions with some kind of a pointer to the Value, but it seemed to be too much work (since there would be handling of such info throughout the pipeline, etc.).
Let me think about it, and there might be some combination of this approach and the ideas shared that potentially could solve the problem.

[djtodoro]

• Use 2 extra arguments from llvm.dbg.value()
• Handle modified params

[djtodoro]

This needs to be tested more (so it is not for the final commit (yet)). I believe this triggers some asserts, but (at least) we are covering the cases we want.

[StephenTozer]

LGTM, this new approach looks solid. As per usual, wait for further approval from someone with more authority in this area.

llvm/include/llvm/CodeGen/SelectionDAG.h

1477–1478

Nit, I think the "v" should be uppercase.

llvm/lib/CodeGen/SelectionDAG/InstrEmitter.cpp

710–726

Minor: Comment could do with a small rewrite, something like "must generate an undef" -> "must generate a DBG_VALUE that is either undef, or an entry value if one is available"

711

Double semi-colon here.

llvm/lib/CodeGen/SelectionDAG/SDNodeDbgValue.h

68–69

Nit, this can be put in the initializer list.

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

5491–5493

Perhaps instead of simply making this a condition, there should be an assert here that V doesn't already exist in ArgValueMap? I can't think of any case where it would already be there that wouldn't be an error, since I don't think we would ever call this twice for the same Value.

llvm/test/DebugInfo/X86/entry-val-invalidated-node-modifed-param-with-add.ll

2–4

Personally I think it'd probably be best to specify the DWARF version in this, so that this test doesn't break if the default becomes 5 (or already is in a clone repo). It might be better to simply update the test if/when that happens though, I don't have especially strong opinions about it. Alternatively you could simply regex it as DW_OP{{(_GNU)?}}_entry_value; also not sure whether or not this approach would be preferred.

llvm/test/DebugInfo/X86/entry-values-for-isel-invalidated-nodes.ll

2–5

Repeat of above comment about DWARF version.

[djtodoro]

@StephenTozer Thanks for your comments. I'll address them and refactor the patch a bit, as soon as I catch some time to address some issues with the first patch from the stack.

[djtodoro]

• Use the entry values for local vars as well

llvm/include/llvm/CodeGen/FunctionLoweringInfo.h

public:
   /// MBBMap - A mapping from LLVM basic blocks to their machine code entry.
   DenseMap<const BasicBlock*, MachineBasicBlock *> MBBMap;
 
   /// ValueMap - Since we emit code for the function a basic block at a time,
   /// we must remember which virtual registers hold the values for
   /// cross-basic-block values.
   DenseMap<const Value *, Register> ValueMap;
 
+  /// A mapping from the argument values to their virtual registers.
+  DenseMap<const Value *, Register> ArgValueMap;
+
   /// VirtReg2Value map is needed by the Divergence Analysis driven
   /// instruction selection. It is reverted ValueMap. It is computed
   /// in lazy style - on demand. It is used to get the Value corresponding
   /// to the live in virtual register and is called from the
   /// TargetLowerinInfo::isSDNodeSourceOfDivergence.
   DenseMap<Register, const Value*> VirtReg2Value;
 
   /// This method is called from TargetLowerinInfo::isSDNodeSourceOfDivergence

llvm/include/llvm/CodeGen/SelectionDAG.h

#endif
 
   /// Get the specified node if it's already available, or else return NULL.
   SDNode *getNodeIfExists(unsigned Opcode, SDVTList VTList, ArrayRef<SDValue> Ops,
                           const SDNodeFlags Flags = SDNodeFlags());
 
   /// Creates a SDDbgValue node.
   SDDbgValue *getDbgValue(DIVariable *Var, DIExpression *Expr, SDNode *N,
                           unsigned R, bool IsIndirect, const DebugLoc &DL,
-                          unsigned O);
+                          unsigned O, unsigned VRegForEntryValue = 0,
+                          DIExpression *EntryExpr = nullptr);
 
   /// Creates a constant SDDbgValue node.
   SDDbgValue *getConstantDbgValue(DIVariable *Var, DIExpression *Expr,
                                   const Value *C, const DebugLoc &DL,
-                                  unsigned O);
+                                  unsigned O, unsigned EntryValueReg = 0,
+                                  DIExpression *EntryExpr = nullptr);
 
   /// Creates a FrameIndex SDDbgValue node.
   SDDbgValue *getFrameIndexDbgValue(DIVariable *Var, DIExpression *Expr,
                                     unsigned FI, bool IsIndirect,
                                     const DebugLoc &DL, unsigned O);
 
   /// Creates a VReg SDDbgValue node.
   SDDbgValue *getVRegDbgValue(DIVariable *Var, DIExpression *Expr,

llvm/lib/CodeGen/AsmPrinter/DwarfExpression.cpp

if ((HasComplexExpression || IsEmittingEntryValue) && DwarfRegs.size() > 1) {
     LocationKind = Unknown;
     return false;
   }
 
   // Handle simple register locations. If we are supposed to emit
   // a call site parameter expression and if that expression is just a register
   // location, emit it with addBReg and offset 0, because we should emit a DWARF
   // expression representing a value, rather than a location.
-  if (!isMemoryLocation() && !HasComplexExpression &&
-      (!isParameterValue() || isEntryValue())) {
+  if ((!isMemoryLocation() && !HasComplexExpression && !isParameterValue()) ||
+      (!isMemoryLocation() && isEntryValue())) {
     for (auto &Reg : DwarfRegs) {
       if (Reg.DwarfRegNo >= 0)
         addReg(Reg.DwarfRegNo, Reg.Comment);
       addOpPiece(Reg.SubRegSize);
     }
 
     if (isEntryValue())
       finalizeEntryValue();
 
     if (isEntryValue() && !isIndirect() && !isParameterValue() &&
-        DwarfVersion >= 4)
+        DwarfVersion >= 4 && !HasComplexExpression)
       emitOp(dwarf::DW_OP_stack_value);
 
     DwarfRegs.clear();
     return true;
   }
 
   // Don't emit locations that cannot be expressed without DW_OP_stack_value.
   if (DwarfVersion < 4)
case dwarf::DW_OP_LLVM_fragment: {
       // Emit the DW_OP_piece.
       addOpPiece(SizeInBits, SubRegisterOffsetInBits);
       setSubRegisterPiece(0, 0);
       // Reset the location description kind.
       LocationKind = Unknown;
       return;
     }
     case dwarf::DW_OP_plus_uconst:
-      assert(!isRegisterLocation());
+      assert(!isRegisterLocation() || isEntryValue());
       emitOp(dwarf::DW_OP_plus_uconst);
       emitUnsigned(Op->getArg(0));
       break;
     case dwarf::DW_OP_plus:
     case dwarf::DW_OP_minus:
     case dwarf::DW_OP_mul:
     case dwarf::DW_OP_div:
     case dwarf::DW_OP_mod:
case dwarf::DW_OP_deref:
       if (!isMemoryLocation() && ::isMemoryLocation(ExprCursor))
         // Turning this into a memory location description makes the deref
         // implicit.
         LocationKind = Memory;
       else
         emitOp(dwarf::DW_OP_deref);
       break;
     case dwarf::DW_OP_constu:
-      assert(!isRegisterLocation());
+      assert(!isRegisterLocation() || isEntryValue());
       emitConstu(Op->getArg(0));
       break;
     case dwarf::DW_OP_LLVM_convert: {
       unsigned BitSize = Op->getArg(0);
       dwarf::TypeKind Encoding = static_cast<dwarf::TypeKind>(Op->getArg(1));
       if (DwarfVersion >= 5) {
         emitOp(dwarf::DW_OP_convert);
         // If targeting a location-list; simply emit the index into the raw

llvm/lib/CodeGen/SelectionDAG/InstrEmitter.cpp

 #include "llvm/CodeGen/TargetLowering.h"
 #include "llvm/CodeGen/TargetSubtargetInfo.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/DebugInfo.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Target/TargetMachine.h"
+#include "llvm/Transforms/Utils/Local.h"
 using namespace llvm;
 
 #define DEBUG_TYPE "instr-emitter"
 
 /// MinRCSize - Smallest register class we allow when constraining virtual
 /// registers.  If satisfying all register class constraints would require
 /// using a smaller register class, emit a COPY to a new virtual register
 /// instead.
InstrEmitter::EmitDbgValue(SDDbgValue *SD,
   MDNode *Var = SD->getVariable();
   MDNode *Expr = SD->getExpression();
   DebugLoc DL = SD->getDebugLoc();
   assert(cast<DILocalVariable>(Var)->isValidLocationForIntrinsic(DL) &&
          "Expected inlined-at fields to agree");
 
   SD->setIsEmitted();
 
+  auto &TM = TLI->getTargetMachine();
   if (SD->isInvalidated()) {
-    // An invalidated SDNode must generate an undef DBG_VALUE: although the
-    // original value is no longer computed, earlier DBG_VALUEs live ranges
-    // must not leak into later code.
+    Register Reg = SD->getVRegForEntryValue();
+    DIExpression *EntryValueExpr = SD->getEntryExpression();
+
+    // It the node has been invalidated, try to salvage the value
+    // if an entry value is available for the variable. Entry values
+    // act as backups here, and it will end up in an expression with
+    // a DW_OP_entry_value.
+
+    if (TM.Options.ShouldEmitDebugEntryValues() && Reg)
+      Expr = DIExpression::prepend(cast<DIExpression>(EntryValueExpr),
+                                   DIExpression::EntryValue);
+
+    // An invalidated SDNode must generate a DBG_VALUE that is either undef,
+    // or an entry value if one is available: although the original
+    // value is no longer computed, earlier DBG_VALUEs live ranges must not leak
+    // into later code.
     auto MIB = BuildMI(*MF, DL, TII->get(TargetOpcode::DBG_VALUE));
-    MIB.addReg(0U);
+    MIB.addReg(Reg, RegState::Debug);
     MIB.addReg(0U, RegState::Debug);
     MIB.addMetadata(Var);
     MIB.addMetadata(Expr);
     return &*MIB;
   }
 
   if (SD->getKind() == SDDbgValue::FRAMEIX) {
     // Stack address; this needs to be lowered in target-dependent fashion.
if (SD->getKind() == SDDbgValue::SDNODE) {
     } else if (const ConstantFP *CF = dyn_cast<ConstantFP>(V)) {
       MIB.addFPImm(CF);
     } else if (isa<ConstantPointerNull>(V)) {
       // Note: This assumes that all nullptr constants are zero-valued.
       MIB.addImm(0);
     } else {
       // Could be an Undef.  In any case insert an Undef so we can see what we
       // dropped.
-      MIB.addReg(0U);
+      Register Reg = SD->getVRegForEntryValue();
+      DIExpression *EntryValueExpr = SD->getEntryExpression();
+      if (Reg && TM.Options.ShouldEmitDebugEntryValues())
+        Expr = DIExpression::prepend(cast<DIExpression>(EntryValueExpr),
+                                     DIExpression::EntryValue);
+      MIB.addReg(Reg, RegState::Debug);
     }
   } else {
     // Insert an Undef so we can see what we dropped.
     MIB.addReg(0U);
   }
 
   // Indirect addressing is indicated by an Imm as the second parameter.
   if (SD->isIndirect())

llvm/lib/CodeGen/SelectionDAG/SDNodeDbgValue.h

struct {
       unsigned ResNo;       ///< Valid for expressions.
     } s;
     const Value *Const;     ///< Valid for constants.
     unsigned FrameIx;       ///< Valid for stack objects.
     unsigned VReg;          ///< Valid for registers.
   } u;
   DIVariable *Var;
   DIExpression *Expr;
+  DIExpression *EntryExpr;
   DebugLoc DL;
   unsigned Order;
+  unsigned VRegForEntryValue = 0;
   enum DbgValueKind kind;
   bool IsIndirect;
   bool Invalid = false;
   bool Emitted = false;
 
 public:
   /// Constructor for non-constants.
   SDDbgValue(DIVariable *Var, DIExpression *Expr, SDNode *N, unsigned R,
-             bool indir, DebugLoc dl, unsigned O)
-      : Var(Var), Expr(Expr), DL(std::move(dl)), Order(O), IsIndirect(indir) {
+             bool indir, DebugLoc dl, unsigned O, unsigned vRegForEntryValue,
+             DIExpression *EntryExpr)
+      : Var(Var), Expr(Expr), EntryExpr(EntryExpr), DL(std::move(dl)), Order(O),
+        VRegForEntryValue(vRegForEntryValue), IsIndirect(indir) {
     kind = SDNODE;
     u.s.Node = N;
     u.s.ResNo = R;
   }
 
   /// Constructor for constants.
   SDDbgValue(DIVariable *Var, DIExpression *Expr, const Value *C, DebugLoc dl,
-             unsigned O)
-      : Var(Var), Expr(Expr), DL(std::move(dl)), Order(O), IsIndirect(false) {
+             unsigned O, unsigned vRegForEntryValue, DIExpression *EntryExpr)
+      : Var(Var), Expr(Expr), EntryExpr(EntryExpr), DL(std::move(dl)),
+        Order(O), VRegForEntryValue(vRegForEntryValue), IsIndirect(false) {
     kind = CONST;
     u.Const = C;
   }
 
   /// Constructor for virtual registers and frame indices.
   SDDbgValue(DIVariable *Var, DIExpression *Expr, unsigned VRegOrFrameIdx,
              bool IsIndirect, DebugLoc DL, unsigned Order,
              enum DbgValueKind Kind)
public:
   const Value *getConst() const { assert (kind==CONST); return u.Const; }
 
   /// Returns the FrameIx for a stack object
   unsigned getFrameIx() const { assert (kind==FRAMEIX); return u.FrameIx; }
 
   /// Returns the Virtual Register for a VReg
   unsigned getVReg() const { assert (kind==VREG); return u.VReg; }
 
+  /// Returns the Virtual Register for an entry value.
+  unsigned getVRegForEntryValue() const { return VRegForEntryValue; }
+
+  /// Returns an expression that applies onto entry value.
+  DIExpression *getEntryExpression() const { return EntryExpr; }
+
   /// Returns whether this is an indirect value.
   bool isIndirect() const { return IsIndirect; }
 
   /// Returns the DebugLoc.
   DebugLoc getDebugLoc() const { return DL; }
 
   /// Returns the SDNodeOrder.  This is the order of the preceding node in the
   /// input.

llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp

SDNode *SelectionDAG::getNodeIfExists(unsigned Opcode, SDVTList VTList,
   return nullptr;
 }
 
 /// getDbgValue - Creates a SDDbgValue node.
 ///
 /// SDNode
 SDDbgValue *SelectionDAG::getDbgValue(DIVariable *Var, DIExpression *Expr,
                                       SDNode *N, unsigned R, bool IsIndirect,
-                                      const DebugLoc &DL, unsigned O) {
+                                      const DebugLoc &DL, unsigned O,
+                                      unsigned VRegForEntryValue,
+                                      DIExpression *EntryExpr) {
   assert(cast<DILocalVariable>(Var)->isValidLocationForIntrinsic(DL) &&
          "Expected inlined-at fields to agree");
   return new (DbgInfo->getAlloc())
-      SDDbgValue(Var, Expr, N, R, IsIndirect, DL, O);
+      SDDbgValue(Var, Expr, N, R, IsIndirect, DL, O, VRegForEntryValue,
+                 EntryExpr);
 }
 
 /// Constant
 SDDbgValue *SelectionDAG::getConstantDbgValue(DIVariable *Var,
                                               DIExpression *Expr,
                                               const Value *C,
-                                              const DebugLoc &DL, unsigned O) {
+                                              const DebugLoc &DL, unsigned O,
+                                              unsigned EntryValueReg,
+                                              DIExpression *EntryExpr) {
   assert(cast<DILocalVariable>(Var)->isValidLocationForIntrinsic(DL) &&
          "Expected inlined-at fields to agree");
-  return new (DbgInfo->getAlloc()) SDDbgValue(Var, Expr, C, DL, O);
+  return new (DbgInfo->getAlloc())
+      SDDbgValue(Var, Expr, C, DL, O, EntryValueReg, EntryExpr);
 }
 
 /// FrameIndex
 SDDbgValue *SelectionDAG::getFrameIndexDbgValue(DIVariable *Var,
                                                 DIExpression *Expr, unsigned FI,
                                                 bool IsIndirect,
                                                 const DebugLoc &DL,
                                                 unsigned O) {

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.h

public:
   /// resolve the debuginfo to something that is represented in this DAG. If
   /// this cannot be done, produce an Undef debug value record.
   void salvageUnresolvedDbgValue(DanglingDebugInfo &DDI);
 
   /// For a given Value, attempt to create and record a SDDbgValue in the
   /// SelectionDAG.
   bool handleDebugValue(const Value *V, DILocalVariable *Var,
                         DIExpression *Expr, DebugLoc CurDL,
-                        DebugLoc InstDL, unsigned Order);
+                        DebugLoc InstDL, unsigned Order,
+                        const Value *EntryValue = nullptr,
+                        DIExpression *EntryExpr = nullptr);
 
   /// Evict any dangling debug information, attempting to salvage it first.
   void resolveOrClearDbgInfo();
 
   SDValue getValue(const Value *V);
 
   /// Return the SDNode for the specified IR value if it exists.
   SDNode *getNodeForIRValue(const Value *V) {
private:
 
   /// Update the DAG and DAG builder with the relevant information after
   /// a new root node has been created which could be a tail call.
   void updateDAGForMaybeTailCall(SDValue MaybeTC);
 
   /// Return the appropriate SDDbgValue based on N.
   SDDbgValue *getDbgValue(SDValue N, DILocalVariable *Variable,
                           DIExpression *Expr, const DebugLoc &dl,
-                          unsigned DbgSDNodeOrder);
+                          unsigned DbgSDNodeOrder,
+                          unsigned vRegForEntryValue = 0,
+                          DIExpression *EntryExpr = nullptr);
 
   /// Lowers CallInst to an external symbol.
   void lowerCallToExternalSymbol(const CallInst &I, const char *FunctionName);
 };
 
 /// This struct represents the registers (physical or virtual)
 /// that a particular set of values is assigned, and the type information about
 /// the value. The most common situation is to represent one value at a time,

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

void SelectionDAGBuilder::salvageUnresolvedDbgValue(DanglingDebugInfo &DDI) {
   LLVM_DEBUG(dbgs() << "Dropping debug value info for:\n  " << DDI.getDI()
                     << "\n");
   LLVM_DEBUG(dbgs() << "  Last seen at:\n    " << *DDI.getDI()->getOperand(0)
                     << "\n");
 }
 
 bool SelectionDAGBuilder::handleDebugValue(const Value *V, DILocalVariable *Var,
                                            DIExpression *Expr, DebugLoc dl,
-                                           DebugLoc InstDL, unsigned Order) {
+                                           DebugLoc InstDL, unsigned Order,
+                                           const Value *EntryValue,
+                                           DIExpression *EntryExpr) {
   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
   SDDbgValue *SDV;
   if (isa<ConstantInt>(V) || isa<ConstantFP>(V) || isa<UndefValue>(V) ||
       isa<ConstantPointerNull>(V)) {
-    SDV = DAG.getConstantDbgValue(Var, Expr, V, dl, SDNodeOrder);
+    unsigned EntryValueReg = 0;
+    if (isa<UndefValue>(V)) {
+      auto EVMI = FuncInfo.ArgValueMap.find(EntryValue);
+      if (EVMI != FuncInfo.ArgValueMap.end())
+         EntryValueReg = EVMI->second;
+    }
+
+    SDV = DAG.getConstantDbgValue(Var, Expr, V, dl, SDNodeOrder, EntryValueReg,
+                                  EntryExpr);
+
     DAG.AddDbgValue(SDV, nullptr, false);
     return true;
   }
 
   // If the Value is a frame index, we can create a FrameIndex debug value
   // without relying on the DAG at all.
   if (const AllocaInst *AI = dyn_cast<AllocaInst>(V)) {
     auto SI = FuncInfo.StaticAllocaMap.find(AI);
bool SelectionDAGBuilder::handleDebugValue(const Value *V, DILocalVariable *Var,
   // Do not use getValue() in here; we don't want to generate code at
   // this point if it hasn't been done yet.
   SDValue N = NodeMap[V];
   if (!N.getNode() && isa<Argument>(V)) // Check unused arguments map.
     N = UnusedArgNodeMap[V];
   if (N.getNode()) {
     if (EmitFuncArgumentDbgValue(V, Var, Expr, dl, false, N))
       return true;
-    SDV = getDbgValue(N, Var, Expr, dl, SDNodeOrder);
+    unsigned EntryValueReg = 0;
+    auto EVMI = FuncInfo.ArgValueMap.find(EntryValue);
+    if (EVMI != FuncInfo.ArgValueMap.end())
+       EntryValueReg = EVMI->second;
+    SDV = getDbgValue(N, Var, Expr, dl, SDNodeOrder, EntryValueReg,
+                      EntryExpr);
     DAG.AddDbgValue(SDV, N.getNode(), false);
     return true;
   }
 
   // Special rules apply for the first dbg.values of parameter variables in a
   // function. Identify them by the fact they reference Argument Values, that
   // they're parameters, and they are parameters of the current function. We
   // need to let them dangle until they get an SDNode.
if (Reg && Reg.isVirtual()) {
       Register PR = RegInfo.getLiveInPhysReg(Reg);
       if (PR)
         Reg = PR;
     }
     if (Reg) {
       Op = MachineOperand::CreateReg(Reg, false);
       IsIndirect = IsDbgDeclare;
     }
+
+    // Map the register into the Value, so it can be used for debug
+    // info recovering.
+    if (FuncInfo.ArgValueMap.find(V) == FuncInfo.ArgValueMap.end())
+      FuncInfo.ArgValueMap[V] = Reg;
   }
 
   if (!Op && N.getNode()) {
     // Check if frame index is available.
     SDValue LCandidate = peekThroughBitcasts(N);
     if (LoadSDNode *LNode = dyn_cast<LoadSDNode>(LCandidate.getNode()))
       if (FrameIndexSDNode *FINode =
           dyn_cast<FrameIndexSDNode>(LNode->getBasePtr().getNode()))
bool SelectionDAGBuilder::EmitFuncArgumentDbgValue(
   return true;
 }
 
 /// Return the appropriate SDDbgValue based on N.
 SDDbgValue *SelectionDAGBuilder::getDbgValue(SDValue N,
                                              DILocalVariable *Variable,
                                              DIExpression *Expr,
                                              const DebugLoc &dl,
-                                             unsigned DbgSDNodeOrder) {
+                                             unsigned DbgSDNodeOrder,
+                                             unsigned vRegForEntryValue,
+                                             DIExpression *EntryExpr) {
   if (auto *FISDN = dyn_cast<FrameIndexSDNode>(N.getNode())) {
     // Construct a FrameIndexDbgValue for FrameIndexSDNodes so we can describe
     // stack slot locations.
     //
     // Consider "int x = 0; int *px = &x;". There are two kinds of interesting
     // debug values here after optimization:
     //
     //   dbg.value(i32* %px, !"int *px", !DIExpression()), and
     //   dbg.value(i32* %px, !"int x", !DIExpression(DW_OP_deref))
     //
     // Both describe the direct values of their associated variables.
     return DAG.getFrameIndexDbgValue(Variable, Expr, FISDN->getIndex(),
                                      /*IsIndirect*/ false, dl, DbgSDNodeOrder);
   }
   return DAG.getDbgValue(Variable, Expr, N.getNode(), N.getResNo(),
-                         /*IsIndirect*/ false, dl, DbgSDNodeOrder);
+                         /*IsIndirect*/ false, dl, DbgSDNodeOrder,
+                         vRegForEntryValue, EntryExpr);
 }
 
 static unsigned FixedPointIntrinsicToOpcode(unsigned Intrinsic) {
   switch (Intrinsic) {
   case Intrinsic::smul_fix:
     return ISD::SMULFIX;
   case Intrinsic::umul_fix:
     return ISD::UMULFIX;
case Intrinsic::dbg_value: {
 
     DILocalVariable *Variable = DI.getVariable();
     DIExpression *Expression = DI.getExpression();
     dropDanglingDebugInfo(Variable, Expression);
     const Value *V = DI.getValue();
     if (!V)
       return;
 
+    const Value *EntryValue = DI.getVariableEntryValue();
+    DIExpression *EntryExpression = DI.getEntryExpression();
+
     if (handleDebugValue(V, Variable, Expression, dl, DI.getDebugLoc(),
-        SDNodeOrder))
+        SDNodeOrder, EntryValue, EntryExpression))
       return;
 
     // TODO: Dangling debug info will eventually either be resolved or produce
     // an Undef DBG_VALUE. However in the resolution case, a gap may appear
     // between the original dbg.value location and its resolved DBG_VALUE, which
     // we should ideally fill with an extra Undef DBG_VALUE.
 
     DanglingDebugInfoMap[V].emplace_back(&DI, dl, SDNodeOrder);

llvm/test/DebugInfo/X86/entry-val-invalidated-node-modifed-param-with-add.ll

+; RUN: llc < %s -O2 -stop-before=finalize-isel | FileCheck %s
+; RUN: llc -O2 %s -o %t -filetype=obj
+; RUN: llvm-dwarfdump %t | FileCheck %s --check-prefix=CHECK-DWARFDUMP
+
+; C producer:
+; void baz();
+; void bar();
+;
+; void foo(int param, int param2) {
+;   baz();
+;   param = param2 + 2;
+;   bar();
+; }
+
+; $ clang -g -O2 test.c -S -emit-llvm
+
+; CHECK: DBG_VALUE $edi, $noreg, !12, !DIExpression()
+; CHECK: DBG_VALUE $esi, $noreg, !12, !DIExpression(DW_OP_LLVM_entry_value, 1, DW_OP_plus_uconst, 2, DW_OP_stack_value)
+
+; CHECK-DWARFDUMP: DW_OP_GNU_entry_value(DW_OP_reg4 RSI), DW_OP_constu 0xffffffff, DW_OP_and, DW_OP_plus_uconst 0x2, DW_OP_stack_value
+; CHECK-DWARFDUMP: DW_OP_GNU_entry_value(DW_OP_reg4 RSI), DW_OP_stack_value
+
+; ModuleID = 'test.c'
+source_filename = "test.c"
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+; Function Attrs: nounwind uwtable
+define dso_local void @foo(i32 %param, i32 %param2) local_unnamed_addr !dbg !7 {
+entry:
+  call void @llvm.dbg.value(metadata i32 %param, metadata !12, metadata !DIExpression(), metadata i32 %param, metadata !DIExpression()), !dbg !14
+  call void @llvm.dbg.value(metadata i32 %param2, metadata !13, metadata !DIExpression(), metadata i32 %param2, metadata !DIExpression()), !dbg !14
+  tail call void (...) @baz(), !dbg !15
+  call void @llvm.dbg.value(metadata i32 %param2, metadata !12, metadata !DIExpression(DW_OP_plus_uconst, 2, DW_OP_stack_value), metadata i32 %param2, metadata !DIExpression(DW_OP_plus_uconst, 2, DW_OP_stack_value)), !dbg !14
+  tail call void (...) @bar(), !dbg !16
+  ret void, !dbg !17
+}
+
+declare !dbg !18 dso_local void @baz(...) local_unnamed_addr
+
+declare !dbg !21 dso_local void @bar(...) local_unnamed_addr
+
+; Function Attrs: nounwind readnone speculatable willreturn
+declare void @llvm.dbg.value(metadata, metadata, metadata, metadata, metadata)
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!3, !4, !5}
+!llvm.ident = !{!6}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 12.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
+!1 = !DIFile(filename: "test2.c", directory: "/")
+!2 = !{}
+!3 = !{i32 7, !"Dwarf Version", i32 4}
+!4 = !{i32 2, !"Debug Info Version", i32 3}
+!5 = !{i32 1, !"wchar_size", i32 4}
+!6 = !{!"clang version 12.0.0"}
+!7 = distinct !DISubprogram(name: "foo", scope: !1, file: !1, line: 4, type: !8, scopeLine: 4, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !11)
+!8 = !DISubroutineType(types: !9)
+!9 = !{null, !10, !10}
+!10 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!11 = !{!12, !13}
+!12 = !DILocalVariable(name: "param", arg: 1, scope: !7, file: !1, line: 4, type: !10)
+!13 = !DILocalVariable(name: "param2", arg: 2, scope: !7, file: !1, line: 4, type: !10)
+!14 = !DILocation(line: 0, scope: !7)
+!15 = !DILocation(line: 5, column: 5, scope: !7)
+!16 = !DILocation(line: 7, column: 5, scope: !7)
+!17 = !DILocation(line: 8, column: 1, scope: !7)
+!18 = !DISubprogram(name: "baz", scope: !1, file: !1, line: 1, type: !19, spFlags: DISPFlagOptimized, retainedNodes: !2)
+!19 = !DISubroutineType(types: !20)
+!20 = !{null, null}
+!21 = !DISubprogram(name: "bar", scope: !1, file: !1, line: 2, type: !19, spFlags: DISPFlagOptimized, retainedNodes: !2)

llvm/test/DebugInfo/X86/entry-val-invalidated-node-modifed-param.ll

+; RUN: llc < %s -O2 -stop-before=finalize-isel | FileCheck %s
+; RUN: llc -O2 %s -o %t -filetype=obj
+; RUN: llvm-dwarfdump %t | FileCheck %s --check-prefix=CHECK-DWARFDUMP
+
+; C producer:
+; void baz();
+; void bar();
+;
+; void foo(int param, int param2) {
+;   baz();
+;   param = param2;
+;   bar();
+; }
+
+; $ clang -g -O2 test.c -S -emit-llvm
+
+; CHECK: DBG_VALUE $edi, $noreg, !12, !DIExpression()
+; CHECK: DBG_VALUE $esi, $noreg, !12, !DIExpression(DW_OP_LLVM_entry_value, 1)
+
+; CHECK-DWARFDUMP: DW_OP_GNU_entry_value(DW_OP_reg4 RSI), DW_OP_stack_value
+; CHECK-DWARFDUMP: DW_OP_GNU_entry_value(DW_OP_reg4 RSI), DW_OP_stack_value
+
+; ModuleID = 'test.c'
+source_filename = "test.c"
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+; Function Attrs: nounwind uwtable
+define dso_local void @foo(i32 %param, i32 %param2) local_unnamed_addr !dbg !7 {
+entry:
+  call void @llvm.dbg.value(metadata i32 %param, metadata !12, metadata !DIExpression(), metadata i32 %param, metadata !DIExpression()), !dbg !14
+  call void @llvm.dbg.value(metadata i32 %param2, metadata !13, metadata !DIExpression(), metadata i32 %param2, metadata !DIExpression()), !dbg !14
+  tail call void (...) @baz(), !dbg !15
+  call void @llvm.dbg.value(metadata i32 %param2, metadata !12, metadata !DIExpression(), metadata i32 %param2, metadata !DIExpression()), !dbg !14
+  tail call void (...) @bar(), !dbg !16
+  ret void, !dbg !17
+}
+
+declare !dbg !18 dso_local void @baz(...) local_unnamed_addr
+
+declare !dbg !21 dso_local void @bar(...) local_unnamed_addr
+
+; Function Attrs: nounwind readnone speculatable willreturn
+declare void @llvm.dbg.value(metadata, metadata, metadata, metadata, metadata)
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!3, !4, !5}
+!llvm.ident = !{!6}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 12.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
+!1 = !DIFile(filename: "test.c", directory: "/")
+!2 = !{}
+!3 = !{i32 7, !"Dwarf Version", i32 4}
+!4 = !{i32 2, !"Debug Info Version", i32 3}
+!5 = !{i32 1, !"wchar_size", i32 4}
+!6 = !{!"clang version 12.0.0"}
+!7 = distinct !DISubprogram(name: "foo", scope: !1, file: !1, line: 4, type: !8, scopeLine: 4, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !11)
+!8 = !DISubroutineType(types: !9)
+!9 = !{null, !10, !10}
+!10 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!11 = !{!12, !13}
+!12 = !DILocalVariable(name: "param", arg: 1, scope: !7, file: !1, line: 4, type: !10)
+!13 = !DILocalVariable(name: "param2", arg: 2, scope: !7, file: !1, line: 4, type: !10)
+!14 = !DILocation(line: 0, scope: !7)
+!15 = !DILocation(line: 5, column: 5, scope: !7)
+!16 = !DILocation(line: 7, column: 5, scope: !7)
+!17 = !DILocation(line: 8, column: 1, scope: !7)
+!18 = !DISubprogram(name: "baz", scope: !1, file: !1, line: 1, type: !19, spFlags: DISPFlagOptimized, retainedNodes: !2)
+!19 = !DISubroutineType(types: !20)
+!20 = !{null, null}
+!21 = !DISubprogram(name: "bar", scope: !1, file: !1, line: 2, type: !19, spFlags: DISPFlagOptimized, retainedNodes: !2)

llvm/test/DebugInfo/X86/entry-values-for-isel-invalidated-nodes.ll

+; RUN: llc < %s -O2 -stop-before=finalize-isel | FileCheck %s
+; RUN: llc -O2 %s -o %t -filetype=obj
+; RUN: llvm-dwarfdump %t | FileCheck %s --check-prefix=CHECK-DWARFDUMP
+
+; C producer:
+; void f1(int);
+; void f2(int i) {
+;    f1(1);
+;    i = i + 5;
+;    f1(3);
+; }
+; $ clang -g -O2 test.c -S -emit-llvm
+
+; CHECK: DBG_VALUE $edi, $noreg, !{{.*}}, !DIExpression()
+; CHECK: DBG_VALUE $edi, $noreg, !{{.*}}, !DIExpression(DW_OP_LLVM_entry_value, 1, DW_OP_plus_uconst, 5, DW_OP_stack_value)
+
+; CHECK-DWARFDUMP: DW_OP_GNU_entry_value(DW_OP_reg5 RDI), DW_OP_stack_value
+; CHECK-DWARFDUMP: DW_OP_GNU_entry_value(DW_OP_reg5 RDI), DW_OP_constu 0xffffffff, DW_OP_and, DW_OP_plus_uconst 0x5, DW_OP_stack_value
+
+; ModuleID = 'test.c'
+source_filename = "test.c"
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+; Function Attrs: nounwind uwtable
+define dso_local void @f2(i32 %i) local_unnamed_addr #0 !dbg !7 {
+entry:
+  call void @llvm.dbg.value(metadata i32 %i, metadata !12, metadata !DIExpression(), metadata i32 %i, metadata !DIExpression()), !dbg !13
+  tail call void @f1(i32 1) #3, !dbg !14
+  call void @llvm.dbg.value(metadata i32 %i, metadata !12, metadata !DIExpression(DW_OP_plus_uconst, 5, DW_OP_stack_value), metadata i32 %i, metadata !DIExpression(DW_OP_plus_uconst, 5, DW_OP_stack_value)), !dbg !13
+  tail call void @f1(i32 3) #3, !dbg !15
+  ret void, !dbg !16
+}
+
+declare !dbg !17 dso_local void @f1(i32) local_unnamed_addr
+
+; Function Attrs: nounwind readnone speculatable willreturn
+declare void @llvm.dbg.value(metadata, metadata, metadata, metadata, metadata)
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!3, !4, !5}
+!llvm.ident = !{!6}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 12.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
+!1 = !DIFile(filename: "test.c", directory: "/dir")
+!2 = !{}
+!3 = !{i32 7, !"Dwarf Version", i32 4}
+!4 = !{i32 2, !"Debug Info Version", i32 3}
+!5 = !{i32 1, !"wchar_size", i32 4}
+!6 = !{!"clang version 12.0.0"}
+!7 = distinct !DISubprogram(name: "f2", scope: !1, file: !1, line: 2, type: !8, scopeLine: 2, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !11)
+!8 = !DISubroutineType(types: !9)
+!9 = !{null, !10}
+!10 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!11 = !{!12}
+!12 = !DILocalVariable(name: "i", arg: 1, scope: !7, file: !1, line: 2, type: !10)
+!13 = !DILocation(line: 0, scope: !7)
+!14 = !DILocation(line: 3, column: 4, scope: !7)
+!15 = !DILocation(line: 5, column: 4, scope: !7)
+!16 = !DILocation(line: 6, column: 1, scope: !7)
+!17 = !DISubprogram(name: "f1", scope: !1, file: !1, line: 1, type: !8, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !2)