[DebugInfo][NFC] Rename is/setUndef to is/setKilllocation

[Orlando]

Summary

These names better reflect the semantics and also the implementation, since it's not just "undef" operands that are sentinels used to signal that the debug intrinsic terminates dominating locations definitions.

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

[StephenTozer]

LGTM with the suggested "changes".

llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp

2114

I think the removal of DVI->getValue() == nullptr should be in the previous patch - would call it a nit, but probably important to preserve the obvious trivial-ness of this patch.

llvm/lib/Transforms/Scalar/LoopStrengthReduce.cpp

6549–6551

Also should be moved into the previous patch.

[Orlando]

Thanks for the review(s).

llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp

2114

SGTM, that also lets me re-jig the patch dependencies a bit.

llvm/include/llvm/IR/IntrinsicInst.h

public:
   /// Does this describe the address of a local variable. True for dbg.addr and
   /// dbg.declare, but not dbg.value, which describes its value, or dbg.assign,
   /// which describes a combination of the variable's value and address.
   bool isAddressOfVariable() const {
     return getIntrinsicID() != Intrinsic::dbg_value &&
            getIntrinsicID() != Intrinsic::dbg_assign;
   }
 
-  void setUndef() {
+  void setKillLocation() {
     // TODO: When/if we remove duplicate values from DIArgLists, we don't need
     // this set anymore.
     SmallPtrSet<Value *, 4> RemovedValues;
     for (Value *OldValue : location_ops()) {
       if (!RemovedValues.insert(OldValue).second)
         continue;
       Value *Undef = UndefValue::get(OldValue->getType());
       replaceVariableLocationOp(OldValue, Undef);
     }
   }
 
-  bool isUndef() const {
+  bool isKillLocation() const {
     return (getNumVariableLocationOps() == 0 &&
             !getExpression()->isComplex()) ||
            any_of(location_ops(), [](Value *V) { return isa<UndefValue>(V); });
   }
 
   DILocalVariable *getVariable() const {
     return cast<DILocalVariable>(getRawVariable());
   }

llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp

for (auto &I : BB) {
       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.
-        if (DVI->isUndef() || DVI->getValue() == nullptr || DVI->hasArgList())
+        if (DVI->isKillLocation() || DVI->getValue() == nullptr ||
+            DVI->hasArgList())
           return UndefValue::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());

llvm/lib/CodeGen/CodeGenPrepare.cpp

for (Instruction &Insn : llvm::make_early_inc_range(BB)) {
         // If we depend on multiple instructions and any of them doesn't
         // dominate this DVI, we probably can't salvage it: moving it to
         // after any of the instructions could cause us to lose the others.
         if (VIs.size() > 1) {
           LLVM_DEBUG(
               dbgs()
               << "Unable to find valid location for Debug Value, undefing:\n"
               << *DVI);
-          DVI->setUndef();
+          DVI->setKillLocation();
           break;
         }
 
         LLVM_DEBUG(dbgs() << "Moving Debug Value before :\n"
                           << *DVI << ' ' << *VI);
         DVI->removeFromParent();
         if (isa<PHINode>(VI))
           DVI->insertBefore(&*VI->getParent()->getFirstInsertionPt());

llvm/lib/Transforms/Scalar/LoopStrengthReduce.cpp

static void restorePreTransformState(DVIRecoveryRec &DVIRec) {
   }
   LLVM_DEBUG(dbgs() << "scev-salvage: pre-LSR: " << *DVIRec.DVI << '\n');
 }
 
 static bool SalvageDVI(llvm::Loop *L, ScalarEvolution &SE,
                        llvm::PHINode *LSRInductionVar, DVIRecoveryRec &DVIRec,
                        const SCEV *SCEVInductionVar,
                        SCEVDbgValueBuilder IterCountExpr) {
-  if (!DVIRec.DVI->isUndef())
+  if (!DVIRec.DVI->isKillLocation())
     return false;
 
   // LSR may have caused several changes to the dbg.value in the failed salvage
   // attempt. So restore the DIExpression, the location ops and also the
   // location ops format, which is always DIArglist for multiple ops, but only
   // sometimes for a single op.
   restorePreTransformState(DVIRec);
 
static void DbgGatherSalvagableDVI(
     SmallSet<AssertingVH<DbgValueInst>, 2> &DVIHandles) {
   for (const auto &B : L->getBlocks()) {
     for (auto &I : *B) {
       auto DVI = dyn_cast<DbgValueInst>(&I);
       if (!DVI)
         continue;
       // Ensure that if any location op is undef that the dbg.vlue is not
       // cached.
-      if (DVI->isUndef())
+      if (DVI->isKillLocation())
         continue;
 
       // Check that the location op SCEVs are suitable for translation to
       // DIExpression.
       const auto &HasTranslatableLocationOps =
           [&](const DbgValueInst *DVI) -> bool {
         for (const auto LocOp : DVI->location_ops()) {
           if (!LocOp)
             return false;
 
           if (!SE.isSCEVable(LocOp->getType()))
             return false;
 
           const SCEV *S = SE.getSCEV(LocOp);
           if (SE.containsUndefs(S))
             return false;
         }
         return true;

llvm/lib/Transforms/Utils/BasicBlockUtils.cpp

static bool remomveUndefDbgAssignsFromEntryBlock(BasicBlock *BB) {
   for (auto &I : *BB) {
     DbgValueInst *DVI = dyn_cast<DbgValueInst>(&I);
     if (!DVI)
       continue;
     auto *DAI = dyn_cast<DbgAssignIntrinsic>(DVI);
     bool IsDbgValueKind = (!DAI || at::getAssignmentInsts(DAI).empty());
     DebugVariable Aggregate = GetAggregateVariable(DVI);
     if (!SeenDefForAggregate.contains(Aggregate)) {
-      bool IsUndef = DVI->isUndef() && IsDbgValueKind;
-      if (!IsUndef) {
+      bool IsKill = DVI->isKillLocation() && IsDbgValueKind;
+      if (!IsKill) {
         SeenDefForAggregate.insert(Aggregate);
       } else if (DAI) {
         ToBeRemoved.push_back(DAI);
       }
     }
   }
 
   for (DbgAssignIntrinsic *DAI : ToBeRemoved)

llvm/lib/Transforms/Utils/Debugify.cpp

for (BasicBlock &BB : F) {
         if (DebugifyLevel > Level::Locations) {
           if (auto *DVI = dyn_cast<DbgVariableIntrinsic>(&I)) {
             if (!SP)
               continue;
             // Skip inlined variables.
             if (I.getDebugLoc().getInlinedAt())
               continue;
             // Skip undef values.
-            if (DVI->isUndef())
+            if (DVI->isKillLocation())
               continue;
 
             auto *Var = DVI->getVariable();
             DebugInfoBeforePass.DIVariables[Var]++;
             continue;
           }
         }
 
for (BasicBlock &BB : F) {
         if (DebugifyLevel > Level::Locations) {
           if (auto *DVI = dyn_cast<DbgVariableIntrinsic>(&I)) {
             if (!SP)
               continue;
             // Skip inlined variables.
             if (I.getDebugLoc().getInlinedAt())
               continue;
             // Skip undef values.
-            if (DVI->isUndef())
+            if (DVI->isKillLocation())
               continue;
 
             auto *Var = DVI->getVariable();
             DebugInfoAfterPass.DIVariables[Var]++;
             continue;
           }
         }
 

llvm/lib/Transforms/Utils/LoopUtils.cpp

if (ExitBlock) {
     // Since debug values in the loop have been deleted, inserting an undef
     // dbg.value truncates the range of any dbg.value before the loop where the
     // loop used to be. This is particularly important for constant values.
     Instruction *InsertDbgValueBefore = ExitBlock->getFirstNonPHI();
     assert(InsertDbgValueBefore &&
            "There should be a non-PHI instruction in exit block, else these "
            "instructions will have no parent.");
     for (auto *DVI : DeadDebugInst) {
-      DVI->setUndef();
+      DVI->setKillLocation();
       DVI->moveBefore(InsertDbgValueBefore);
     }
   }
 
   // Remove the block from the reference counting scheme, so that we can
   // delete it freely later.
   for (auto *Block : L->blocks())
     Block->dropAllReferences();

llvm/unittests/Transforms/Utils/LocalTest.cpp

TEST(Local, ReplaceAllDbgUsesWith) {
   EXPECT_EQ(ADbgVal->getNumVariableLocationOps(), 1u);
   EXPECT_EQ(ConstantInt::get(A.getType(), 0), ADbgVal->getVariableLocationOp(0));
 
   // Introduce a use-before-def. Check that the dbg.values for %f become undef.
   EXPECT_TRUE(replaceAllDbgUsesWith(F_, G, G, DT));
 
   auto *FDbgVal = cast<DbgValueInst>(F_.getNextNode());
   EXPECT_EQ(FDbgVal->getNumVariableLocationOps(), 1u);
-  EXPECT_TRUE(FDbgVal->isUndef());
+  EXPECT_TRUE(FDbgVal->isKillLocation());
 
   SmallVector<DbgValueInst *, 1> FDbgVals;
   findDbgValues(FDbgVals, &F_);
   EXPECT_EQ(0U, FDbgVals.size());
 
   // Simulate i32 -> i64 conversion to test sign-extension. Here are some
   // interesting cases to handle:
   //  1) debug user has empty DIExpression