[NFC][GVN] Fix "avaliable" typos

[lebedev.ri]

Hm, guess i missed this pattern :/

llvm/lib/Transforms/Scalar/GVN.cpp

 static cl::opt<uint32_t> MaxNumDeps(
     "gvn-max-num-deps", cl::Hidden, cl::init(100), cl::ZeroOrMore,
     cl::desc("Max number of dependences to attempt Load PRE (default = 100)"));
 
 // This is based on IsValueFullyAvailableInBlockNumSpeculationsMax stat.
 static cl::opt<uint32_t> MaxBBSpeculations(
     "gvn-max-block-speculations", cl::Hidden, cl::init(600), cl::ZeroOrMore,
     cl::desc("Max number of blocks we're willing to speculate on (and recurse "
-             "into) when deducing if a value is fully avaliable or not in GVN "
+             "into) when deducing if a value is fully available or not in GVN "
              "(default = 600)"));
 
 struct llvm::GVN::Expression {
   uint32_t opcode;
   bool commutative = false;
   Type *type = nullptr;
   SmallVector<uint32_t, 4> varargs;
 
for (DenseMap<uint32_t, Value*>::iterator I = d.begin(),
        E = d.end(); I != E; ++I) {
       errs() << I->first << "\n";
       I->second->dump();
   }
   errs() << "}\n";
 }
 #endif
 
