Fix EagerSpecializer to avoid critical edges.

Author: atrick

include/swift/SIL/SILBuilder.h

@@ -2501,6 +2501,10 @@ class SILBuilderWithScope : public SILBuilder {
       : SILBuilder(BB, InheritScopeFrom->getDebugScope(),
                    B.getBuilderContext()) {}
 
+  explicit SILBuilderWithScope(SILBasicBlock *BB, SILBuilderContext &C,
+                               const SILDebugScope *debugScope)
+      : SILBuilder(BB, debugScope, C) {}
+
   /// Creates a new SILBuilder with an insertion point at the
   /// beginning of BB and the debug scope from the first
   /// non-metainstruction in the BB.

include/swift/SILOptimizer/Utils/CFGOptUtils.h

@@ -118,6 +118,17 @@ void splitEdgesFromTo(SILBasicBlock *from, SILBasicBlock *to,
                       DominanceInfo *domInfo = nullptr,
                       SILLoopInfo *loopInfo = nullptr);
 
+/// Create a basic block to serve as the target of a conditional branch, or
+/// other terminator with multiple successors. This avoids introducing critical
+/// edges when inserting conditional branches.
+///
+/// This is a lightweight helper that assumes no block arguments and does not
+/// update dominators or loops. For more general functionality, just create the
+/// conditional branch then call splitCriticalEdge to fix it up.
+SILBasicBlock *createSplitBranchTarget(SILBasicBlock *targetBlock,
+                                       SILBuilder &builder,
+                                       SILLocation loc);
+
 /// Splits the basic block before the instruction with an unconditional branch
 /// and updates the dominator tree and loop info. Returns the new, branched to
 /// block that contains the end of \p SplitBeforeInst's block.

lib/SILOptimizer/Transforms/EagerSpecializer.cpp

@@ -483,7 +483,8 @@ emitTypeCheck(SILBasicBlock *FailedTypeCheckBB, SubstitutableType *ParamTy,
                                         {GenericMTVal, SpecializedMTVal});
 
   auto *SuccessBB = Builder.getFunction().createBasicBlock();
-  Builder.createCondBranch(Loc, Cmp, SuccessBB, FailedTypeCheckBB);
+  auto *FailBB = createSplitBranchTarget(FailedTypeCheckBB, Builder, Loc);
+  Builder.createCondBranch(Loc, Cmp, SuccessBB, FailBB);
   Builder.emitBlock(SuccessBB);
 }
 
@@ -510,7 +511,8 @@ void EagerDispatch::emitIsTrivialCheck(SILBasicBlock *FailedTypeCheckBB,
   auto IsPOD = Builder.createBuiltin(Loc, Ctx.getIdentifier("ispod"), BoolTy,
                                      SubMap, {GenericMT});
   auto *SuccessBB = Builder.getFunction().createBasicBlock();
-  Builder.createCondBranch(Loc, IsPOD, SuccessBB, FailedTypeCheckBB);
+  auto *FailBB = createSplitBranchTarget(FailedTypeCheckBB, Builder, Loc);
+  Builder.createCondBranch(Loc, IsPOD, SuccessBB, FailBB);
   Builder.emitBlock(SuccessBB);
 }
 
@@ -542,14 +544,16 @@ void EagerDispatch::emitTrivialAndSizeCheck(SILBasicBlock *FailedTypeCheckBB,
                                         {ParamSize, LayoutSize});
 
   auto *SuccessBB1 = Builder.getFunction().createBasicBlock();
-  Builder.createCondBranch(Loc, Cmp, SuccessBB1, FailedTypeCheckBB);
+  auto *FailBB1 = createSplitBranchTarget(FailedTypeCheckBB, Builder, Loc);
+  Builder.createCondBranch(Loc, Cmp, SuccessBB1, FailBB1);
   Builder.emitBlock(SuccessBB1);
   // Emit a check that it is a pod object.
   // TODO: Perform this check before all the fixed size checks!
   auto IsPOD = Builder.createBuiltin(Loc, Ctx.getIdentifier("ispod"),
                                          BoolTy, SubMap, { GenericMT });
   auto *SuccessBB2 = Builder.getFunction().createBasicBlock();
