[PassManager] Save compile time by not running the verifier unnecessarily. NFC

[lattner]

Summary

This changes the pass manager to not rerun the verifier when a pass says it
didn't change anything or after an OpToOpPassAdaptor, since neither of those
cases need verification (and if the pass lied, then there will be much larger
semantic problems than will be caught by the verifier).

This maintains behavior in EXPENSIVE_CHECKS mode.

[lattner]

Clean up the comments.

[rriddle]

LGTM, nice!

mlir/lib/Pass/Pass.cpp

if (auto *adaptor = dyn_cast<OpToOpPassAdaptor>(pass))
     adaptor->runOnOperation(verifyPasses);
   else
     pass->runOnOperation();
   bool passFailed = pass->passState->irAndPassFailed.getInt();
 
   // Invalidate any non preserved analyses.
   am.invalidate(pass->passState->preservedAnalyses);
 
+  // When verifyPasses is specified, we run the verifier (unless the pass
+  // failed).
+  //
+
   // Run the verifier if this pass didn't fail already.
-  if (!passFailed && verifyPasses)
+  if (!passFailed && verifyPasses) {
+    bool runVerifierNow = true;
+    // If the pass said that it preserved all analyses then it can't have
+    // permuted the IR, and we don't want to burn compile time running the
+    // verifier.  Similarly, if we just ran an OpToOpPassAdaptor (e.g. to run
+    // function passes within a module) then each subunit will have been
+    // verified on the subunit so there is little benefit in rerunning the
+    // verifier on the whole larger unit again.
+    //
+    // We run these checks in EXPENSIVE_CHECKS mode out of caution.
+#ifndef EXPENSIVE_CHECKS
+    runVerifierNow = !isa<OpToOpPassAdaptor>(pass) &&
+                     !pass->passState->preservedAnalyses.isAll();
+#endif
+    if (runVerifierNow)
       passFailed = failed(verify(op));
+  }
 
   // Instrument after the pass has run.
   if (pi) {
     if (passFailed)
       pi->runAfterPassFailed(pass, op);
     else
       pi->runAfterPass(pass, op);
   }