Add a routine for LCSSA verification of entire function.

[mzolotukhin]

Summary

There is a number of places where we need to check that LCSSA form is
preserved. This patch adds a helper function for that.

[sanjoy]

lib/Transforms/Utils/LCSSA.cpp

274

I think this basically is Loop::isRecursivelyLCSSAForm.

288

I'm not super convinced that we need a new function here. :)

I think this can be:

all_of(LI, [&](Loop *L) { return L->isRecursiveLCSSAForm(DT); });

If you do want a new function, the logical place for it, IMO, is LoopInfo.

[mzolotukhin]

Oh, neat, we already have everything I need! We no longer need this then.

include/llvm/Transforms/Utils/LoopUtils.h

 /// LoopInfo and DominatorTree are required and preserved.
 ///
 /// If ScalarEvolution is passed in, it will be preserved.
 ///
 /// Returns true if any modifications are made to the loop.
 bool formLCSSARecursively(Loop &L, DominatorTree &DT, LoopInfo *LI,
                           ScalarEvolution *SE);
 
+/// \brief Check if all loops in the function \param F are in LCSSA form.
+/// LoopInfo and DominatorTree are required.
+bool isFunctionInLCSSAForm(Function &F, DominatorTree &DT, LoopInfo &LI);
+
 /// \brief Walk the specified region of the CFG (defined by all blocks
 /// dominated by the specified block, and that are in the current loop) in
 /// reverse depth first order w.r.t the DominatorTree. This allows us to visit
 /// uses before definitions, allowing us to sink a loop body in one pass without
 /// iteration. Takes DomTreeNode, AliasAnalysis, LoopInfo, DominatorTree,
 /// DataLayout, TargetLibraryInfo, Loop, AliasSet information for all
 /// instructions of the loop and loop safety information as arguments.
 /// It returns changed status.

lib/Transforms/Utils/LCSSA.cpp

bool llvm::formLCSSARecursively(Loop &L, DominatorTree &DT, LoopInfo *LI,
   // Recurse depth-first through inner loops.
   for (Loop *SubLoop : L.getSubLoops())
     Changed |= formLCSSARecursively(*SubLoop, DT, LI, SE);
 
   Changed |= formLCSSA(L, DT, LI, SE);
   return Changed;
 }
 
+/// Check if all loops in a loop nest are in LCSSA form.
+static bool isLoopNestInLCSSAForm(Loop &L, DominatorTree &DT) {
+  if (!L.isLCSSAForm(DT))
+    return false;
+
+  // Recurse through inner loops.
+  for (Loop *SubLoop : L)
+    if (!isLoopNestInLCSSAForm(*SubLoop, DT))
+      return false;
+
+  return true;
+}
+
+/// Check if all loops in the function F are in LCSSA form.
+bool llvm::isFunctionInLCSSAForm(Function &F, DominatorTree &DT, LoopInfo &LI) {
+  for (Loop *L : LI)
+    if (!isLoopNestInLCSSAForm(*L, DT))
+      return false;
+
+  return true;
+}
+
 namespace {
 struct LCSSA : public FunctionPass {
   static char ID; // Pass identification, replacement for typeid
   LCSSA() : FunctionPass(ID) {
     initializeLCSSAPass(*PassRegistry::getPassRegistry());
   }
 
   // Cached analysis information for the current function.