[NFC][Assignment Tracking] add is/setKillAddress

[Orlando]

Summary

Unlike D140903 this patch folds in treating an empty metadata address component of a dbg.assign the same as undef because it was already being treated that way in the AssignmentTrackingAnalysis pass.

llvm/include/llvm/IR/IntrinsicInst.h

DIExpression *getAddressExpression() const {
     return cast<DIExpression>(getRawAddressExpression());
   }
   void setAddressExpression(DIExpression *NewExpr) {
     setArgOperand(OpAddressExpr,
                   MetadataAsValue::get(NewExpr->getContext(), NewExpr));
   }
   void setAssignId(DIAssignID *New);
   void setAddress(Value *V);
+  /// Kill the address component.
+  void setKillAddress();
+  /// Check whether this kills the address component. This doesn't take into
+  /// account the position of the intrinsic, therefore a returned value of false
+  /// does not guarentee the address is a valid location for the variable at the
+  /// intrinsic's position in IR.
+  bool isKillAddress() const;
   void setValue(Value *V);
   /// \name Casting methods
   /// @{
   static bool classof(const IntrinsicInst *I) {
     return I->getIntrinsicID() == Intrinsic::dbg_assign;
   }
   static bool classof(const Value *V) {
     return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));

llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp

auto Emit = [this, Source, After, DL](Value *Val, DIExpression *Expr) {
     InsertBeforeMap[InsertBefore].push_back(VarLoc);
   };
 
   // NOTE: This block can mutate Kind.
   if (Kind == LocKind::Mem) {
     const auto *DAI = cast<DbgAssignIntrinsic>(Source);
     // Check the address hasn't been dropped (e.g. the debug uses may not have
     // been replaced before deleting a Value).
-    if (Value *Val = DAI->getAddress()) {
+    if (DAI->isKillAddress()) {
+      // The address isn't valid so treat this as a non-memory def.
+      Kind = LocKind::Val;
+    } else {
+      Value *Val = DAI->getAddress();
       DIExpression *Expr = DAI->getAddressExpression();
       assert(!Expr->getFragmentInfo() &&
              "fragment info should be stored in value-expression only");
       // Copy the fragment info over from the value-expression to the new
       // DIExpression.
       if (auto OptFragInfo = Source->getExpression()->getFragmentInfo()) {
         auto FragInfo = *OptFragInfo;
         Expr = *DIExpression::createFragmentExpression(
             Expr, FragInfo.OffsetInBits, FragInfo.SizeInBits);
       }
       // The address-expression has an implicit deref, add it now.
       std::tie(Val, Expr) =
           walkToAllocaAndPrependOffsetDeref(Layout, Val, Expr);
       Emit(Val, Expr);
       return;
-    } else {
-      // The address isn't valid so treat this as a non-memory def.
-      Kind = LocKind::Val;
     }
   }
 
   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())
void AssignmentTrackingLowering::processDbgAssign(DbgAssignIntrinsic &DAI,
 
   // 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 (isa<UndefValue>(DAI.getAddress())) {
-      // Address may be undef to indicate that although the store does take
-      // place, this part of the original store has been elided.
+    if (DAI.isKillAddress()) {
       LLVM_DEBUG(
-          dbgs() << "Val, Stack matches Debug program but address is undef\n";);
+          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;
     };
     setLocKind(LiveSet, Var, Kind);
     emitDbgValue(Kind, &DAI, &DAI);
   } else {

llvm/lib/IR/IntrinsicInst.cpp

 
 void DbgAssignIntrinsic::setAddress(Value *V) {
   assert(V->getType()->isPointerTy() &&
          "Destination Component must be a pointer type");
   setOperand(OpAddress,
              MetadataAsValue::get(getContext(), ValueAsMetadata::get(V)));
 }
 
+void DbgAssignIntrinsic::setKillAddress() {
+  if (isKillAddress())
+    return;
+  setAddress(UndefValue::get(getAddress()->getType()));
+}
+
+bool DbgAssignIntrinsic::isKillAddress() const {
+  Value *Addr = getAddress();
+  return !Addr || isa<UndefValue>(Addr);
+}
+
 void DbgAssignIntrinsic::setValue(Value *V) {
   setOperand(OpValue,
              MetadataAsValue::get(getContext(), ValueAsMetadata::get(V)));
 }
 
 int llvm::Intrinsic::lookupLLVMIntrinsicByName(ArrayRef<const char *> NameTable,
                                                StringRef Name) {
   assert(Name.startswith("llvm."));

llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp

for (auto *DAI : at::getAssignmentMarkers(Inst)) {
 
     // Fragments overlap: insert a new dbg.assign for this dead part.
     auto *NewAssign = cast<DbgAssignIntrinsic>(DAI->clone());
     NewAssign->insertAfter(DAI);
     if (!LinkToNothing)
       LinkToNothing = DIAssignID::getDistinct(Inst->getContext());
     NewAssign->setAssignId(LinkToNothing);
     NewAssign->setExpression(CreateDeadFragExpr());
-    NewAssign->setAddress(UndefValue::get(DAI->getAddress()->getType()));
+    NewAssign->setKillAddress();
   }
 }
 
 static bool tryToShorten(Instruction *DeadI, int64_t &DeadStart,
                          uint64_t &DeadSize, int64_t KillingStart,
                          uint64_t KillingSize, bool IsOverwriteEnd) {
   auto *DeadIntrinsic = cast<AnyMemIntrinsic>(DeadI);
   Align PrefAlign = DeadIntrinsic->getDestAlign().valueOrOne();

llvm/lib/Transforms/Utils/Local.cpp

static void salvageDbgAssignAddress(DbgAssignIntrinsic *DAI) {
   assert(!SalvagedExpr->getFragmentInfo().has_value() &&
          "address-expression shouldn't have fragment info");
 
   // Salvage succeeds if no additional values are required.
   if (AdditionalValues.empty()) {
     DAI->setAddress(NewV);
     DAI->setAddressExpression(SalvagedExpr);
   } else {
-    DAI->setAddress(UndefValue::get(I->getType()));
+    DAI->setKillAddress();
   }
 }
 
 void llvm::salvageDebugInfoForDbgValues(
     Instruction &I, ArrayRef<DbgVariableIntrinsic *> DbgUsers) {
   // These are arbitrary chosen limits on the maximum number of values and the
   // maximum size of a debug expression we can salvage up to, used for
   // performance reasons.