[DebugInfo][InstrRef] Avoid un-necessary densemap copies and comparisons

[jmorse]

Summary

This is a plain and simple performance patch: InstrRefBasedLDV passes uses three distinct DenseMaps when calculating what variable values are in a block: two "long term" dense maps, and one "working" dense map. The live-ins are:

• Placed into the working set, as vlocJoin works out what each variables value should be,
• Copied into the "long term" live-in storage back in buildVLocValueMap,
• The working set has its values updated by the blocks transfer function,
• The working set is copied into the blocks live-out DenseMap.

This works well enough, but it involves two dense map comparisons and two dense map assignments, when each of the live-in / live-out dense maps are updated. For scopes with a small number of variables, this can take a large amount of time, seeing how (I think?) the initial DenseMap allocation is 64 elements. We could pay with SmallDenseMaps, however instead, lets just reduce the total number of densemaps. We can update live-ins and live-outs in-place, as appropriate, avoiding the comparisons and copies.

Practically, this means passing fewer bits of information around. Every time we make an assignment to a live-in or live-out because vlocJoin (or the transfer function) has changed it, we have to do an explicit comparison to see whether we're changing the value. Otherwise, everything works as before.

This claws back another slice of performance: http://llvm-compile-time-tracker.com/compare.php?from=bc07cf76a31fa769786d6631fe25586bd1396c34&to=231cbb7cbd13e01cf81fa97db441582af2efbbb7&stat=instructions

[Orlando]

Nice, LGTM. Might be worth adding NFC to the patch title?

llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.h

void buildVLocValueMap(const DILocation *DILoc,
                     SmallPtrSetImpl<MachineBasicBlock *> &AssignBlocks,
                     LiveInsT &Output, ValueIDNum **MOutLocs,
                     ValueIDNum **MInLocs,
                     SmallVectorImpl<VLocTracker> &AllTheVLocs);
 
   /// Attempt to eliminate un-necessary PHIs on entry to a block. Examines the
   /// live-in values coming from predecessors live-outs, and replaces any PHIs
   /// already present in this blocks live-ins with a live-through value if the
-  /// PHI isn't needed. Live out and live in variable values are stored in
-  /// \p VLOCOutLocs and \p VLOCInLocs. The live-ins for \p MBB are computed and
-  /// stored into \p VLOCInLocs.
-  /// \p InLocsT Output argument, where calculated live-in values are also
-  ///          stored.
+  /// PHI isn't needed. Live out variable values are stored in
+  /// \p VLOCOutLocs. The live-ins for \p MBB are stored in \p LiveIns, which
+  /// is also an output argument.
   /// \returns true if any live-ins change value, either from value propagation
   ///          or PHI elimination.
   bool vlocJoin(MachineBasicBlock &MBB, LiveIdxT &VLOCOutLocs,
-                LiveIdxT &VLOCInLocs,
                 const SmallSet<DebugVariable, 4> &AllVars,
                 SmallPtrSet<const MachineBasicBlock *, 8> &InScopeBlocks,
                 SmallPtrSet<const MachineBasicBlock *, 8> &BlocksToExplore,
-                DenseMap<DebugVariable, DbgValue> &InLocsT);
+                DenseMap<DebugVariable, DbgValue> &LiveIns);
 
   /// For the given block and live-outs feeding into it, try to find a
   /// machine location where all the variable values join together.
   /// \returns Value ID of a machine PHI if an appropriate one is available.
   Optional<ValueIDNum>
   pickVPHILoc(const MachineBasicBlock &MBB, const DebugVariable &Var,
               const LiveIdxT &LiveOuts, ValueIDNum **MOutLocs,
               const SmallVectorImpl<const MachineBasicBlock *> &BlockOrders);

llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp

