Add -allow-critical-edges flag.

Provide a mechanism to gradually migrate unit tests away from allowing
critical edges via -allow-critical-edges=false.

This will be the default in OSSA very soon, and will hopefully become
the default eventually for all SIL stages.

Note that not all required optimization pass changes have been
committed yet. I have pending changes in:
- SimplifyCFG
- SILCloner subclasses
- EagerSpecializer
- ArraySpecialization
- LoopUtils
- LoopRotate

There are multiple reasons we need to disallow critical edges:

1. Most passes do not perform CFG transformations. However, we often
need to split critical edges and remember to invalidate all SIL
analyses at the end of virtually every pass. This is very innefficient
and highly bug prone.

2. Many SIL analysis algorithms needs to reason about CFG
edges. Avoiding critical edges leads to far simpler and more efficient
designs when edges can be identified by blocks.

3. Handling block arguments on conditional branches create complexity
at the lowest level of the SIL interface. This complexity is difficult
to abstract over and bleeds until any algorithm that needs to reason
about phi operands. It's far easier to work with phis if we can easily
recover the phi operand with only a reference to the predecessor
block.

4. Attempting to preserve critical edges in high and mid level IR
blocks optimizations that otherwise have no business optimizing
branches. Branch optimization should always be defered to machine
level IR where the most relevant heuristics are employed to remove
unconditional branches. If code didn't need to be placed on a critical
edges, then a branch optimization can easily remove that code from the
critical edge.

Author: atrick

lib/SIL/Verifier/SILVerifier.cpp

@@ -65,6 +65,10 @@ static llvm::cl::opt<bool> VerifyDIHoles(
 static llvm::cl::opt<bool> SkipConvertEscapeToNoescapeAttributes(
     "verify-skip-convert-escape-to-noescape-attributes", llvm::cl::init(false));
 
+// Allow unit tests to gradually migrate toward -allow-critical-edges=false.
+static llvm::cl::opt<bool> AllowCriticalEdges("allow-critical-edges",
+                                              llvm::cl::init(true));
+
 // The verifier is basically all assertions, so don't compile it with NDEBUG to
 // prevent release builds from triggering spurious unused variable warnings.
 
@@ -5147,7 +5151,7 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
   }
 
   void verifyBranches(const SILFunction *F) {
-    // Verify that there is no non_condbr critical edge.
+    // Verify no critical edge.
     auto isCriticalEdgePred = [](const TermInst *T, unsigned EdgeIdx) {
       assert(T->getSuccessors().size() > EdgeIdx && "Not enough successors");
 
@@ -5170,10 +5174,11 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
       const TermInst *TI = BB.getTerminator();
       CurInstruction = TI;
 
-      // Check for non-cond_br critical edges.
-      if (isa<CondBranchInst>(TI)) {
+      // FIXME: In OSSA, critical edges will never be allowed.
+      // In Lowered SIL, they are allowed on unconditional branches only.
+      //   if (!(isSILOwnershipEnabled() && F->hasOwnership()))
+      if (AllowCriticalEdges && isa<CondBranchInst>(TI))
         continue;
-      }
 
       for (unsigned Idx = 0, e = BB.getSuccessors().size(); Idx != e; ++Idx) {
         require(!isCriticalEdgePred(TI, Idx),