[Assignment Tracking][NFC] Reuse BlockInfo rather than re-allocating each iteration

[Orlando]

Summary

This has a slight positive impact on the CTMark project compile times.

[Orlando]

Format and add context.

[jryans]

Seems reasonable, thanks! 😄

[scott.linder]

llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp

1758

When Join aliases A this will clear A, is that intended?

1822

What is this std::move for? Was there a version which accepted an rvalue-reference at some point?

[Orlando]

Thanks both. @scott.linder yep I definitely missed something with this one and it doesn't do what I wanted it do. I will abandon this one.

llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp

bool operator==(const BlockInfo &Other) const {
              mapsAreEqual(StackHomeValue, Other.StackHomeValue) &&
              mapsAreEqual(DebugValue, Other.DebugValue);
     }
     bool operator!=(const BlockInfo &Other) const { return !(*this == Other); }
     bool isValid() {
       return LiveLoc.size() == DebugValue.size() &&
              LiveLoc.size() == StackHomeValue.size();
     }
+    void clear() {
+      StackHomeValue.clear();
+      DebugValue.clear();
+      LiveLoc.clear();
+    }
   };
 
   Function &Fn;
   const DataLayout &Layout;
   const DenseSet<DebugAggregate> *VarsWithStackSlot;
   FunctionVarLocsBuilder *FnVarLocs;
   DenseMap<const BasicBlock *, BlockInfo> LiveIn;
   DenseMap<const BasicBlock *, BlockInfo> LiveOut;
private:
   /// dropped debug info. It is assumed the key is associated with a top value
   /// (⊤) in this case (unknown location / assignment).
   ///@{
   static LocKind joinKind(LocKind A, LocKind B);
   static LocMap joinLocMap(const LocMap &A, const LocMap &B);
   static Assignment joinAssignment(const Assignment &A, const Assignment &B);
   static AssignmentMap joinAssignmentMap(const AssignmentMap &A,
                                          const AssignmentMap &B);
-  static BlockInfo joinBlockInfo(const BlockInfo &A, const BlockInfo &B);
+  static void joinBlockInfo(BlockInfo &Result, const BlockInfo &A,
+                            const BlockInfo &B);
   ///@}
 
   /// Process the instructions in \p BB updating \p LiveSet along the way. \p
   /// LiveSet must be initialized with the current live-in locations before
   /// calling this.
   void process(BasicBlock &BB, BlockInfo *LiveSet);
   ///@name processMethods
   /// Methods to process instructions in order to update the LiveSet (current
AssignmentTrackingLowering::joinAssignmentMap(const AssignmentMap &A,
   for (auto Var : SymmetricDifference)
     Join.insert({Var, Assignment::makeNoneOrPhi()});
 
   assert(Join.size() == (IntersectSize + SymmetricDifference.size()));
   assert(Join.size() >= A.size() && Join.size() >= B.size());
   return Join;
 }
 
-AssignmentTrackingLowering::BlockInfo
-AssignmentTrackingLowering::joinBlockInfo(const BlockInfo &A,
+void AssignmentTrackingLowering::joinBlockInfo(BlockInfo &Join,
+                                               const BlockInfo &A,
                                                const BlockInfo &B) {
-  BlockInfo Join;
+  Join.clear();
   Join.LiveLoc = joinLocMap(A.LiveLoc, B.LiveLoc);
   Join.StackHomeValue = joinAssignmentMap(A.StackHomeValue, B.StackHomeValue);
   Join.DebugValue = joinAssignmentMap(A.DebugValue, B.DebugValue);
   assert(Join.isValid());
-  return Join;
 }
 
 bool AssignmentTrackingLowering::join(
     const BasicBlock &BB, const SmallPtrSet<BasicBlock *, 16> &Visited) {
 
   SmallVector<const BasicBlock *> VisitedPreds;
   // Ignore backedges if we have not visited the predecessor yet. As the
   // predecessor hasn't yet had locations propagated into it, most locations
if (VisitedPreds.size() == 1) {
     }
     return /*Changed*/ false;
   }
 
   // More than one pred. Join LiveOuts of blocks 1 and 2.
   assert(VisitedPreds.size() > 1);
   const BlockInfo &PredLiveOut0 = LiveOut.find(VisitedPreds[0])->second;
   const BlockInfo &PredLiveOut1 = LiveOut.find(VisitedPreds[1])->second;
-  BlockInfo BBLiveIn = joinBlockInfo(PredLiveOut0, PredLiveOut1);
+  BlockInfo BBLiveIn;
+  joinBlockInfo(BBLiveIn, PredLiveOut0, PredLiveOut1);
 
   ArrayRef Tail = [&]() {
     auto *It = VisitedPreds.begin();
     std::advance(It, 2);
     return ArrayRef(It, VisitedPreds.end());
   }();
 
   // Join the LiveOuts of subsequent blocks.
   for (const BasicBlock *Pred : Tail) {
     const auto &PredLiveOut = LiveOut.find(Pred);
     assert(PredLiveOut != LiveOut.end() &&
            "block should have been processed already");
-    BBLiveIn = joinBlockInfo(std::move(BBLiveIn), PredLiveOut->second);
+    joinBlockInfo(BBLiveIn, std::move(BBLiveIn), PredLiveOut->second);
   }
 
   // Save the joined result for BB.
   auto CurrentLiveInEntry = LiveIn.find(&BB);
   // Check if there isn't an entry, or there is but the LiveIn set has changed
   // (expensive check).
   if (CurrentLiveInEntry == LiveIn.end() ||
       BBLiveIn != CurrentLiveInEntry->second) {