-enum class AvaliabilityState : char {
+enum class AvailabilityState : char {
   /// We know the block *is not* fully available. This is a fixpoint.
   Unavailable = 0,
   /// We know the block *is* fully available. This is a fixpoint.
   Available = 1,
   /// We do not know whether the block is fully available or not,
   /// but we are currently speculating that it will be.
   /// If it would have turned out that the block was, in fact, not fully
   /// available, this would have been cleaned up into an Unavailable.
   SpeculativelyAvailable = 2,
 };
 
 /// Return true if we can prove that the value
 /// we're analyzing is fully available in the specified block.  As we go, keep
 /// track of which blocks we know are fully alive in FullyAvailableBlocks.  This
 /// map is actually a tri-state map with the following values:
 ///   0) we know the block *is not* fully available.
 ///   1) we know the block *is* fully available.
 ///   2) we do not know whether the block is fully available or not, but we are
 ///      currently speculating that it will be.
 static bool IsValueFullyAvailableInBlock(
     BasicBlock *BB,
-    DenseMap<BasicBlock *, AvaliabilityState> &FullyAvailableBlocks) {
+    DenseMap<BasicBlock *, AvailabilityState> &FullyAvailableBlocks) {
   SmallVector<BasicBlock *, 32> Worklist;
   Optional<BasicBlock *> UnavailableBB;
 
   // The number of times we didn't find an entry for a block in a map and
-  // optimistically inserted an entry marking block as speculatively avaliable.
+  // optimistically inserted an entry marking block as speculatively available.
   unsigned NumNewNewSpeculativelyAvailableBBs = 0;
 
 #ifndef NDEBUG
   SmallSet<BasicBlock *, 32> NewSpeculativelyAvailableBBs;
   SmallVector<BasicBlock *, 32> AvailableBBs;
 #endif
 
   Worklist.emplace_back(BB);
   while (!Worklist.empty()) {
     BasicBlock *CurrBB = Worklist.pop_back_val(); // LIFO - depth-first!
     // Optimistically assume that the block is Speculatively Available and check
     // to see if we already know about this block in one lookup.
-    std::pair<DenseMap<BasicBlock *, AvaliabilityState>::iterator, bool> IV =
+    std::pair<DenseMap<BasicBlock *, AvailabilityState>::iterator, bool> IV =
         FullyAvailableBlocks.try_emplace(
-            CurrBB, AvaliabilityState::SpeculativelyAvailable);
-    AvaliabilityState &State = IV.first->second;
+            CurrBB, AvailabilityState::SpeculativelyAvailable);
+    AvailabilityState &State = IV.first->second;
 
     // Did the entry already exist for this block?
     if (!IV.second) {
-      if (State == AvaliabilityState::Unavailable) {
+      if (State == AvailabilityState::Unavailable) {
         UnavailableBB = CurrBB;
-        break; // Backpropagate unavaliability info.
+        break; // Backpropagate unavailability info.
       }
 
 #ifndef NDEBUG
       AvailableBBs.emplace_back(CurrBB);
 #endif
       continue; // Don't recurse further, but continue processing worklist.
     }
 
     // No entry found for block.
     ++NumNewNewSpeculativelyAvailableBBs;
     bool OutOfBudget = NumNewNewSpeculativelyAvailableBBs > MaxBBSpeculations;
 
     // If we have exhausted our budget, mark this block as unavailable.
     // Also, if this block has no predecessors, the value isn't live-in here.
     if (OutOfBudget || pred_empty(CurrBB)) {
       MaxBBSpeculationCutoffReachedTimes += (int)OutOfBudget;
-      State = AvaliabilityState::Unavailable;
+      State = AvailabilityState::Unavailable;
       UnavailableBB = CurrBB;
-      break; // Backpropagate unavaliability info.
+      break; // Backpropagate unavailability info.
     }
 
     // Tentatively consider this block as speculatively available.
 #ifndef NDEBUG
     NewSpeculativelyAvailableBBs.insert(CurrBB);
 #endif
     // And further recurse into block's predecessors, in depth-first order!
     Worklist.append(pred_begin(CurrBB), pred_end(CurrBB));
   }
 
 #if LLVM_ENABLE_STATS
   IsValueFullyAvailableInBlockNumSpeculationsMax.updateMax(
       NumNewNewSpeculativelyAvailableBBs);
 #endif
 
   // If the block isn't marked as fixpoint yet
   // (the Unavailable and Available states are fixpoints)
   auto MarkAsFixpointAndEnqueueSuccessors =
-      [&](BasicBlock *BB, AvaliabilityState FixpointState) {
+      [&](BasicBlock *BB, AvailabilityState FixpointState) {
         auto It = FullyAvailableBlocks.find(BB);
         if (It == FullyAvailableBlocks.end())
           return; // Never queried this block, leave as-is.
-        switch (AvaliabilityState &State = It->second) {
-        case AvaliabilityState::Unavailable:
-        case AvaliabilityState::Available:
+        switch (AvailabilityState &State = It->second) {
+        case AvailabilityState::Unavailable:
+        case AvailabilityState::Available:
           return; // Don't backpropagate further, continue processing worklist.
-        case AvaliabilityState::SpeculativelyAvailable: // Fix it!
+        case AvailabilityState::SpeculativelyAvailable: // Fix it!
           State = FixpointState;
 #ifndef NDEBUG
           assert(NewSpeculativelyAvailableBBs.erase(BB) &&
                  "Found a speculatively available successor leftover?");
 #endif
           // Queue successors for further processing.
           Worklist.append(succ_begin(BB), succ_end(BB));
           return;
         }
       };
 
   if (UnavailableBB) {
     // Okay, we have encountered an unavailable block.
     // Mark speculatively available blocks reachable from UnavailableBB as
     // unavailable as well. Paths are terminated when they reach blocks not in
     // FullyAvailableBlocks or they are not marked as speculatively available.
     Worklist.clear();
     Worklist.append(succ_begin(*UnavailableBB), succ_end(*UnavailableBB));
     while (!Worklist.empty())
       MarkAsFixpointAndEnqueueSuccessors(Worklist.pop_back_val(),
-                                         AvaliabilityState::Unavailable);
+                                         AvailabilityState::Unavailable);
   }
 
 #ifndef NDEBUG
   Worklist.clear();
   for (BasicBlock *AvailableBB : AvailableBBs)
     Worklist.append(succ_begin(AvailableBB), succ_end(AvailableBB));
   while (!Worklist.empty())
     MarkAsFixpointAndEnqueueSuccessors(Worklist.pop_back_val(),
-                                       AvaliabilityState::Available);
+                                       AvailabilityState::Available);
 
   assert(NewSpeculativelyAvailableBBs.empty() &&
          "Must have fixed all the new speculatively available blocks.");
 #endif
 
   return !UnavailableBB;
 }
 
bool GVN::PerformLoadPRE(LoadInst *LI, AvailValInBlkVect &ValuesPerBlock,
   }
 
   assert(TmpBB);
   LoadBB = TmpBB;
 
   // Check to see how many predecessors have the loaded value fully
   // available.
   MapVector<BasicBlock *, Value *> PredLoads;
-  DenseMap<BasicBlock *, AvaliabilityState> FullyAvailableBlocks;
+  DenseMap<BasicBlock *, AvailabilityState> FullyAvailableBlocks;
   for (const AvailableValueInBlock &AV : ValuesPerBlock)
-    FullyAvailableBlocks[AV.BB] = AvaliabilityState::Available;
+    FullyAvailableBlocks[AV.BB] = AvailabilityState::Available;
   for (BasicBlock *UnavailableBB : UnavailableBlocks)
-    FullyAvailableBlocks[UnavailableBB] = AvaliabilityState::Unavailable;
+    FullyAvailableBlocks[UnavailableBB] = AvailabilityState::Unavailable;
 
   SmallVector<BasicBlock *, 4> CriticalEdgePred;
   for (BasicBlock *Pred : predecessors(LoadBB)) {
     // If any predecessor block is an EH pad that does not allow non-PHI
     // instructions before the terminator, we can't PRE the load.
     if (Pred->getTerminator()->isEHPad()) {
       LLVM_DEBUG(
           dbgs() << "COULD NOT PRE LOAD BECAUSE OF AN EH PAD PREDECESSOR '"