Optional<ValueIDNum> InstrRefBasedLDV::pickVPHILoc(
   LocIdx L = *CandidateLocs.begin();
 
   // Return a PHI-value-number for the found location.
   ValueIDNum PHIVal = {(unsigned)MBB.getNumber(), 0, L};
   return PHIVal;
 }
 
 bool InstrRefBasedLDV::vlocJoin(
-    MachineBasicBlock &MBB, LiveIdxT &VLOCOutLocs, LiveIdxT &VLOCInLocs,
+    MachineBasicBlock &MBB, LiveIdxT &VLOCOutLocs,
     const SmallSet<DebugVariable, 4> &AllVars,
     SmallPtrSet<const MachineBasicBlock *, 8> &InScopeBlocks,
     SmallPtrSet<const MachineBasicBlock *, 8> &BlocksToExplore,
-    DenseMap<DebugVariable, DbgValue> &InLocsT) {
+    DenseMap<DebugVariable, DbgValue> &LiveIns) {
   // To emulate VarLocBasedImpl, process this block if it's not in scope but
   // _does_ assign a variable value. No live-ins for this scope are transferred
   // in though, so we can return immediately.
   if (InScopeBlocks.count(&MBB) == 0 && !ArtificialBlocks.count(&MBB))
     return false;
 
   LLVM_DEBUG(dbgs() << "join MBB: " << MBB.getNumber() << "\n");
   bool Changed = false;
 
-  // Pick out the live-ins from prior iterations.
-  auto ILSIt = VLOCInLocs.find(&MBB);
-  assert(ILSIt != VLOCInLocs.end());
-  auto &ILS = *ILSIt->second;
-
   // Order predecessors by RPOT order, for exploring them in that order.
   SmallVector<MachineBasicBlock *, 8> BlockOrders(MBB.predecessors());
 
   auto Cmp = [&](MachineBasicBlock *A, MachineBasicBlock *B) {
     return BBToOrder[A] < BBToOrder[B];
   };
 
   llvm::sort(BlockOrders, Cmp);
 
   unsigned CurBlockRPONum = BBToOrder[&MBB];
 
   // We re-construct the live-in map each time we join. For each variable, call
   // one of these "confirm" utilities, according to which flavour of variable
   // value it is.
-  auto ConfirmValue = [&InLocsT](const DebugVariable &DV, DbgValue VR) {
-    auto Result = InLocsT.insert(std::make_pair(DV, VR));
-    (void)Result;
-    assert(Result.second);
+  auto ConfirmValue = [&LiveIns, &Changed](const DebugVariable &DV,
+                                           const DbgValue &VR) {
+    auto OldLiveIn = LiveIns.find(DV);
+    assert(OldLiveIn != LiveIns.end());
+    if (OldLiveIn->second != VR) {
+      Changed = true;
+      OldLiveIn->second = VR;
+    }
   };
 
   auto ConfirmVPHI = [&ConfirmValue,
                       &MBB](const DebugVariable &Var,
                             const DbgValueProperties &Properties) {
     DbgValue NoLocPHIVal(MBB.getNumber(), Properties, DbgValue::VPHI);
     ConfirmValue(Var, NoLocPHIVal);
   };
for (auto p : BlockOrders) {
       unsigned ThisBBRPONum = BBToOrder[p];
       if (ThisBBRPONum < CurBlockRPONum)
         ++BackEdgesStart;
 
       Values.push_back(std::make_pair(p, &VIt->second));
     }
 
     // Pick out the live-in value from last time we vlocJoin'd this block.
-    auto LiveInIt = ILS.find(Var);
-    assert(LiveInIt != ILS.end() && "Uninitialized live-in vloc?");
+    auto LiveInIt = LiveIns.find(Var);
+    assert(LiveInIt != LiveIns.end() && "Uninitialized live-in vloc?");
     const DbgValue &OldLiveInDbgValue = LiveInIt->second;
 
     // If there were no values, or one of the predecessors couldn't have a
     // value, then give up immediately. It's not safe to produce a live-in
     // value. Leave as whatever it was before.
     if (Bail || Values.size() == 0) {
       ConfirmValue(Var, OldLiveInDbgValue);
       continue;
for (auto &Var : AllVars) {
     if (!Disagree) {
       ConfirmValue(Var, FirstVal);
     } else {
       // Otherwise use a VPHI.
       ConfirmVPHI(Var, FirstVal.Properties);
     }
   }
 
-  // Store newly calculated in-locs into VLOCInLocs, if they've changed.
-  Changed = ILS != InLocsT;
-  if (Changed)
-    ILS = InLocsT;
-
   return Changed;
 }
 
 void InstrRefBasedLDV::buildVLocValueMap(const DILocation *DILoc,
     const SmallSet<DebugVariable, 4> &VarsWeCareAbout,
     SmallPtrSetImpl<MachineBasicBlock *> &AssignBlocks, LiveInsT &Output,
     ValueIDNum **MOutLocs, ValueIDNum **MInLocs,
     SmallVectorImpl<VLocTracker> &AllTheVLocs) {
void InstrRefBasedLDV::buildVLocValueMap(const DILocation *DILoc,
   LiveIdxT LiveOutIdx, LiveInIdx;
   LiveOutIdx.reserve(NumBlocks);
   LiveInIdx.reserve(NumBlocks);
   for (unsigned I = 0; I < NumBlocks; ++I) {
     LiveOutIdx[BlockOrders[I]] = &LiveOuts[I];
     LiveInIdx[BlockOrders[I]] = &LiveIns[I];
   }
 
+  // Initialize all live-outs to "nothing", to avoid later conditionals.
+  for (auto &LiveOut : LiveOutIdx) {
+    const MachineBasicBlock *OutBB = LiveOut.first;
+    auto *LiveOutMap = LiveOut.second;
+    DbgValue EmptyDbgValue(OutBB->getNumber(), EmptyProperties,
+                           DbgValue::NoVal);
+    for (const DebugVariable &Var : VarsWeCareAbout)
+
+      LiveOutMap->insert(std::make_pair(Var, EmptyDbgValue));
+  }
+
   // Convert a const set to a non-const set. LexicalScopes
   // getMachineBasicBlocks returns const MBB pointers, IDF wants mutable ones.
   // (Neither of them mutate anything).
   SmallPtrSet<MachineBasicBlock *, 8> MutBlocksToExplore;
   for (const auto *MBB : BlocksToExplore)
     MutBlocksToExplore.insert(const_cast<MachineBasicBlock*>(MBB));
 
   // Place PHIs for variable values, using the LLVM IDF calculator.
void InstrRefBasedLDV::buildVLocValueMap(const DILocation *DILoc,
   // live-ins change thereafter.
   bool FirstTrip = true;
   while (!Worklist.empty() || !Pending.empty()) {
     while (!Worklist.empty()) {
       auto *MBB = OrderToBB[Worklist.top()];
       CurBB = MBB->getNumber();
       Worklist.pop();
 
-      DenseMap<DebugVariable, DbgValue> JoinedInLocs;
+      auto BlockLiveInsIt = LiveInIdx.find(MBB);
+      assert(BlockLiveInsIt != LiveInIdx.end());
+      auto &BlockLiveIns = *BlockLiveInsIt->second;
 
       // Join values from predecessors. Updates LiveInIdx, and writes output
       // into JoinedInLocs.
-      bool InLocsChanged;
-      InLocsChanged = vlocJoin(*MBB, LiveOutIdx, LiveInIdx,
-                               VarsWeCareAbout, InScopeBlocks, BlocksToExplore,
-                               JoinedInLocs);
+      bool InLocsChanged =
+          vlocJoin(*MBB, LiveOutIdx, VarsWeCareAbout, InScopeBlocks,
+                   BlocksToExplore, BlockLiveIns);
 
       SmallVector<const MachineBasicBlock *, 8> Preds;
       for (const auto *Pred : MBB->predecessors())
         Preds.push_back(Pred);
 
       // Opportunistically pick a machine-value for any VPHIs starting in this
       // block. This makes their machine-value available and propagated through
       // all blocks by the time value propagation finishes. We can't do this any
       // earlier as it needs to read the block live-outs.
       for (auto &Var : VarsWeCareAbout) {
-        DbgValue &Val = JoinedInLocs.find(Var)->second;
+        DbgValue &Val = BlockLiveIns.find(Var)->second;
         if (Val.Kind != DbgValue::VPHI || Val.BlockNo != (int)CurBB)
           continue;
 
         // There's a small possibility that on a preceeding path, a VPHI is
         // eliminated and transitions from VPHI-with-location to
         // live-through-value. As a result, the selected location of any VPHI
         // might change, so we need to re-compute it on each iteration.
         Optional<ValueIDNum> ValueNum = pickVPHILoc(
                   *MBB, Var, LiveOutIdx, MOutLocs, Preds);
 
         if (ValueNum) {
           InLocsChanged |= Val.ID != *ValueNum;
           Val.ID = *ValueNum;
-          // FIXME: it's stupid to have two different live-in maps at this
-          // stage, one for evaluating the transfer func in, one for storage.
-          // Fix this in the future.
-          LiveInIdx[MBB]->find(Var)->second.ID = *ValueNum;
         }
       }
 
       if (!InLocsChanged && !FirstTrip)
         continue;
 
+      auto &LiveOuts = *LiveOutIdx[MBB];
+      bool OLChanged = false;
+
       // Do transfer function.
       auto &VTracker = AllTheVLocs[MBB->getNumber()];
+      SmallSet<DebugVariable, 8> VarsTransferred;
       for (auto &Transfer : VTracker.Vars) {
         // Is this var we're mangling in this scope?
         if (VarsWeCareAbout.count(Transfer.first)) {
+          VarsTransferred.insert(Transfer.first);
+          auto OutIt = LiveOuts.find(Transfer.first);
+          assert(OutIt != LiveOuts.end());
+
           // Erase on empty transfer (DBG_VALUE $noreg).
           if (Transfer.second.Kind == DbgValue::Undef) {
-            auto InLocIt = JoinedInLocs.find(Transfer.first);
-            assert(InLocIt != JoinedInLocs.end());
-            InLocIt->second.Kind = DbgValue::NoVal;
+            DbgValue NewVal(MBB->getNumber(), EmptyProperties, DbgValue::NoVal);
+            if (OutIt->second != NewVal) {
+              OutIt->second = NewVal;
+              OLChanged = true;
+            }
           } else {
             // Insert new variable value; or overwrite.
-            auto NewValuePair = std::make_pair(Transfer.first, Transfer.second);
-            auto Result = JoinedInLocs.insert(NewValuePair);
-            if (!Result.second)
-              Result.first->second = Transfer.second;
+            if (OutIt->second != Transfer.second) {
+              OutIt->second = Transfer.second;
+              OLChanged = true;
             }
           }
         }
+      }
+
+      // For anything not assigned by the transfer function, copy live-in to
+      // live-outs.
+      for (const DebugVariable &Var : VarsWeCareAbout) {
+        if (VarsTransferred.count(Var))
+          continue;
 
-      // Did the live-out locations change?
-      bool OLChanged = JoinedInLocs != *LiveOutIdx[MBB];
+        auto OutIt = LiveOuts.find(Var);
+        auto InIt = BlockLiveIns.find(Var);
+        if (InIt->second != OutIt->second) {
+          OutIt->second = InIt->second;
+          OLChanged = true;
+        }
+      }
 
-      // If they haven't changed, there's no need to explore further.
+      // If no live-out value changed, there's no need to explore further.
       if (!OLChanged)
         continue;
 
-      // Commit to the live-out record.
-      *LiveOutIdx[MBB] = JoinedInLocs;
-
       // We should visit all successors. Ensure we'll visit any non-backedge
       // successors during this dataflow iteration; book backedge successors
       // to be visited next time around.
       for (auto s : MBB->successors()) {
         // Ignore out of scope / not-to-be-explored successors.
         if (LiveInIdx.find(s) == LiveInIdx.end())
           continue;
 

llvm/unittests/CodeGen/InstrRefLDVTest.cpp

public:
   Optional<ValueIDNum>
   pickVPHILoc(const MachineBasicBlock &MBB, const DebugVariable &Var,
               const InstrRefBasedLDV::LiveIdxT &LiveOuts, ValueIDNum **MOutLocs,
               const SmallVectorImpl<const MachineBasicBlock *> &BlockOrders) {
     return LDV->pickVPHILoc(MBB, Var, LiveOuts, MOutLocs, BlockOrders);
   }
 
   bool vlocJoin(MachineBasicBlock &MBB, InstrRefBasedLDV::LiveIdxT &VLOCOutLocs,
-                InstrRefBasedLDV::LiveIdxT &VLOCInLocs,
                 const SmallSet<DebugVariable, 4> &AllVars,
                 SmallPtrSet<const MachineBasicBlock *, 8> &InScopeBlocks,
                 SmallPtrSet<const MachineBasicBlock *, 8> &BlocksToExplore,
                 DenseMap<DebugVariable, DbgValue> &InLocsT) {
-    return LDV->vlocJoin(MBB, VLOCOutLocs, VLOCInLocs, AllVars,
-                         InScopeBlocks, BlocksToExplore, InLocsT);
+    return LDV->vlocJoin(MBB, VLOCOutLocs, AllVars, InScopeBlocks,
+                         BlocksToExplore, InLocsT);
   }
 
   void buildVLocValueMap(const DILocation *DILoc,
                     const SmallSet<DebugVariable, 4> &VarsWeCareAbout,
                     SmallPtrSetImpl<MachineBasicBlock *> &AssignBlocks,
                     InstrRefBasedLDV::LiveInsT &Output, ValueIDNum **MOutLocs,
                     ValueIDNum **MInLocs,
                     SmallVectorImpl<VLocTracker> &AllTheVLocs) {
TEST_F(InstrRefLDVTest, vlocJoinDiamond) {
 
   SmallSet<DebugVariable, 4> AllVars;
   AllVars.insert(Var);
 
   DenseMap<DebugVariable, DbgValue> JoinedLocs;
 
   // vlocJoin is here to propagate incoming values, and eliminate PHIs. Start
   // off by propagating a value into the merging block, number 3.
-  VLiveIns[3].insert({Var, DbgValue(3, EmptyProps, DbgValue::NoVal)});
+  JoinedLocs.insert({Var, DbgValue(3, EmptyProps, DbgValue::NoVal)});
   VLiveOuts[1].insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
   VLiveOuts[2].insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
-  bool Result = vlocJoin(*MBB3, VLiveOutIdx, VLiveInIdx, AllVars,
-                         AllBlocks, AllBlocks, JoinedLocs);
+  bool Result =
+      vlocJoin(*MBB3, VLiveOutIdx, AllVars, AllBlocks, AllBlocks, JoinedLocs);
   EXPECT_TRUE(Result); // Output locs should have changed.
-  auto It = VLiveIns[3].find(Var);
+  auto It = JoinedLocs.find(Var);
   EXPECT_EQ(It->second.Kind, DbgValue::Def);
   EXPECT_EQ(It->second.ID, LiveInRsp);
-  JoinedLocs.clear();
+  // JoinedLocs.clear(); <--- leave commented out for next test,
 
   // And if we did it a second time, leaving the live-ins as it was, then
   // we should report no change.
-  Result = vlocJoin(*MBB3, VLiveOutIdx, VLiveInIdx, AllVars,
-                    AllBlocks, AllBlocks, JoinedLocs);
+  Result =
+      vlocJoin(*MBB3, VLiveOutIdx, AllVars, AllBlocks, AllBlocks, JoinedLocs);
   EXPECT_FALSE(Result);
   JoinedLocs.clear();
-  VLiveIns[3].clear();
 
   // If the live-in variable values are different, but there's no PHI placed
   // in this block, then just pick a location. It should be the first (in RPO)
   // predecessor to avoid being a backedge.
   VLiveOuts[2].clear();
   VLiveOuts[2].insert({Var, DbgValue(LiveInRax, EmptyProps, DbgValue::Def)});
-  VLiveIns[3].insert({Var, DbgValue(3, EmptyProps, DbgValue::NoVal)});
-  Result = vlocJoin(*MBB3, VLiveOutIdx, VLiveInIdx, AllVars,
-                    AllBlocks, AllBlocks, JoinedLocs);
+  JoinedLocs.insert({Var, DbgValue(3, EmptyProps, DbgValue::NoVal)});
+  Result =
+      vlocJoin(*MBB3, VLiveOutIdx, AllVars, AllBlocks, AllBlocks, JoinedLocs);
   EXPECT_TRUE(Result);
-  It = VLiveIns[3].find(Var);
+  It = JoinedLocs.find(Var);
   EXPECT_EQ(It->second.Kind, DbgValue::Def);
   // RPO is blocks 0 2 1 3, so LiveInRax is picked as the first predecessor
   // of this join.
   EXPECT_EQ(It->second.ID, LiveInRax);
   JoinedLocs.clear();
-  VLiveIns[3].clear();
 
   // No tests for whether vlocJoin will pass-through a variable with differing
   // expressions / properties. Those can only come about due to assignments; and
   // for any assignment at all, a PHI should have been placed at the dominance
   // frontier. We rely on the IDF calculator being accurate (which is OK,
   // because so does the rest of LLVM).
 
   // Try placing a PHI. With differing input values (LiveInRsp, LiveInRax),
   // this PHI should not be eliminated.
-  VLiveIns[3].insert({Var, DbgValue(3, EmptyProps, DbgValue::VPHI)});
-  Result = vlocJoin(*MBB3, VLiveOutIdx, VLiveInIdx, AllVars,
-                    AllBlocks, AllBlocks, JoinedLocs);
+  JoinedLocs.insert({Var, DbgValue(3, EmptyProps, DbgValue::VPHI)});
+  Result =
+      vlocJoin(*MBB3, VLiveOutIdx, AllVars, AllBlocks, AllBlocks, JoinedLocs);
   // Expect no change.
   EXPECT_FALSE(Result);
-  It = VLiveIns[3].find(Var);
+  It = JoinedLocs.find(Var);
   EXPECT_EQ(It->second.Kind, DbgValue::VPHI);
   // This should not have been assigned a fixed value.
   EXPECT_EQ(It->second.ID, ValueIDNum::EmptyValue);
   EXPECT_EQ(It->second.BlockNo, 3);
   JoinedLocs.clear();
-  VLiveIns[3].clear();
 
   // Try a simple PHI elimination. Put a PHI in block 3, but LiveInRsp on both
   // incoming edges. Re-load in and out-locs with unrelated values; they're
   // irrelevant.
   VLiveOuts[1].clear();
   VLiveOuts[2].clear();
   VLiveOuts[1].insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
   VLiveOuts[2].insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
-  VLiveIns[3].insert({Var, DbgValue(3, EmptyProps, DbgValue::VPHI)});
-  Result = vlocJoin(*MBB3, VLiveOutIdx, VLiveInIdx, AllVars,
-                    AllBlocks, AllBlocks, JoinedLocs);
+  JoinedLocs.insert({Var, DbgValue(3, EmptyProps, DbgValue::VPHI)});
+  Result =
+      vlocJoin(*MBB3, VLiveOutIdx, AllVars, AllBlocks, AllBlocks, JoinedLocs);
   EXPECT_TRUE(Result);
-  It = VLiveIns[3].find(Var);
+  It = JoinedLocs.find(Var);
   EXPECT_EQ(It->second.Kind, DbgValue::Def);
   EXPECT_EQ(It->second.ID, LiveInRsp);
   JoinedLocs.clear();
-  VLiveIns[3].clear();
 
   // If the "current" live-in is a VPHI, but not a VPHI generated in the current
   // block, then it's the remains of an earlier value propagation. We should
   // value propagate through this merge. Even if the current incoming values
   // disagree, because we've previously determined any VPHI here is redundant.
   VLiveOuts[1].clear();
   VLiveOuts[2].clear();
   VLiveOuts[1].insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
   VLiveOuts[2].insert({Var, DbgValue(LiveInRax, EmptyProps, DbgValue::Def)});
-  VLiveIns[3].insert({Var, DbgValue(2, EmptyProps, DbgValue::VPHI)});
-  Result = vlocJoin(*MBB3, VLiveOutIdx, VLiveInIdx, AllVars,
-                    AllBlocks, AllBlocks, JoinedLocs);
+  JoinedLocs.insert({Var, DbgValue(2, EmptyProps, DbgValue::VPHI)});
+  Result =
+      vlocJoin(*MBB3, VLiveOutIdx, AllVars, AllBlocks, AllBlocks, JoinedLocs);
   EXPECT_TRUE(Result);
-  It = VLiveIns[3].find(Var);
+  It = JoinedLocs.find(Var);
   EXPECT_EQ(It->second.Kind, DbgValue::Def);
   EXPECT_EQ(It->second.ID, LiveInRax); // from block 2
   JoinedLocs.clear();
-  VLiveIns[3].clear();
 
   // The above test, but test that we will install one value-propagated VPHI
   // over another.
   VLiveOuts[1].clear();
   VLiveOuts[2].clear();
   VLiveOuts[1].insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
   VLiveOuts[2].insert({Var, DbgValue(0, EmptyProps, DbgValue::VPHI)});
-  VLiveIns[3].insert({Var, DbgValue(2, EmptyProps, DbgValue::VPHI)});
-  Result = vlocJoin(*MBB3, VLiveOutIdx, VLiveInIdx, AllVars,
-                    AllBlocks, AllBlocks, JoinedLocs);
+  JoinedLocs.insert({Var, DbgValue(2, EmptyProps, DbgValue::VPHI)});
+  Result =
+      vlocJoin(*MBB3, VLiveOutIdx, AllVars, AllBlocks, AllBlocks, JoinedLocs);
   EXPECT_TRUE(Result);
-  It = VLiveIns[3].find(Var);
+  It = JoinedLocs.find(Var);
   EXPECT_EQ(It->second.Kind, DbgValue::VPHI);
   EXPECT_EQ(It->second.BlockNo, 0);
   JoinedLocs.clear();
-  VLiveIns[3].clear();
 
   // We shouldn't eliminate PHIs when properties disagree.
   DbgValueProperties PropsWithIndirect(EmptyExpr, true);
   VLiveOuts[1].clear();
   VLiveOuts[2].clear();
   VLiveOuts[1].insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
-  VLiveOuts[2].insert({Var, DbgValue(LiveInRsp, PropsWithIndirect, DbgValue::Def)});
-  VLiveIns[3].insert({Var, DbgValue(3, EmptyProps, DbgValue::VPHI)});
-  Result = vlocJoin(*MBB3, VLiveOutIdx, VLiveInIdx, AllVars,
-                    AllBlocks, AllBlocks, JoinedLocs);
+  VLiveOuts[2].insert(
+      {Var, DbgValue(LiveInRsp, PropsWithIndirect, DbgValue::Def)});
+  JoinedLocs.insert({Var, DbgValue(3, EmptyProps, DbgValue::VPHI)});
+  Result =
+      vlocJoin(*MBB3, VLiveOutIdx, AllVars, AllBlocks, AllBlocks, JoinedLocs);
   EXPECT_FALSE(Result);
-  It = VLiveIns[3].find(Var);
+  It = JoinedLocs.find(Var);
   EXPECT_EQ(It->second.Kind, DbgValue::VPHI);
   EXPECT_EQ(It->second.BlockNo, 3);
   JoinedLocs.clear();
-  VLiveIns[3].clear();
 
   // Even if properties disagree, we should still value-propagate if there's no
   // PHI to be eliminated. The disagreeing values should work themselves out,
   // seeing how we've determined no PHI is necessary.
   VLiveOuts[1].clear();
   VLiveOuts[2].clear();
   VLiveOuts[1].insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
-  VLiveOuts[2].insert({Var, DbgValue(LiveInRsp, PropsWithIndirect, DbgValue::Def)});
-  VLiveIns[3].insert({Var, DbgValue(2, EmptyProps, DbgValue::VPHI)});
-  Result = vlocJoin(*MBB3, VLiveOutIdx, VLiveInIdx, AllVars,
-                    AllBlocks, AllBlocks, JoinedLocs);
+  VLiveOuts[2].insert(
+      {Var, DbgValue(LiveInRsp, PropsWithIndirect, DbgValue::Def)});
+  JoinedLocs.insert({Var, DbgValue(2, EmptyProps, DbgValue::VPHI)});
+  Result =
+      vlocJoin(*MBB3, VLiveOutIdx, AllVars, AllBlocks, AllBlocks, JoinedLocs);
   EXPECT_TRUE(Result);
-  It = VLiveIns[3].find(Var);
+  It = JoinedLocs.find(Var);
   EXPECT_EQ(It->second.Kind, DbgValue::Def);
   EXPECT_EQ(It->second.ID, LiveInRsp);
   // Also check properties come from block 2, the first RPO predecessor to block
   // three.
   EXPECT_EQ(It->second.Properties, PropsWithIndirect);
   JoinedLocs.clear();
   VLiveIns[3].clear();
 
   // Again, disagreeing properties, this time the expr, should cause a PHI to
   // not be eliminated.
   DIExpression *NewExpr = DIExpression::prepend(EmptyExpr, DIExpression::ApplyOffset, 4);
   DbgValueProperties PropsWithExpr(NewExpr, false);
   VLiveOuts[1].clear();
   VLiveOuts[2].clear();
   VLiveOuts[1].insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
   VLiveOuts[2].insert({Var, DbgValue(LiveInRsp, PropsWithExpr, DbgValue::Def)});
-  VLiveIns[3].insert({Var, DbgValue(3, EmptyProps, DbgValue::VPHI)});
-  Result = vlocJoin(*MBB3, VLiveOutIdx, VLiveInIdx, AllVars,
-                    AllBlocks, AllBlocks, JoinedLocs);
+  JoinedLocs.insert({Var, DbgValue(3, EmptyProps, DbgValue::VPHI)});
+  Result =
+      vlocJoin(*MBB3, VLiveOutIdx, AllVars, AllBlocks, AllBlocks, JoinedLocs);
   EXPECT_FALSE(Result);
-  It = VLiveIns[3].find(Var);
-  EXPECT_EQ(It->second.Kind, DbgValue::VPHI);
-  EXPECT_EQ(It->second.BlockNo, 3);
-  EXPECT_EQ(It->second.Properties, EmptyProps);
-  JoinedLocs.clear();
-  VLiveIns[3].clear();
 }
 
 TEST_F(InstrRefLDVTest, vlocJoinLoops) {
   setupSimpleLoop();
   //    entry
   //     |
   //     |/-----\
   //    loopblk |
   //     |\-----/
   //     |
   //     ret
   ASSERT_TRUE(MTracker->getNumLocs() == 1);
   LocIdx RspLoc(0);
   Register RAX = getRegByName("RAX");
   LocIdx RaxLoc = MTracker->lookupOrTrackRegister(RAX);
 
   unsigned EntryBlk = 0, LoopBlk = 1;
 
   ValueIDNum LiveInRsp(EntryBlk, 0, RspLoc);
   ValueIDNum LiveInRax(EntryBlk, 0, RaxLoc);
   ValueIDNum RspPHIInBlk1(LoopBlk, 0, RspLoc);
 
   DebugVariable Var(FuncVariable, None, nullptr);
   DbgValueProperties EmptyProps(EmptyExpr, false);
-  SmallVector<DenseMap<DebugVariable, DbgValue>, 32> VLiveOuts, VLiveIns;
+  SmallVector<DenseMap<DebugVariable, DbgValue>, 32> VLiveOuts;
   VLiveOuts.resize(3);
-  VLiveIns.resize(3);
-  InstrRefBasedLDV::LiveIdxT VLiveOutIdx, VLiveInIdx;
+  InstrRefBasedLDV::LiveIdxT VLiveOutIdx;
   VLiveOutIdx[MBB0] = &VLiveOuts[0];
   VLiveOutIdx[MBB1] = &VLiveOuts[1];
   VLiveOutIdx[MBB2] = &VLiveOuts[2];
-  VLiveInIdx[MBB0] = &VLiveIns[0];
-  VLiveInIdx[MBB1] = &VLiveIns[1];
-  VLiveInIdx[MBB2] = &VLiveIns[2];
 
   SmallPtrSet<const MachineBasicBlock *, 8> AllBlocks;
   AllBlocks.insert(MBB0);
   AllBlocks.insert(MBB1);
   AllBlocks.insert(MBB2);
 
   SmallVector<const MachineBasicBlock *, 2> Preds;
   for (const auto *Pred : MBB1->predecessors())
     Preds.push_back(Pred);
 
   SmallSet<DebugVariable, 4> AllVars;
   AllVars.insert(Var);
 
   DenseMap<DebugVariable, DbgValue> JoinedLocs;
 
   // Test some back-edge-specific behaviours of vloc join. Mostly: the fact that
   // VPHIs that arrive on backedges can be eliminated, despite having different
   // values to the predecessor.
 
   // First: when there's no VPHI placed already, propagate the live-in value of
   // the first RPO predecessor.
   VLiveOuts[0].insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
   VLiveOuts[1].insert({Var, DbgValue(LiveInRax, EmptyProps, DbgValue::Def)});
-  VLiveIns[1].insert({Var, DbgValue(LiveInRax, EmptyProps, DbgValue::Def)});
-  bool Result = vlocJoin(*MBB1, VLiveOutIdx, VLiveInIdx, AllVars,
-                    AllBlocks, AllBlocks, JoinedLocs);
+  JoinedLocs.insert({Var, DbgValue(LiveInRax, EmptyProps, DbgValue::Def)});
+  bool Result =
+      vlocJoin(*MBB1, VLiveOutIdx, AllVars, AllBlocks, AllBlocks, JoinedLocs);
   EXPECT_TRUE(Result);
-  auto It = VLiveIns[1].find(Var);
+  auto It = JoinedLocs.find(Var);
   EXPECT_EQ(It->second.Kind, DbgValue::Def);
   EXPECT_EQ(It->second.ID, LiveInRsp);
   JoinedLocs.clear();
-  VLiveIns[1].clear();
 
   // If there is a VPHI: don't elimiante it if there are disagreeing values.
   VLiveOuts[0].insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
   VLiveOuts[1].insert({Var, DbgValue(LiveInRax, EmptyProps, DbgValue::Def)});
-  VLiveIns[1].insert({Var, DbgValue(1, EmptyProps, DbgValue::VPHI)});
-  Result = vlocJoin(*MBB1, VLiveOutIdx, VLiveInIdx, AllVars,
-                    AllBlocks, AllBlocks, JoinedLocs);
+  JoinedLocs.insert({Var, DbgValue(1, EmptyProps, DbgValue::VPHI)});
+  Result =
+      vlocJoin(*MBB1, VLiveOutIdx, AllVars, AllBlocks, AllBlocks, JoinedLocs);
   EXPECT_FALSE(Result);
-  It = VLiveIns[1].find(Var);
+  It = JoinedLocs.find(Var);
   EXPECT_EQ(It->second.Kind, DbgValue::VPHI);
   EXPECT_EQ(It->second.BlockNo, 1);
   JoinedLocs.clear();
-  VLiveIns[1].clear();
 
   // If we feed this VPHI back into itself though, we can eliminate it.
   VLiveOuts[0].clear();
   VLiveOuts[1].clear();
   VLiveOuts[0].insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
   VLiveOuts[1].insert({Var, DbgValue(1, EmptyProps, DbgValue::VPHI)});
-  VLiveIns[1].insert({Var, DbgValue(1, EmptyProps, DbgValue::VPHI)});
-  Result = vlocJoin(*MBB1, VLiveOutIdx, VLiveInIdx, AllVars,
-                    AllBlocks, AllBlocks, JoinedLocs);
+  JoinedLocs.insert({Var, DbgValue(1, EmptyProps, DbgValue::VPHI)});
+  Result =
+      vlocJoin(*MBB1, VLiveOutIdx, AllVars, AllBlocks, AllBlocks, JoinedLocs);
   EXPECT_TRUE(Result);
-  It = VLiveIns[1].find(Var);
+  It = JoinedLocs.find(Var);
   EXPECT_EQ(It->second.Kind, DbgValue::Def);
   EXPECT_EQ(It->second.ID, LiveInRsp);
   JoinedLocs.clear();
-  VLiveIns[1].clear();
 
   // Don't eliminate backedge VPHIs if the predecessors have different
   // properties.
   DIExpression *NewExpr = DIExpression::prepend(EmptyExpr, DIExpression::ApplyOffset, 4);
   DbgValueProperties PropsWithExpr(NewExpr, false);
   VLiveOuts[1].clear();
   VLiveOuts[1].insert({Var, DbgValue(1, PropsWithExpr, DbgValue::VPHI)});
-  VLiveIns[1].insert({Var, DbgValue(1, EmptyProps, DbgValue::VPHI)});
-  Result = vlocJoin(*MBB1, VLiveOutIdx, VLiveInIdx, AllVars,
-                    AllBlocks, AllBlocks, JoinedLocs);
+  JoinedLocs.insert({Var, DbgValue(1, EmptyProps, DbgValue::VPHI)});
+  Result =
+      vlocJoin(*MBB1, VLiveOutIdx, AllVars, AllBlocks, AllBlocks, JoinedLocs);
   EXPECT_FALSE(Result);
-  It = VLiveIns[1].find(Var);
+  It = JoinedLocs.find(Var);
   EXPECT_EQ(It->second.Kind, DbgValue::VPHI);
   EXPECT_EQ(It->second.BlockNo, 1);
   JoinedLocs.clear();
-  VLiveIns[1].clear();
 
   // Backedges with VPHIs, but from the wrong block, shouldn't be eliminated.
   VLiveOuts[1].clear();
   VLiveOuts[1].insert({Var, DbgValue(0, EmptyProps, DbgValue::VPHI)});
-  VLiveIns[1].insert({Var, DbgValue(1, EmptyProps, DbgValue::VPHI)});
-  Result = vlocJoin(*MBB1, VLiveOutIdx, VLiveInIdx, AllVars,
-                    AllBlocks, AllBlocks, JoinedLocs);
+  JoinedLocs.insert({Var, DbgValue(1, EmptyProps, DbgValue::VPHI)});
+  Result =
+      vlocJoin(*MBB1, VLiveOutIdx, AllVars, AllBlocks, AllBlocks, JoinedLocs);
   EXPECT_FALSE(Result);
-  It = VLiveIns[1].find(Var);
+  It = JoinedLocs.find(Var);
   EXPECT_EQ(It->second.Kind, DbgValue::VPHI);
   EXPECT_EQ(It->second.BlockNo, 1);
   JoinedLocs.clear();
-  VLiveIns[1].clear();
 }
 
 TEST_F(InstrRefLDVTest, vlocJoinBadlyNestedLoops) {
   // Test PHI elimination in the presence of multiple backedges.
   setupBadlyNestedLoops();
   //           entry
   //             |
   //           loop1 -o
TEST_F(InstrRefLDVTest, vlocJoinBadlyNestedLoops) {
   unsigned EntryBlk = 0;
 
   ValueIDNum LiveInRsp(EntryBlk, 0, RspLoc);
   ValueIDNum LiveInRax(EntryBlk, 0, RaxLoc);
   ValueIDNum LiveInRbx(EntryBlk, 0, RbxLoc);
 
   DebugVariable Var(FuncVariable, None, nullptr);
   DbgValueProperties EmptyProps(EmptyExpr, false);
-  SmallVector<DenseMap<DebugVariable, DbgValue>, 32> VLiveOuts, VLiveIns;
+  SmallVector<DenseMap<DebugVariable, DbgValue>, 32> VLiveOuts;
   VLiveOuts.resize(5);
-  VLiveIns.resize(5);
-  InstrRefBasedLDV::LiveIdxT VLiveOutIdx, VLiveInIdx;
+  InstrRefBasedLDV::LiveIdxT VLiveOutIdx;
   VLiveOutIdx[MBB0] = &VLiveOuts[0];
   VLiveOutIdx[MBB1] = &VLiveOuts[1];
   VLiveOutIdx[MBB2] = &VLiveOuts[2];
   VLiveOutIdx[MBB3] = &VLiveOuts[3];
   VLiveOutIdx[MBB4] = &VLiveOuts[4];
-  VLiveInIdx[MBB0] = &VLiveIns[0];
-  VLiveInIdx[MBB1] = &VLiveIns[1];
-  VLiveInIdx[MBB2] = &VLiveIns[2];
-  VLiveInIdx[MBB3] = &VLiveIns[3];
-  VLiveInIdx[MBB4] = &VLiveIns[4];
 
   SmallPtrSet<const MachineBasicBlock *, 8> AllBlocks;
   AllBlocks.insert(MBB0);
   AllBlocks.insert(MBB1);
   AllBlocks.insert(MBB2);
   AllBlocks.insert(MBB3);
   AllBlocks.insert(MBB4);
 
   // We're going to focus on block 1.
   SmallVector<const MachineBasicBlock *, 3> Preds;
   for (const auto *Pred : MBB1->predecessors())
     Preds.push_back(Pred);
 
   SmallSet<DebugVariable, 4> AllVars;
   AllVars.insert(Var);
 
   DenseMap<DebugVariable, DbgValue> JoinedLocs;
 
   // Test a normal VPHI isn't eliminated.
   VLiveOuts[0].insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
   VLiveOuts[1].insert({Var, DbgValue(LiveInRax, EmptyProps, DbgValue::Def)});
   VLiveOuts[2].insert({Var, DbgValue(LiveInRbx, EmptyProps, DbgValue::Def)});
-  VLiveIns[1].insert({Var, DbgValue(1, EmptyProps, DbgValue::VPHI)});
-  bool Result = vlocJoin(*MBB1, VLiveOutIdx, VLiveInIdx, AllVars,
-                    AllBlocks, AllBlocks, JoinedLocs);
+  JoinedLocs.insert({Var, DbgValue(1, EmptyProps, DbgValue::VPHI)});
+  bool Result =
+      vlocJoin(*MBB1, VLiveOutIdx, AllVars, AllBlocks, AllBlocks, JoinedLocs);
   EXPECT_FALSE(Result);
-  auto It = VLiveIns[1].find(Var);
+  auto It = JoinedLocs.find(Var);
   EXPECT_EQ(It->second.Kind, DbgValue::VPHI);
   EXPECT_EQ(It->second.BlockNo, 1);
   JoinedLocs.clear();
-  VLiveIns[1].clear();
 
   // Common VPHIs on backedges should merge.
   VLiveOuts[0].clear();
   VLiveOuts[1].clear();
   VLiveOuts[2].clear();
   VLiveOuts[0].insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
   VLiveOuts[1].insert({Var, DbgValue(1, EmptyProps, DbgValue::VPHI)});
   VLiveOuts[2].insert({Var, DbgValue(1, EmptyProps, DbgValue::VPHI)});
-  VLiveIns[1].insert({Var, DbgValue(1, EmptyProps, DbgValue::VPHI)});
-  Result = vlocJoin(*MBB1, VLiveOutIdx, VLiveInIdx, AllVars,
-                    AllBlocks, AllBlocks, JoinedLocs);
+  JoinedLocs.insert({Var, DbgValue(1, EmptyProps, DbgValue::VPHI)});
+  Result =
+      vlocJoin(*MBB1, VLiveOutIdx, AllVars, AllBlocks, AllBlocks, JoinedLocs);
   EXPECT_TRUE(Result);
-  It = VLiveIns[1].find(Var);
+  It = JoinedLocs.find(Var);
   EXPECT_EQ(It->second.Kind, DbgValue::Def);
   EXPECT_EQ(It->second.ID, LiveInRsp);
   JoinedLocs.clear();
-  VLiveIns[1].clear();
 
   // They shouldn't merge if one of their properties is different.
   DbgValueProperties PropsWithIndirect(EmptyExpr, true);
   VLiveOuts[0].clear();
   VLiveOuts[1].clear();
   VLiveOuts[2].clear();
   VLiveOuts[0].insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
   VLiveOuts[1].insert({Var, DbgValue(1, EmptyProps, DbgValue::VPHI)});
   VLiveOuts[2].insert({Var, DbgValue(1, PropsWithIndirect, DbgValue::VPHI)});
-  VLiveIns[1].insert({Var, DbgValue(1, EmptyProps, DbgValue::VPHI)});
-  Result = vlocJoin(*MBB1, VLiveOutIdx, VLiveInIdx, AllVars,
-                    AllBlocks, AllBlocks, JoinedLocs);
+  JoinedLocs.insert({Var, DbgValue(1, EmptyProps, DbgValue::VPHI)});
+  Result =
+      vlocJoin(*MBB1, VLiveOutIdx, AllVars, AllBlocks, AllBlocks, JoinedLocs);
   EXPECT_FALSE(Result);
-  It = VLiveIns[1].find(Var);
+  It = JoinedLocs.find(Var);
   EXPECT_EQ(It->second.Kind, DbgValue::VPHI);
   EXPECT_EQ(It->second.BlockNo, 1);
   JoinedLocs.clear();
-  VLiveIns[1].clear();
 
   // VPHIs from different blocks should not merge.
   VLiveOuts[0].clear();
   VLiveOuts[1].clear();
   VLiveOuts[2].clear();
   VLiveOuts[0].insert({Var, DbgValue(LiveInRsp, EmptyProps, DbgValue::Def)});
   VLiveOuts[1].insert({Var, DbgValue(1, EmptyProps, DbgValue::VPHI)});
   VLiveOuts[2].insert({Var, DbgValue(2, EmptyProps, DbgValue::VPHI)});
-  VLiveIns[1].insert({Var, DbgValue(1, EmptyProps, DbgValue::VPHI)});
-  Result = vlocJoin(*MBB1, VLiveOutIdx, VLiveInIdx, AllVars,
-                    AllBlocks, AllBlocks, JoinedLocs);
+  JoinedLocs.insert({Var, DbgValue(1, EmptyProps, DbgValue::VPHI)});
+  Result =
+      vlocJoin(*MBB1, VLiveOutIdx, AllVars, AllBlocks, AllBlocks, JoinedLocs);
   EXPECT_FALSE(Result);
-  It = VLiveIns[1].find(Var);
+  It = JoinedLocs.find(Var);
   EXPECT_EQ(It->second.Kind, DbgValue::VPHI);
   EXPECT_EQ(It->second.BlockNo, 1);
   JoinedLocs.clear();
-  VLiveIns[1].clear();
 }
 
 // Above are tests for picking VPHI locations, and eliminating VPHIs. No
 // unit-tests are written for evaluating the transfer function as that's
 // pretty straight forwards, or applying VPHI-location-picking to live-ins.
 // Instead, pre-set some machine locations and apply buildVLocValueMap to the
 // existing CFG patterns.
 TEST_F(InstrRefLDVTest, VLocSingleBlock) {