[NFC][SafepointIRVerifier] Add alias for set of available values

[anna]

LGTM.

lib/IR/SafepointIRVerifier.cpp

static void PrintValueSet(raw_ostream &OS, IteratorTy Begin, IteratorTy End) {
   OS << "]";
 }
 
 /// The verifier algorithm is phrased in terms of availability.  The set of
 /// values "available" at a given point in the control flow graph is the set of
 /// correctly relocated value at that point, and is a subset of the set of
 /// definitions dominating that point.
 
+using AvailableValueSet = DenseSet<const Value *>;
+
 /// State we compute and track per basic block.
 struct BasicBlockState {
   // Set of values available coming in, before the phi nodes
-  DenseSet<const Value *> AvailableIn;
+  AvailableValueSet AvailableIn;
 
   // Set of values available going out
-  DenseSet<const Value *> AvailableOut;
+  AvailableValueSet AvailableOut;
 
   // AvailableOut minus AvailableIn.
   // All elements are Instructions
-  DenseSet<const Value *> Contribution;
+  AvailableValueSet Contribution;
 
   // True if this block contains a safepoint and thus AvailableIn does not
   // contribute to AvailableOut.
   bool Cleared = false;
 };
 
 
 /// Gather all the definitions dominating the start of BB into Result.  This is
 /// simply the Defs introduced by every dominating basic block and the function
 /// arguments.
 static void GatherDominatingDefs(const BasicBlock *BB,
-                                 DenseSet<const Value *> &Result,
+                                 AvailableValueSet &Result,
                                  const DominatorTree &DT,
                     DenseMap<const BasicBlock *, BasicBlockState *> &BlockMap) {
   DomTreeNode *DTN = DT[const_cast<BasicBlock *>(BB)];
 
   while (DTN->getIDom()) {
     DTN = DTN->getIDom();
     const auto &Defs = BlockMap[DTN->getBlock()]->Contribution;
     Result.insert(Defs.begin(), Defs.end());
     // If this block is 'Cleared', then nothing LiveIn to this block can be
     // available after this block completes.  Note: This turns out to be
     // really important for reducing memory consuption of the initial available
     // sets and thus peak memory usage by this verifier.
     if (BlockMap[DTN->getBlock()]->Cleared)
       return;
   }
 
   for (const Argument &A : BB->getParent()->args())
     if (containsGCPtrType(A.getType()))
       Result.insert(&A);
 }
 
 /// Model the effect of an instruction on the set of available values.
 static void TransferInstruction(const Instruction &I, bool &Cleared,
-                              DenseSet<const Value *> &Available) {
+                                AvailableValueSet &Available) {
   if (isStatepoint(I)) {
     Cleared = true;
     Available.clear();
   } else if (containsGCPtrType(I.getType()))
     Available.insert(&I);
 }
 
 /// Compute the AvailableOut set for BB, based on the BasicBlockState BBS,
 /// which is the BasicBlockState for BB.
 /// ContributionChanged is set when the verifier runs for the first time
 /// (in this case Contribution was changed from 'empty' to its initial state) or
 /// when Contribution of this BB was changed since last computation.
 static void TransferBlock(const BasicBlock *BB, BasicBlockState &BBS,
                           bool ContributionChanged) {
 
-  const DenseSet<const Value *> &AvailableIn = BBS.AvailableIn;
-  DenseSet<const Value *> &AvailableOut  = BBS.AvailableOut;
+  const AvailableValueSet &AvailableIn = BBS.AvailableIn;
+  AvailableValueSet &AvailableOut  = BBS.AvailableOut;
 
   if (BBS.Cleared) {
     // AvailableOut will change only when Contribution changed.
     if (ContributionChanged)
       AvailableOut = BBS.Contribution;
   } else {
     // Otherwise, we need to reduce the AvailableOut set by things which are no
     // longer in our AvailableIn
-    DenseSet<const Value *> Temp = BBS.Contribution;
+    AvailableValueSet Temp = BBS.Contribution;
     set_union(Temp, AvailableIn);
     AvailableOut = std::move(Temp);
   }
 
   DEBUG(dbgs() << "Transfered block " << BB->getName() << " from ";
         PrintValueSet(dbgs(), AvailableIn.begin(), AvailableIn.end());
         dbgs() << " to ";
         PrintValueSet(dbgs(), AvailableOut.begin(), AvailableOut.end());

 /// This function iterates over all BBs from BlockMap and recalculates
 /// AvailableIn/Out for each of them until it converges.
 /// It calls Visitor for each visited BB after updating it's AvailableIn.
 /// BBContributionUpdater may change BB's Contribution and should return true in
 /// this case.
 ///
 /// BBContributionUpdater is expected to have following signature:
 /// (const BasicBlock *BB, const BasicBlockState *BBS,
-///  DenseSet<const Value *> &Contribution) -> bool
+///  AvailableValueSet &Contribution) -> bool
 /// FIXME: type of BBContributionUpdater is a template parameter because it
 /// might be a lambda with arbitrary non-empty capture list. It's a bit ugly and
 /// unclear, but other options causes us to spread the logic of
 /// RecalculateBBStates across the rest of the algorithm. The solution is to
 /// move this function, TransferBlock, TransferInstruction and others to a
 /// separate class which will hold all the logic related to BlockStateMap.
 template <typename VisitorTy>
 static void RecalculateBBsStates(BlockStateMap &BlockMap,
static void Verify(const Function &F, const DominatorTree &DT) {
 
   for (auto &BBI : BlockMap) {
     GatherDominatingDefs(BBI.first, BBI.second->AvailableIn, DT, BlockMap);
     TransferBlock(BBI.first, *BBI.second, true);
   }
 
   RecalculateBBsStates(BlockMap, [] (const BasicBlock *,
                                      const BasicBlockState *,
-                                     DenseSet<const Value *> &) {
+                                     AvailableValueSet &) {
     return false;
   });
 
   // We now have all the information we need to decide if the use of a heap
   // reference is legal or not, given our safepoint semantics.
 
   bool AnyInvalidUses = false;
 
static void Verify(const Function &F, const DominatorTree &DT) {
 
   // This set contains defs that can be safely ignored during verification.
   DenseSet<const Instruction *> ValidUnrelocatedDefs;
 
   // Now we can remove all valid unrelocated gc pointer defs from all BBS sets.
   RecalculateBBsStates(BlockMap, [&ValidUnrelocatedDefs](
                                      const BasicBlock *BB,
                                      const BasicBlockState *BBS,
-                                     DenseSet<const Value *> &Contribution) {
-    DenseSet<const Value *> AvailableSet = BBS->AvailableIn;
+                                     AvailableValueSet &Contribution) {
+    AvailableValueSet AvailableSet = BBS->AvailableIn;
     bool ContributionChanged = false;
     for (const Instruction &I : *BB) {
       bool ProducesUnrelocatedPointer = false;
       if ((isa<GetElementPtrInst>(I) || isa<BitCastInst>(I)) &&
           containsGCPtrType(I.getType())) {
         // GEP/bitcast of unrelocated pointer is legal by itself but this
         // def shouldn't appear in any AvailableSet.
         for (const Value *V : I.operands())
static void Verify(const Function &F, const DominatorTree &DT) {
 
   // We need RPO here to a) report always the first error b) report errors in
   // same order from run to run.
   ReversePostOrderTraversal<const Function *> RPOT(&F);
   for (const BasicBlock *BB : RPOT) {
     BasicBlockState *BBS = BlockMap[BB];
     // We destructively modify AvailableIn as we traverse the block instruction
     // by instruction.
-    DenseSet<const Value *> &AvailableSet = BBS->AvailableIn;
+    AvailableValueSet &AvailableSet = BBS->AvailableIn;
     for (const Instruction &I : *BB) {
       if (ValidUnrelocatedDefs.count(&I)) {
         continue; // This instruction shouldn't be added to AvailableSet.
       } else if (const PHINode *PN = dyn_cast<PHINode>(&I)) {
         if (containsGCPtrType(PN->getType()))
           for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) {
             const BasicBlock *InBB = PN->getIncomingBlock(i);
             const Value *InValue = PN->getIncomingValue(i);