-  Builder.createCondBranch(Loc, IsPOD, SuccessBB2, FailedTypeCheckBB);
+  auto *FailBB2 = createSplitBranchTarget(FailedTypeCheckBB, Builder, Loc);
+  Builder.createCondBranch(Loc, IsPOD, SuccessBB2, FailBB2);
   Builder.emitBlock(SuccessBB2);
 }
 
@@ -580,11 +584,11 @@ void EagerDispatch::emitRefCountedObjectCheck(SILBasicBlock *FailedTypeCheckBB,
                                         {CanBeClass, ClassConst});
 
   auto *SuccessBB = Builder.getFunction().createBasicBlock();
-  auto *MayBeCallsCheckBB = Builder.getFunction().createBasicBlock();
-  Builder.createCondBranch(Loc, Cmp1, SuccessBB,
-                           MayBeCallsCheckBB);
+  auto *MayBeClassCheckBB = Builder.getFunction().createBasicBlock();
+  auto *SwiftClassBB = createSplitBranchTarget(SuccessBB, Builder, Loc);
+  Builder.createCondBranch(Loc, Cmp1, SwiftClassBB, MayBeClassCheckBB);
 
-  Builder.emitBlock(MayBeCallsCheckBB);
+  Builder.emitBlock(MayBeClassCheckBB);
 
   auto MayBeClassConst =
       Builder.createIntegerLiteral(Loc, Int8Ty, 2);
@@ -594,8 +598,9 @@ void EagerDispatch::emitRefCountedObjectCheck(SILBasicBlock *FailedTypeCheckBB,
                                         {CanBeClass, MayBeClassConst});
 
   auto *IsClassCheckBB = Builder.getFunction().createBasicBlock();
-  Builder.createCondBranch(Loc, Cmp2, IsClassCheckBB,
-                           FailedTypeCheckBB);
+  auto *FailClassCheckBB =
+    createSplitBranchTarget(FailedTypeCheckBB, Builder, Loc);
+  Builder.createCondBranch(Loc, Cmp2, IsClassCheckBB, FailClassCheckBB);
 
   Builder.emitBlock(IsClassCheckBB);
 
@@ -610,7 +615,9 @@ void EagerDispatch::emitRefCountedObjectCheck(SILBasicBlock *FailedTypeCheckBB,
   auto Member = Members[0];
   auto BoolValue =
       Builder.emitStructExtract(Loc, IsClassRuntimeCheck, Member, BoolTy);
-  Builder.createCondBranch(Loc, BoolValue, SuccessBB, FailedTypeCheckBB);
+  auto *FailBB = createSplitBranchTarget(FailedTypeCheckBB, Builder, Loc);
+  auto *ObjCOrExistentialBB = createSplitBranchTarget(SuccessBB, Builder, Loc);
+  Builder.createCondBranch(Loc, BoolValue, ObjCOrExistentialBB, FailBB);
 
   Builder.emitBlock(SuccessBB);
 }

lib/SILOptimizer/Utils/CFGOptUtils.cpp

@@ -494,6 +494,17 @@ bool swift::isCriticalEdge(TermInst *t, unsigned edgeIdx) {
   return true;
 }
 
+SILBasicBlock *swift::createSplitBranchTarget(SILBasicBlock *targetBlock,
+                                              SILBuilder &builder,
+                                              SILLocation loc) {
+  auto *function = targetBlock->getParent();
+  auto *edgeBB = function->createBasicBlockBefore(targetBlock);
+  SILBuilderWithScope(edgeBB, builder.getBuilderContext(),
+                      builder.getCurrentDebugScope())
+      .createBranch(loc, targetBlock);
+  return edgeBB;
+}
+
 /// Splits the basic block at the iterator with an unconditional branch and
 /// updates the dominator tree and loop info.
 SILBasicBlock *swift::splitBasicBlockAndBranch(SILBuilder &builder,