Fix issue 12023 by avoiding a critical edge in the SSA graph with a switch statement.

sdk/lib/_internal/compiler/implementation/ssa/builder.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of ssa;
 
 /**
  * A special element for the extra parameter taken by intercepted
  * methods. We need to override [Element.computeType] because our
  * optimizers may look at its declared type.
@@ skipping 4652 matching lines @@
                     JumpHandler jumpHandler,
                     HInstruction buildExpression(),
                     var switchCases,
                     Iterable<Constant> getConstants(SwitchCase switchCase),
                     bool isDefaultCase(SwitchCase switchCase),
                     void buildSwitchCase(SwitchCase switchCase)) {
     Map<CaseMatch, Constant> constants = new Map<CaseMatch, Constant>();
 
     // TODO(ngeoffray): Handle switch-instruction in bailout code.
     work.allowSpeculativeOptimization = false;
-    // Then build a switch structure.
     HBasicBlock expressionStart = openNewBlock();
     HInstruction expression = buildExpression();
     if (switchCases.isEmpty) {
       return;
     }
-    HBasicBlock expressionEnd = current;
 
     HSwitch switchInstruction = new HSwitch(<HInstruction>[expression]);
-    HBasicBlock expressionBlock = close(switchInstruction);
+    HBasicBlock expressionEnd = close(switchInstruction);
     LocalsHandler savedLocals = localsHandler;
 
     List<List<Constant>> matchExpressions = <List<Constant>>[];
     List<HStatementInformation> statements = <HStatementInformation>[];
     bool hasDefault = false;
     Element getFallThroughErrorElement = backend.getFallThroughError();
     HasNextIterator<Node> caseIterator =
         new HasNextIterator<Node>(switchCases.iterator);
     while (caseIterator.hasNext) {
       SwitchCase switchCase = caseIterator.next();
       List<Constant> caseConstants = <Constant>[];
       HBasicBlock block = graph.addNewBlock();
       for (Constant constant in getConstants(switchCase)) {
         caseConstants.add(constant);
         HConstant hConstant = graph.addConstant(constant, compiler);
         switchInstruction.inputs.add(hConstant);
         hConstant.usedBy.add(switchInstruction);
-        expressionBlock.addSuccessor(block);
+        expressionEnd.addSuccessor(block);
       }
       matchExpressions.add(caseConstants);
 
       if (isDefaultCase(switchCase)) {
         // An HSwitch has n inputs and n+1 successors, the last being the
         // default case.
-        expressionBlock.addSuccessor(block);
+        expressionEnd.addSuccessor(block);
         hasDefault = true;
       }
       open(block);
       localsHandler = new LocalsHandler.from(savedLocals);
       buildSwitchCase(switchCase);
-      if (!isAborted() && caseIterator.hasNext) {
-        pushInvokeStatic(switchCase, getFallThroughErrorElement, []);
-        HInstruction error = pop();
-        closeAndGotoExit(new HThrow(error));
+      if (!isAborted()) {
+        if (caseIterator.hasNext) {
+          pushInvokeStatic(switchCase, getFallThroughErrorElement, []);
+          HInstruction error = pop();
+          closeAndGotoExit(new HThrow(error));
+        } else if (!isDefaultCase(switchCase)) {
+          // If there is no default, we will add one later to avoid
+          // the critical edge. So we generate a break statement to make
+          // sure the last case does not fall through to the default case.
+          jumpHandler.generateBreak();
+        }
       }
       statements.add(
           new HSubGraphBlockInformation(new SubGraph(block, lastOpenedBlock)));
     }
 
     // Add a join-block if necessary.
     // We create [joinBlock] early, and then go through the cases that might
     // want to jump to it. In each case, if we add [joinBlock] as a successor
     // of another block, we also add an element to [caseHandlers] that is used
     // to create the phis in [joinBlock].
     // If we never jump to the join block, [caseHandlers] will stay empty, and
     // the join block is never added to the graph.
     HBasicBlock joinBlock = new HBasicBlock();
     List<LocalsHandler> caseHandlers = <LocalsHandler>[];
     jumpHandler.forEachBreak((HBreak instruction, LocalsHandler locals) {
       instruction.block.addSuccessor(joinBlock);
       caseHandlers.add(locals);
     });
     jumpHandler.forEachContinue((HContinue instruction, LocalsHandler locals) {
       assert(invariant(errorNode, false,
                        message: 'Continue cannot target a switch.'));
     });
     if (!isAborted()) {
       current.close(new HGoto());
       lastOpenedBlock.addSuccessor(joinBlock);
       caseHandlers.add(localsHandler);
     }
     if (!hasDefault) {
-      // The current flow is only aborted if the switch has a default that
-      // aborts (all previous cases must abort, and if there is no default,
-      // it's possible to miss all the cases).
-      expressionEnd.addSuccessor(joinBlock);
+      // Always create a default case, to avoid a critical edge in the
+      // graph.
+      HBasicBlock defaultCase = addNewBlock();
+      expressionEnd.addSuccessor(defaultCase);
+      open(defaultCase);
+      close(new HGoto());
+      defaultCase.addSuccessor(joinBlock);
       caseHandlers.add(savedLocals);
+      matchExpressions.add(<Constant>[]);
+      statements.add(new HSubGraphBlockInformation(new SubGraph(
+          defaultCase, defaultCase)));
     }
     assert(caseHandlers.length == joinBlock.predecessors.length);
     if (caseHandlers.length != 0) {
       graph.addBlock(joinBlock);
       open(joinBlock);
       if (caseHandlers.length == 1) {
         localsHandler = caseHandlers[0];
       } else {
         localsHandler = savedLocals.mergeMultiple(caseHandlers, joinBlock);
       }
     } else {
       // The joinblock is not used.
       joinBlock = null;
     }
 
     HSubExpressionBlockInformation expressionInfo =
         new HSubExpressionBlockInformation(new SubExpression(expressionStart,
                                                              expressionEnd));
     expressionStart.setBlockFlow(
         new HSwitchBlockInformation(expressionInfo,
                                     matchExpressions,
                                     statements,
-                                    hasDefault,
                                     jumpHandler.target,
                                     jumpHandler.labels()),
         joinBlock);
 
     jumpHandler.close();
   }
 
   bool nonPrimitiveTypeOverridesEquals(Constant constant) {
     // Function values override equals. Even static ones, since
     // they inherit from [Function].
@@ skipping 660 matching lines @@
           new HSubGraphBlockInformation(elseBranch.graph));
 
     HBasicBlock conditionStartBlock = conditionBranch.block;
     conditionStartBlock.setBlockFlow(info, joinBlock);
     SubGraph conditionGraph = conditionBranch.graph;
     HIf branch = conditionGraph.end.last;
     assert(branch is HIf);
     branch.blockInformation = conditionStartBlock.blockFlow;
   }
 }