[GVNHoist] Early exit of cheap computations

[hiraditya]

Summary

Rename variables.

[sebpop]

LGTM. Thanks.

llvm/trunk/lib/Transforms/Scalar/GVNHoist.cpp

bool hasEHOrLoadsOnPath(const Instruction *NewPt, MemoryDef *Def,
     // from OldBB into NewBB has to be safe on all execution paths.
     for (auto I = idf_begin(OldBB), E = idf_end(OldBB); I != E;) {
       if (*I == NewBB) {
         // Stop traversal when reaching HoistPt.
         I.skipChildren();
         continue;
       }
 
+      // Stop walk once the limit is reached.
+      if (NBBsOnAllPaths == 0)
+        return true;
+
       // Impossible to hoist with exceptions on the path.
       if (hasEH(*I))
         return true;
 
       // Check that we do not move a store past loads.
       if (hasMemoryUse(NewPt, Def, *I))
         return true;
 
-      // Stop walk once the limit is reached.
-      if (NBBsOnAllPaths == 0)
-        return true;
-
       // -1 is unlimited number of blocks on all paths.
       if (NBBsOnAllPaths != -1)
         --NBBsOnAllPaths;
 
       ++I;
     }
 
     return false;
bool hasEHOnPath(const BasicBlock *HoistPt, const BasicBlock *BB,
     // on all execution paths.
     for (auto I = idf_begin(BB), E = idf_end(BB); I != E;) {
       if (*I == HoistPt) {
         // Stop traversal when reaching NewHoistPt.
         I.skipChildren();
         continue;
       }
 
-      // Impossible to hoist with exceptions on the path.
-      if (hasEH(*I))
-        return true;
-
       // Stop walk once the limit is reached.
       if (NBBsOnAllPaths == 0)
         return true;
 
+      // Impossible to hoist with exceptions on the path.
+      if (hasEH(*I))
+        return true;
+
       // -1 is unlimited number of blocks on all paths.
       if (NBBsOnAllPaths != -1)
         --NBBsOnAllPaths;
 
       ++I;
     }
 
     return false;
private:
   void partitionCandidates(SmallVecImplInsn &InstructionsToHoist,
                            HoistingPointList &HPL, InsKind K) {
     // No need to sort for two instructions.
     if (InstructionsToHoist.size() > 2) {
       SortByDFSIn Pred(DFSNumber);
       std::sort(InstructionsToHoist.begin(), InstructionsToHoist.end(), Pred);
     }
 
-    int NBBsOnAllPaths = MaxNumberOfBBSInPath;
+    int NumBBsOnAllPaths = MaxNumberOfBBSInPath;
 
     SmallVecImplInsn::iterator II = InstructionsToHoist.begin();
     SmallVecImplInsn::iterator Start = II;
     Instruction *HoistPt = *II;
     BasicBlock *HoistBB = HoistPt->getParent();
     MemoryUseOrDef *UD;
     if (K != InsKind::Scalar)
       UD = MSSA->getMemoryAccess(HoistPt);
 
     for (++II; II != InstructionsToHoist.end(); ++II) {
       Instruction *Insn = *II;
       BasicBlock *BB = Insn->getParent();
       BasicBlock *NewHoistBB;
       Instruction *NewHoistPt;
 
-      if (BB == HoistBB) {
+      if (BB == HoistBB) { // Both are in the same Basic Block.
         NewHoistBB = HoistBB;
         NewHoistPt = firstInBB(Insn, HoistPt) ? Insn : HoistPt;
       } else {
+        // If the hoisting point contains one of the instructions,
+        // then hoist there, otherwise hoist before the terminator.
         NewHoistBB = DT->findNearestCommonDominator(HoistBB, BB);
         if (NewHoistBB == BB)
           NewHoistPt = Insn;
         else if (NewHoistBB == HoistBB)
           NewHoistPt = HoistPt;
         else
           NewHoistPt = NewHoistBB->getTerminator();
       }
 
       SmallPtrSet<const BasicBlock *, 2> WL;
       WL.insert(HoistBB);
       WL.insert(BB);
 
       if (K == InsKind::Scalar) {
-        if (safeToHoistScalar(NewHoistBB, WL, NBBsOnAllPaths)) {
+        if (safeToHoistScalar(NewHoistBB, WL, NumBBsOnAllPaths)) {
           // Extend HoistPt to NewHoistPt.
           HoistPt = NewHoistPt;
           HoistBB = NewHoistBB;
           continue;
         }
       } else {
         // When NewBB already contains an instruction to be hoisted, the
         // expression is needed on all paths.
         // Check that the hoisted expression is needed on all paths: it is
         // unsafe to hoist loads to a place where there may be a path not
         // loading from the same address: for instance there may be a branch on
         // which the address of the load may not be initialized.
         if ((HoistBB == NewHoistBB || BB == NewHoistBB ||
              hoistingFromAllPaths(NewHoistBB, WL)) &&
             // Also check that it is safe to move the load or store from HoistPt
             // to NewHoistPt, and from Insn to NewHoistPt.
-            safeToHoistLdSt(NewHoistPt, HoistPt, UD, K, NBBsOnAllPaths) &&
+            safeToHoistLdSt(NewHoistPt, HoistPt, UD, K, NumBBsOnAllPaths) &&
             safeToHoistLdSt(NewHoistPt, Insn, MSSA->getMemoryAccess(Insn),
-                            K, NBBsOnAllPaths)) {
+                            K, NumBBsOnAllPaths)) {
           // Extend HoistPt to NewHoistPt.
           HoistPt = NewHoistPt;
           HoistBB = NewHoistBB;
           continue;
         }
       }
 
       // At this point it is not safe to extend the current hoisting to
       // NewHoistPt: save the hoisting list so far.
       if (std::distance(Start, II) > 1)
         HPL.push_back({HoistBB, SmallVecInsn(Start, II)});
 
       // Start over from BB.
       Start = II;
       if (K != InsKind::Scalar)
         UD = MSSA->getMemoryAccess(*Start);
       HoistPt = Insn;
       HoistBB = BB;
-      NBBsOnAllPaths = MaxNumberOfBBSInPath;
+      NumBBsOnAllPaths = MaxNumberOfBBSInPath;
     }
 
     // Save the last partition.
     if (std::distance(Start, II) > 1)
       HPL.push_back({HoistBB, SmallVecInsn(Start, II)});
   }
 
   // Initialize HPL from Map.