[Assignment Tracking][NFC] Use RawLocationWrapper in VarLocInfo [2/x]

[Orlando]

Summary

Use RawLocationWrapper rather than a Value to represent the location operand(s) so that it's possible to represent multiple location operands. AssignmentTrackingAnalysis still converts variadic debug intrinsics to kill locations so this patch is NFC.

llvm/include/llvm/CodeGen/AssignmentTrackingAnalysis.h

 #ifndef LLVM_CODEGEN_ASSIGNMENTTRACKINGANALYSIS_H
 #define LLVM_CODEGEN_ASSIGNMENTTRACKINGANALYSIS_H
 
 #include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/IR/DebugLoc.h"
+#include "llvm/IR/IntrinsicInst.h"
 #include "llvm/Pass.h"
 
 namespace llvm {
 class Function;
 class Instruction;
 class Value;
 class raw_ostream;
 } // namespace llvm
 class FunctionVarLocsBuilder;
 
 namespace llvm {
 /// Type wrapper for integer ID for Variables. 0 is reserved.
 enum class VariableID : unsigned { Reserved = 0 };
 /// Variable location definition used by FunctionVarLocs.
 struct VarLocInfo {
   llvm::VariableID VariableID;
   DIExpression *Expr = nullptr;
   DebugLoc DL;
-  Value *V = nullptr; // TODO: Needs to be value_s_ for variadic expressions.
+  RawLocationWrapper Values = RawLocationWrapper();
 };
 
 /// Data structure describing the variable locations in a function. Used as the
 /// result of the AssignmentTrackingAnalysis pass. Essentially read-only
 /// outside of AssignmentTrackingAnalysis where it is built.
 class FunctionVarLocs {
   /// Maps VarLocInfo.VariableID to a DebugVariable for VarLocRecords.
   SmallVector<DebugVariable> Variables;

llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp

public:
 
   /// Replace the defs that come just before /p Before with /p Wedge.
   void setWedge(const Instruction *Before, SmallVector<VarLocInfo> &&Wedge) {
     VarLocsBeforeInst[Before] = std::move(Wedge);
   }
 
   /// Add a def for a variable that is valid for its lifetime.
   void addSingleLocVar(DebugVariable Var, DIExpression *Expr, DebugLoc DL,
-                       Value *V) {
+                       RawLocationWrapper R) {
     VarLocInfo VarLoc;
     VarLoc.VariableID = insertVariable(Var);
     VarLoc.Expr = Expr;
     VarLoc.DL = DL;
-    VarLoc.V = V;
+    VarLoc.Values = R;
     SingleLocVars.emplace_back(VarLoc);
   }
 
   /// Add a def to the wedge of defs just before /p Before.
   void addVarLoc(Instruction *Before, DebugVariable Var, DIExpression *Expr,
-                 DebugLoc DL, Value *V) {
+                 DebugLoc DL, RawLocationWrapper R) {
     VarLocInfo VarLoc;
     VarLoc.VariableID = insertVariable(Var);
     VarLoc.Expr = Expr;
     VarLoc.DL = DL;
-    VarLoc.V = V;
+    VarLoc.Values = R;
     VarLocsBeforeInst[Before].emplace_back(VarLoc);
   }
 };
 
 void FunctionVarLocs::print(raw_ostream &OS, const Function &Fn) const {
   // Print the variable table first. TODO: Sorting by variable could make the
   // output more stable?
   unsigned Counter = -1;
if (auto F = V.getFragment())
          << F->OffsetInBits + F->SizeInBits << ")";
     if (const auto *IA = V.getInlinedAt())
       OS << " inlined-at " << *IA;
     OS << "\n";
   }
 
   auto PrintLoc = [&OS](const VarLocInfo &Loc) {
     OS << "DEF Var=[" << (unsigned)Loc.VariableID << "]"
-       << " Expr=" << *Loc.Expr << " V=" << *Loc.V << "\n";
+       << " Expr=" << *Loc.Expr << " Values=(";
+    for (auto *Op : Loc.Values.location_ops()) {
+      errs() << Op->getName() << " ";
+    }
+    errs() << ")\n";
   };
 
   // Print the single location variables.
   OS << "=== Single location vars ===\n";
   for (auto It = single_locs_begin(), End = single_locs_end(); It != End;
        ++It) {
     PrintLoc(*It);
   }
using FragsInMemMap = IntervalMap<
       OffsetInBitsTy, BaseAddress,
       IntervalMapImpl::NodeSizer<OffsetInBitsTy, BaseAddress>::LeafSize,
       FragTraits>;
   FragsInMemMap::Allocator IntervalMapAlloc;
   using VarFragMap = DenseMap<unsigned, FragsInMemMap>;
 
   /// IDs for memory location base addresses in maps. Use 0 to indicate that
   /// there's no memory location.
-  UniqueVector<Value *> Bases;
+  UniqueVector<RawLocationWrapper> Bases;
   UniqueVector<DebugAggregate> Aggregates;
   DenseMap<const BasicBlock *, VarFragMap> LiveIn;
   DenseMap<const BasicBlock *, VarFragMap> LiveOut;
 
   struct FragMemLoc {
     unsigned Var;
     unsigned Base;
     unsigned OffsetInBits;
for (const auto &APair : A) {
         return false;
     }
     return true;
   }
 
   /// Return a string for the value that \p BaseID represents.
   std::string toString(unsigned BaseID) {
     if (BaseID)
-      return Bases[BaseID]->getName().str();
+      return Bases[BaseID].getVariableLocationOp(0)->getName().str();
     else
       return "None";
   }
 
   /// Format string describing an FragsInMemMap (IntervalMap) interval.
   std::string toString(FragsInMemMap::const_iterator It, bool Newline = true) {
     std::string String;
     std::stringstream S(String);
void addDef(const VarLocInfo &VarLoc, Instruction &Before, BasicBlock &BB,
     // base pointer, do The Thing, otherwise fall back to normal dbg.value
     // behaviour. AssignmentTrackingLowering has generated DIExpressions
     // written in terms of the base pointer.
     // TODO: Remove this condition since the fragment offset doesn't always
     // equal the offset from base pointer (e.g. for a SROA-split variable).
     const auto DerefOffsetInBytes = getDerefOffsetInBytes(DIExpr);
     const unsigned Base =
         DerefOffsetInBytes && *DerefOffsetInBytes * 8 == StartBit
-            ? Bases.insert(VarLoc.V)
+            ? Bases.insert(VarLoc.Values)
             : 0;
     LLVM_DEBUG(dbgs() << "DEF " << DbgVar.getVariable()->getName() << " ["
                       << StartBit << ", " << EndBit << "): " << toString(Base)
                       << "\n");
 
     // First of all, any locs that use mem that are disrupted need reinstating.
     // Unfortunately, IntervalMap doesn't let us insert intervals that overlap
     // with existing intervals so this code involves a lot of fiddling around

 }
 #endif
 
 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) {
+  auto Emit = [this, Source, After, DL](Metadata *Val, DIExpression *Expr) {
     assert(Expr);
     if (!Val)
-      Val = PoisonValue::get(Type::getInt1Ty(Source->getContext()));
+      Val = ValueAsMetadata::get(
+          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);
     VarLoc.Expr = Expr;
-    VarLoc.V = Val;
+    VarLoc.Values = RawLocationWrapper(Val);
     VarLoc.DL = DL;
     // Insert it into the map for later.
     InsertBeforeMap[InsertBefore].push_back(VarLoc);
   };
 
   // NOTE: This block can mutate Kind.
   if (Kind == LocKind::Mem) {
     const auto *DAI = cast<DbgAssignIntrinsic>(Source);
if (DAI->isKillAddress()) {
       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);
+      Emit(ValueAsMetadata::get(Val), Expr);
       return;
     }
   }
 
   if (Kind == LocKind::Val) {
     /// Get the value component, converting to Undef if it is variadic.
     Value *Val =
         Source->hasArgList() ? nullptr : Source->getVariableLocationOp(0);
-    Emit(Val, Source->getExpression());
+    Emit(ValueAsMetadata::get(Val), Source->getExpression());
     return;
   }
 
   if (Kind == LocKind::None) {
     Emit(nullptr, Source->getExpression());
     return;
   }
 }
