[DebugInfo] Replace UndefValue with PoisonValue in AssignmentTrackingAnalysis

[Orlando]

Summary

This helps towards the effort to remove UndefValue from LLVM.

Related to https://discourse.llvm.org/t/auto-undef-debug-uses-of-a-deleted-value

[scott.linder]

Code LGTM, thank you! One small request is to move some comments around and update llvm/docs/AssignmentTracking.md to reflect the change.

Something like:

The first three parameters look and behave like an llvm.dbg.value. ID is a reference to a store (see next section). Address is the destination address of the store and it is modified by AddressExpression. An empty/undef/poison Address represents <...>.

llvm/include/llvm/IR/IntrinsicInst.h

451 ↗

(On Diff #486009)

I vote for a short doc comment mentioning that this is the only correct way to ask a DbgAssignIntrinsic whether it "kills" the address-based location.

llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp

1481–1482

Somewhat stale reference to undef directly here. Could the comment just be folded into a general one on isAddressKillLocation itself?

[Orlando]

Thanks for the review!

+ Update the docs
+ Open new parent patch D141125 that adds is/setKillAddress

[scott.linder]

LGTM, thank you!

llvm/docs/AssignmentTracking.md

void @llvm.dbg.assign(Value *Value,
                       DILocalVariable *Variable,
                       DIAssignID *ID,
                       Value *Address,
                       DIExpression *AddressExpression)
 ```
 
 The first three parameters look and behave like an `llvm.dbg.value`. `ID` is a
 reference to a store (see next section). `Address` is the destination address
-of the store and it is modified by `AddressExpression`. LLVM currently encodes
-variable fragment information in `DIExpression`s, so as an implementation quirk
-the `FragmentInfo` for `Variable` is contained within `ValueExpression` only.
+of the store and it is modified by `AddressExpression`. An empty/undef/poison
+address means the address component has been killed (the memory address is no
+longer a valid location). LLVM currently encodes variable fragment information
+in `DIExpression`s, so as an implementation quirk the `FragmentInfo` for
+`Variable` is contained within `ValueExpression` only.
 
 The formal LLVM-IR signature is:
 ```
 void @llvm.dbg.assign(metadata, metadata, metadata, metadata, metadata, metadata)
 ```
 
 ### Instruction link: `DIAssignID`
 

llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp

 
 void AssignmentTrackingLowering::emitDbgValue(
     AssignmentTrackingLowering::LocKind Kind,
     const DbgVariableIntrinsic *Source, Instruction *After) {
 
   DILocation *DL = Source->getDebugLoc();
   auto Emit = [this, Source, After, DL](Value *Val, DIExpression *Expr) {
     assert(Expr);
-    // It's possible that getVariableLocationOp(0) is null. Occurs in
-    // llvm/test/DebugInfo/Generic/2010-05-03-OriginDIE.ll Treat it as undef.
     if (!Val)
-      Val = UndefValue::get(Type::getInt1Ty(Source->getContext()));
+      Val = PoisonValue::get(Type::getInt1Ty(Source->getContext()));
 
     // Find a suitable insert point.
     Instruction *InsertBefore = After->getNextNode();
     assert(InsertBefore && "Shouldn't be inserting after a terminator");
 
     VariableID Var = getVariableID(DebugVariable(Source));
     VarLocInfo VarLoc;
     VarLoc.VariableID = static_cast<VariableID>(Var);
if (DAI->isKillAddress()) {
       Emit(Val, Expr);
       return;
     }
   }
 
   if (Kind == LocKind::Val) {
     /// Get the value component, converting to Undef if it is variadic.
     Value *Val =
-        Source->hasArgList()
-            ? UndefValue::get(Source->getVariableLocationOp(0)->getType())
-            : Source->getVariableLocationOp(0);
+        Source->hasArgList() ? nullptr : Source->getVariableLocationOp(0);
     Emit(Val, Source->getExpression());
     return;
   }
 
   if (Kind == LocKind::None) {
-    Value *Val = UndefValue::get(Source->getVariableLocationOp(0)->getType());
-    Emit(Val, Source->getExpression());
+    Emit(nullptr, Source->getExpression());
     return;
   }
 }
 
 void AssignmentTrackingLowering::processNonDbgInstruction(
     Instruction &I, AssignmentTrackingLowering::BlockInfo *LiveSet) {
   if (I.hasMetadata(LLVMContext::MD_DIAssignID))
     processTaggedInstruction(I, LiveSet);
LLVM_DEBUG(dbgs() << "   LiveLoc " << locStr(getLocKind(LiveSet, Var))
                     << " -> ");
 
   // Check if the DebugValue and StackHomeValue both hold the same
   // Assignment.
   if (hasVarWithAssignment(Var, AV, LiveSet->StackHomeValue)) {
     // They match. We can use the stack home because the debug intrinsics state
     // that an assignment happened here, and we know that specific assignment
     // was the last one to take place in memory for this variable.
     LocKind Kind;
     if (DAI.isKillAddress()) {
       LLVM_DEBUG(
           dbgs()
               << "Val, Stack matches Debug program but address is killed\n";);
       Kind = LocKind::Val;
     } else {
       LLVM_DEBUG(dbgs() << "Mem, Stack matches Debug program\n";);
       Kind = LocKind::Mem;
     };
for (auto &I : BB) {
       if (!DVI)
         continue;
       // Skip variables that haven't been promoted - we've dealt with those
       // already.
       if (VarsWithStackSlot->contains(getAggregate(DVI)))
         continue;
       // Wrapper to get a single value (or undef) from DVI.
       auto GetValue = [DVI]() -> Value * {
-        // Conditions for undef: Any operand undef, zero operands or single
-        // operand is nullptr. We also can't handle variadic DIExpressions yet.
-        // Some of those conditions don't have a type we can pick for
-        // undef. Use i32.
+        // We can't handle variadic DIExpressions yet so treat those as
+        // kill locations.
         if (DVI->isKillLocation() || DVI->getValue() == nullptr ||
             DVI->hasArgList())
-          return UndefValue::get(Type::getInt32Ty(DVI->getContext()));
+          return PoisonValue::get(Type::getInt32Ty(DVI->getContext()));
         return DVI->getValue();
       };
       Instruction *InsertBefore = I.getNextNode();
       assert(InsertBefore && "Unexpected: debug intrinsics after a terminator");
       FnVarLocs->addVarLoc(InsertBefore, DebugVariable(DVI),
                            DVI->getExpression(), DVI->getDebugLoc(),
                            GetValue());
       InsertedAnyIntrinsics = true;