[Assignment Tracking][NFC] Only calculate fragment overlaps for partially stack homed variables

[Orlando]

Summary

This filter is already applied to the rest of the analysis - this change simply prevents some unnecessary work.

[scott.linder]

llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp

1843–1844

I would prefer a reference type, assuming there is no possibility that it is nullptr.

[jmorse]

/me squints -- so if no part of the variable ends up on the stack, this is effectively early-exiting this portion of analysis?

llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp

1843–1844

+1,

[Orlando]

In D145515#4196999, @jmorse wrote:

/me squints -- so if no part of the variable ends up on the stack, this is effectively early-exiting this portion of analysis?

Effectively yes. We already have this filter applied to the rest of the analysis; this patch just adds it to this initialisation step too.

llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp

1843–1844

I have already changed VarsWithStackSlot (the parameter added in this patch) to a reference type - just checking, @jmorse are you asking for me to change FnVarLocs (not added in this patch) too?

[jmorse]

LGTM

llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp

1843–1844

Oh, right, this patch isn't adding that parameter. That can probably be improved some other time then.

llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp

 /// dbg.declares to \p FnVarLocs
 ///
 /// Finally, populate UntaggedStoreVars with a mapping of untagged stores to
 /// the stored-to variable fragments.
 ///
 /// These tasks are bundled together to reduce the number of times we need
 /// to iterate over the function as they can be achieved together in one pass.
 static AssignmentTrackingLowering::OverlapMap buildOverlapMapAndRecordDeclares(
-    Function &Fn, FunctionVarLocsBuilder *FnVarLocs,
+    Function &Fn, const DenseSet<DebugAggregate> &VarsWithStackSlot,
+    FunctionVarLocsBuilder *FnVarLocs,
     AssignmentTrackingLowering::UntaggedStoreAssignmentMap &UntaggedStoreVars) {
   DenseSet<DebugVariable> Seen;
   // Map of Variable: [Fragments].
   DenseMap<DebugAggregate, SmallVector<DebugVariable, 8>> FragmentMap;
   // Iterate over all instructions:
   // - dbg.declare    -> add single location variable record
   // - dbg.*          -> Add fragments to FragmentMap
   // - 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());
       } else if (auto *DII = dyn_cast<DbgVariableIntrinsic>(&I)) {
         DebugVariable DV = DebugVariable(DII);
         DebugAggregate DA = {DV.getVariable(), DV.getInlinedAt()};
+        if (!VarsWithStackSlot.contains(DA))
+          continue;
         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 (DbgAssignIntrinsic *DAI : at::getAssignmentMarkers(Info->Base)) {
           // Discard the fragment if it covers the entire variable.
           std::optional<DIExpression::FragmentInfo> FragInfo =
               [&Info, DAI]() -> std::optional<DIExpression::FragmentInfo> {
             DIExpression::FragmentInfo F;
             F.OffsetInBits = Info->OffsetInBits;
             F.SizeInBits = Info->SizeInBits;
             if (auto ExistingFrag = DAI->getExpression()->getFragmentInfo())
               F.OffsetInBits += ExistingFrag->OffsetInBits;
             if (auto Sz = DAI->getVariable()->getSizeInBits()) {
               if (F.OffsetInBits == 0 && F.SizeInBits == *Sz)
                 return std::nullopt;
             }
             return F;
           }();
 
           DebugVariable DV = DebugVariable(DAI->getVariable(), FragInfo,
                                            DAI->getDebugLoc().getInlinedAt());
           DebugAggregate DA = {DV.getVariable(), DV.getInlinedAt()};
+          if (!VarsWithStackSlot.contains(DA))
+            continue;
 
           // Cache this info for later.
           UntaggedStoreVars[&I].push_back(
               {FnVarLocs->insertVariable(DV), *Info});
 
           if (Seen.insert(DV).second)
             FragmentMap[DA].push_back(DV);
         }
bool AssignmentTrackingLowering::run(FunctionVarLocsBuilder *FnVarLocsBuilder) {
 
   // The general structure here is inspired by VarLocBasedImpl.cpp
   // (LiveDebugValues).
 
   // Build the variable fragment overlap map.
   // Note that this pass doesn't handle partial overlaps correctly (FWIW
   // neither does LiveDebugVariables) because that is difficult to do and
   // appears to be rare occurance.
-  VarContains =
-      buildOverlapMapAndRecordDeclares(Fn, FnVarLocs, UntaggedStoreVars);
+  VarContains = buildOverlapMapAndRecordDeclares(Fn, *VarsWithStackSlot,
+                                                 FnVarLocs, UntaggedStoreVars);
 
   // Prepare for traversal.
   ReversePostOrderTraversal<Function *> RPOT(&Fn);
   std::priority_queue<unsigned int, std::vector<unsigned int>,
                       std::greater<unsigned int>>
       Worklist;
   std::priority_queue<unsigned int, std::vector<unsigned int>,
                       std::greater<unsigned int>>