for (auto [Var, Info] : It->second) {
     // Get DILocation for this unrecorded assignment.
     DILocation *InlinedAt = const_cast<DILocation *>(V.getInlinedAt());
     const DILocation *DILoc = DILocation::get(
         Fn.getContext(), 0, 0, V.getVariable()->getScope(), InlinedAt);
 
     VarLocInfo VarLoc;
     VarLoc.VariableID = static_cast<VariableID>(Var);
     VarLoc.Expr = DIE;
-    VarLoc.V = const_cast<AllocaInst *>(Info.Base);
+    VarLoc.Values = RawLocationWrapper(
+        ValueAsMetadata::get(const_cast<AllocaInst *>(Info.Base)));
     VarLoc.DL = DILoc;
     // 3. Insert it into the map for later.
     InsertBeforeMap[InsertBefore].push_back(VarLoc);
   }
 }
 
 void AssignmentTrackingLowering::processTaggedInstruction(
     Instruction &I, AssignmentTrackingLowering::BlockInfo *LiveSet) {
static AssignmentTrackingLowering::OverlapMap buildOverlapMapAndRecordDeclares(
   // - untagged store -> Add fragments to FragmentMap and update
   //                     UntaggedStoreVars.
   // We need to add fragments for untagged stores too so that we can correctly
   // clobber overlapped fragment locations later.
   for (auto &BB : Fn) {
     for (auto &I : BB) {
       if (auto *DDI = dyn_cast<DbgDeclareInst>(&I)) {
         FnVarLocs->addSingleLocVar(DebugVariable(DDI), DDI->getExpression(),
-                                   DDI->getDebugLoc(), DDI->getAddress());
+                                   DDI->getDebugLoc(),
+                                   DDI->getWrappedLocation());
       } else if (auto *DII = dyn_cast<DbgVariableIntrinsic>(&I)) {
         DebugVariable DV = DebugVariable(DII);
         DebugAggregate DA = {DV.getVariable(), DV.getInlinedAt()};
         if (Seen.insert(DV).second)
           FragmentMap[DA].push_back(DV);
       } else if (auto Info = getUntaggedStoreAssignmentInfo(
                      I, Fn.getParent()->getDataLayout())) {
         // Find markers linked to this alloca.
for (VarLocInfo VarLoc : Vec) {
       }
 
       // All source assignments to this variable remain and all stores to any
       // part of the variable store to the same address (with varying
       // offsets). We can just emit a single location for the whole variable.
       //
       // Unless we've already done so, create the single location def now.
       if (AlwaysStackHomed.insert(Aggr).second) {
-        assert(isa<AllocaInst>(VarLoc.V));
+        assert(!VarLoc.Values.hasArgList() &&
+               isa<AllocaInst>(VarLoc.Values.getVariableLocationOp(0)));
         // TODO: When more complex cases are handled VarLoc.Expr should be
         // built appropriately rather than always using an empty DIExpression.
         // The assert below is a reminder.
         assert(Simple);
         VarLoc.Expr = DIExpression::get(Fn.getContext(), std::nullopt);
         DebugVariable Var = FnVarLocs->getVariable(VarLoc.VariableID);
-        FnVarLocs->addSingleLocVar(Var, VarLoc.Expr, VarLoc.DL, VarLoc.V);
+        FnVarLocs->addSingleLocVar(Var, VarLoc.Expr, VarLoc.DL, VarLoc.Values);
         InsertedAnyIntrinsics = true;
       }
     }
   }
 
   // Insert the other DEFs.
   for (const auto &[InsertBefore, Vec] : InsertBeforeMap) {
     SmallVector<VarLocInfo> NewDefs;
for (auto &I : BB) {
       auto *DVI = dyn_cast<DbgValueInst>(&I);
       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 * {
+      auto GetValue = [DVI]() -> RawLocationWrapper {
         // We can't handle variadic DIExpressions yet so treat those as
         // kill locations.
+        Value *V;
         if (DVI->isKillLocation() || DVI->getValue() == nullptr ||
             DVI->hasArgList())
-          return PoisonValue::get(Type::getInt32Ty(DVI->getContext()));
-        return DVI->getValue();
+          V = PoisonValue::get(Type::getInt32Ty(DVI->getContext()));
+        else
+          V = DVI->getVariableLocationOp(0);
+        return RawLocationWrapper(ValueAsMetadata::get(V));
       };
       Instruction *InsertBefore = I.getNextNode();
       assert(InsertBefore && "Unexpected: debug intrinsics after a terminator");
       FnVarLocs->addVarLoc(InsertBefore, DebugVariable(DVI),
                            DVI->getExpression(), DVI->getDebugLoc(),
                            GetValue());
       InsertedAnyIntrinsics = true;
     }

 ///
 /// This implements removeRedundantDbgInstrsUsingForwardScan from
 /// lib/Transforms/Utils/BasicBlockUtils.cpp for locations described with
 /// FunctionVarLocsBuilder instead of with intrinsics
 static bool
 removeRedundantDbgLocsUsingForwardScan(const BasicBlock *BB,
                                        FunctionVarLocsBuilder &FnVarLocs) {
   bool Changed = false;
-  DenseMap<DebugVariable, std::pair<Value *, DIExpression *>> VariableMap;
+  DenseMap<DebugVariable, std::pair<RawLocationWrapper, DIExpression *>>
+      VariableMap;
 
   // Scan over the entire block, not just over the instructions mapped by
   // FnVarLocs, because wedges in FnVarLocs may only be seperated by debug
   // instructions.
   for (const Instruction &I : *BB) {
     // Get the defs that come just before this instruction.
     const auto *Locs = FnVarLocs.getWedge(&I);
     if (!Locs)
       continue;
 
     NumWedgesScanned++;
     bool ChangedThisWedge = false;
     // The new pruned set of defs.
     SmallVector<VarLocInfo> NewDefs;
 
     // Iterate over the existing defs.
     for (const VarLocInfo &Loc : *Locs) {
       NumDefsScanned++;
       DebugVariable Key(FnVarLocs.getVariable(Loc.VariableID).getVariable(),
                         std::nullopt, Loc.DL.getInlinedAt());
       auto VMI = VariableMap.find(Key);
 
       // Update the map if we found a new value/expression describing the
       // variable, or if the variable wasn't mapped already.
-      if (VMI == VariableMap.end() || VMI->second.first != Loc.V ||
+      if (VMI == VariableMap.end() || VMI->second.first != Loc.Values ||
           VMI->second.second != Loc.Expr) {
-        VariableMap[Key] = {Loc.V, Loc.Expr};
+        VariableMap[Key] = {Loc.Values, Loc.Expr};
         NewDefs.push_back(Loc);
         continue;
       }
 
       // Did not insert this Loc, which is the same as removing it.
       ChangedThisWedge = true;
       NumDefsRemoved++;
     }
for (const Instruction &I : *BB) {
     for (const VarLocInfo &Loc : *Locs) {
       NumDefsScanned++;
       DebugAggregate Aggr{FnVarLocs.getVariable(Loc.VariableID).getVariable(),
                           Loc.DL.getInlinedAt()};
       DebugVariable Var = FnVarLocs.getVariable(Loc.VariableID);
 
       // Remove undef entries that are encountered before any non-undef
       // intrinsics from the entry block.
-      if (isa<UndefValue>(Loc.V) && !HasDefinedBits(Aggr, Var)) {
+      if (Loc.Values.isKillLocation(Loc.Expr) && !HasDefinedBits(Aggr, Var)) {
         // Did not insert this Loc, which is the same as removing it.
         NumDefsRemoved++;
         ChangedThisWedge = true;
         continue;
       }
 
       DefineBits(Aggr, Var);
       NewDefs.push_back(Loc);

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.h

public:
     DIExpression *getExpression() const {
       if (Info.is<VarLocTy>())
         return Info.get<VarLocTy>()->Expr;
       return Info.get<DbgValTy>()->getExpression();
     }
     Value *getVariableLocationOp(unsigned Idx) const {
       assert(Idx == 0 && "Dangling variadic debug values not supported yet");
       if (Info.is<VarLocTy>())
-        return Info.get<VarLocTy>()->V;
+        return Info.get<VarLocTy>()->Values.getVariableLocationOp(Idx);
       return Info.get<DbgValTy>()->getVariableLocationOp(Idx);
     }
     DebugLoc getDebugLoc() const {
       if (Info.is<VarLocTy>())
         return Info.get<VarLocTy>()->DL;
       return Info.get<DbgValTy>()->getDebugLoc();
     }
     unsigned getSDNodeOrder() const { return SDNodeOrder; }

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

void SelectionDAGBuilder::visit(const Instruction &I) {
   // SDNodeOrder, as this mapping is {Inst -> Locs BEFORE Inst}.
   if (FunctionVarLocs const *FnVarLocs = DAG.getFunctionVarLocs()) {
     // Add SDDbgValue nodes for any var locs here. Do so before updating
     // SDNodeOrder, as this mapping is {Inst -> Locs BEFORE Inst}.
     for (auto It = FnVarLocs->locs_begin(&I), End = FnVarLocs->locs_end(&I);
          It != End; ++It) {
       auto *Var = FnVarLocs->getDILocalVariable(It->VariableID);
       dropDanglingDebugInfo(Var, It->Expr);
-      if (!handleDebugValue(It->V, Var, It->Expr, It->DL, SDNodeOrder,
-                            /*IsVariadic=*/false))
+      SmallVector<Value *> Values(It->Values.location_ops());
+      if (!handleDebugValue(Values, Var, It->Expr, It->DL, SDNodeOrder,
+                            It->Values.hasArgList()))
         addDanglingDebugInfo(It, SDNodeOrder);
     }
   }
 
   // Increase the SDNodeOrder if dealing with a non-debug instruction.
   if (!isa<DbgInfoIntrinsic>(I))
     ++SDNodeOrder;
 
void SelectionDAGBuilder::visit(unsigned Opcode, const User &I) {
   default: llvm_unreachable("Unknown instruction type encountered!");
     // Build the switch statement using the Instruction.def file.
 #define HANDLE_INST(NUM, OPCODE, CLASS) \
     case Instruction::OPCODE: visit##OPCODE((const CLASS&)I); break;
 #include "llvm/IR/Instruction.def"
   }
 }
 
+static bool handleDanglingVariadicDebugInfo(SelectionDAG &DAG,
+                                            DILocalVariable *Variable,
+                                            DebugLoc DL, unsigned Order,
+                                            RawLocationWrapper Values,
+                                            DIExpression *Expression) {
+  if (!Values.hasArgList())
+    return false;
+  // For variadic dbg_values we will now insert an undef.
+  // FIXME: We can potentially recover these!
+  SmallVector<SDDbgOperand, 2> Locs;
+  for (const Value *V : Values.location_ops()) {
+    auto *Undef = UndefValue::get(V->getType());
+    Locs.push_back(SDDbgOperand::fromConst(Undef));
+  }
+  SDDbgValue *SDV = DAG.getDbgValueList(Variable, Expression, Locs, {},
+                                        /*IsIndirect=*/false, DL, Order,
+                                        /*IsVariadic=*/true);
+  DAG.AddDbgValue(SDV, /*isParameter=*/false);
+  return true;
+}
+
 void SelectionDAGBuilder::addDanglingDebugInfo(const VarLocInfo *VarLoc,
                                                unsigned Order) {
-  DanglingDebugInfoMap[VarLoc->V].emplace_back(VarLoc, Order);
+  if (!handleDanglingVariadicDebugInfo(
+          DAG,
+          const_cast<DILocalVariable *>(DAG.getFunctionVarLocs()
+                                            ->getVariable(VarLoc->VariableID)
+                                            .getVariable()),
+          VarLoc->DL, Order, VarLoc->Values, VarLoc->Expr)) {
+    DanglingDebugInfoMap[VarLoc->Values.getVariableLocationOp(0)].emplace_back(
+        VarLoc, Order);
+  }
 }
 
 void SelectionDAGBuilder::addDanglingDebugInfo(const DbgValueInst *DI,
                                                unsigned Order) {
   // We treat variadic dbg_values differently at this stage.
-  if (DI->hasArgList()) {
-    // For variadic dbg_values we will now insert an undef.
-    // FIXME: We can potentially recover these!
-    SmallVector<SDDbgOperand, 2> Locs;
-    for (const Value *V : DI->getValues()) {
-      auto Undef = UndefValue::get(V->getType());
-      Locs.push_back(SDDbgOperand::fromConst(Undef));
-    }
-    SDDbgValue *SDV = DAG.getDbgValueList(
-        DI->getVariable(), DI->getExpression(), Locs, {},
-        /*IsIndirect=*/false, DI->getDebugLoc(), Order, /*IsVariadic=*/true);
-    DAG.AddDbgValue(SDV, /*isParameter=*/false);
-  } else {
+  if (!handleDanglingVariadicDebugInfo(
+          DAG, DI->getVariable(), DI->getDebugLoc(), Order,
+          DI->getWrappedLocation(), DI->getExpression())) {
     // 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.
     assert(DI->getNumVariableLocationOps() == 1 &&
            "DbgValueInst without an ArgList should have a single location "
            "operand.");
     DanglingDebugInfoMap[DI->getValue(0)].emplace_back(DI, Order);

llvm/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp

 
 /// Collect single location variable information generated with assignment
 /// tracking. This is done after argument lowering in case the declarations
 /// refer to arguments.
 static void processSingleLocVars(FunctionLoweringInfo &FuncInfo,
                                  FunctionVarLocs const *FnVarLocs) {
   for (auto It = FnVarLocs->single_locs_begin(),
             End = FnVarLocs->single_locs_end();
-       It != End; ++It)
-    processDbgDeclare(FuncInfo, It->V, It->Expr,
+       It != End; ++It) {
+    assert(!It->Values.hasArgList() && "Single loc variadic ops not supported");
+    processDbgDeclare(FuncInfo, It->Values.getVariableLocationOp(0), It->Expr,
                       FnVarLocs->getDILocalVariable(It->VariableID), It->DL);
   }
+}
 
 void SelectionDAGISel::SelectAllBasicBlocks(const Function &Fn) {
   FastISelFailed = false;
   // Initialize the Fast-ISel state, if needed.
   FastISel *FastIS = nullptr;
   if (TM.Options.EnableFastISel) {
     LLVM_DEBUG(dbgs() << "Enabling fast-isel\n");
     FastIS = TLI->createFastISel(*FuncInfo, LibInfo);