Refactoring to prepare for kernel based jump targets

pkg/compiler/lib/src/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.
 
 import 'dart:collection';
 
 import 'package:js_runtime/shared/embedded_names.dart';
 
 import '../closure.dart';
 import '../common.dart';
@@ skipping 1689 matching lines @@
       }
     }
 
     void buildBody() {
       visit(node.body);
     }
 
     loopHandler.handleLoop(
         node,
         closureDataLookup.getClosureRepresentationInfoForLoop(node),
+        elements.getTargetDefinition(node),
         buildInitializer,
         buildCondition,
         buildUpdate,
         buildBody);
   }
 
   visitWhile(ast.While node) {
     assert(isReachable);
     HInstruction buildCondition() {
       visit(node.condition);
       return popBoolified();
     }
 
     loopHandler.handleLoop(
         node,
         closureDataLookup.getClosureRepresentationInfoForLoop(node),
+        elements.getTargetDefinition(node),
         () {},
         buildCondition,
         () {}, () {
       visit(node.body);
     });
   }
 
   visitDoWhile(ast.DoWhile node) {
     assert(isReachable);
     LocalsHandler savedLocals = new LocalsHandler.from(localsHandler);
     var loopClosureInfo =
         closureDataLookup.getClosureRepresentationInfoForLoop(node);
     localsHandler.startLoop(loopClosureInfo);
     loopDepth++;
-    JumpHandler jumpHandler = loopHandler.beginLoopHeader(node);
+    JumpTarget target = elements.getTargetDefinition(node);
+    JumpHandler jumpHandler = loopHandler.beginLoopHeader(node, target);
     HLoopInformation loopInfo = current.loopInformation;
     HBasicBlock loopEntryBlock = current;
     HBasicBlock bodyEntryBlock = current;
-    JumpTarget target = elements.getTargetDefinition(node);
     bool hasContinues = target != null && target.isContinueTarget;
     if (hasContinues) {
       // Add extra block to hang labels on.
       // It doesn't currently work if they are on the same block as the
       // HLoopInfo. The handling of HLabeledBlockInformation will visit a
       // SubGraph that starts at the same block again, so the HLoopInfo is
       // either handled twice, or it's handled after the labeled block info,
       // both of which generate the wrong code.
       // Using a separate block is just a simple workaround.
       bodyEntryBlock = openNewBlock();
@@ skipping 92 matching lines @@
 
       if (jumpHandler.hasAnyBreak()) {
         // Null branchBlock because the body of the do-while loop always aborts,
         // so we never get to the condition.
         loopHandler.endLoop(loopEntryBlock, null, jumpHandler, localsHandler);
 
         // Since the body of the loop has a break, we attach a synthesized label
         // to the body.
         SubGraph bodyGraph = new SubGraph(bodyEntryBlock, bodyExitBlock);
         JumpTarget target = elements.getTargetDefinition(node);
-        LabelDefinition label = target.addLabel(null, 'loop');
-        label.setBreakTarget();
+        LabelDefinition label =
+            target.addLabel(null, 'loop', isBreakTarget: true);
         HLabeledBlockInformation info = new HLabeledBlockInformation(
             new HSubGraphBlockInformation(bodyGraph), <LabelDefinition>[label]);
         loopEntryBlock.setBlockFlow(info, current);
         jumpHandler.forEachBreak((HBreak breakInstruction, _) {
           HBasicBlock block = breakInstruction.block;
           block.addAtExit(new HBreak.toLabel(label));
           block.remove(breakInstruction);
         });
       }
     }
@@ skipping 3502 matching lines @@
 
   /**
    * Creates a [JumpHandler] for a statement. The node must be a jump
    * target. If there are no breaks or continues targeting the statement,
    * a special "null handler" is returned.
    *
    * [isLoopJump] is [:true:] when the jump handler is for a loop. This is used
    * to distinguish the synthesized loop created for a switch statement with
    * continue statements from simple switch statements.
    */
-  JumpHandler createJumpHandler(ast.Statement node, {bool isLoopJump}) {
-    JumpTarget element = elements.getTargetDefinition(node);
-    if (element == null || !identical(element.statement, node)) {
+  JumpHandler createJumpHandler(ast.Statement node, JumpTarget jumpTarget,
+      {bool isLoopJump}) {
+    if (jumpTarget == null || !identical(jumpTarget.statement, node)) {
       // No breaks or continues to this node.
       return new NullJumpHandler(reporter);
     }
     if (isLoopJump && node is ast.SwitchStatement) {
       // Create a special jump handler for loops created for switch statements
       // with continue statements.
-      return new AstSwitchCaseJumpHandler(this, element, node);
+      return new AstSwitchCaseJumpHandler(this, jumpTarget, node);
     }
-    return new JumpHandler(this, element);
+    return new JumpHandler(this, jumpTarget);
   }
 
   visitAsyncForIn(ast.AsyncForIn node) {
     // The async-for is implemented with a StreamIterator.
     HInstruction streamIterator;
 
     visit(node.expression);
     HInstruction expression = pop();
     ConstructorElement constructor = commonElements.streamIteratorConstructor;
     pushInvokeStatic(
@@ skipping 35 matching lines @@
 
       visit(node.body);
     }
 
     void buildUpdate() {}
 
     buildProtectedByFinally(() {
       loopHandler.handleLoop(
           node,
           closureDataLookup.getClosureRepresentationInfoForLoop(node),
+          elements.getTargetDefinition(node),
           buildInitializer,
           buildCondition,
           buildUpdate,
           buildBody);
     }, () {
       pushInvokeDynamic(node, Selectors.cancel, null, [streamIterator]);
       push(new HAwait(pop(),
           new TypeMask.subclass(commonElements.objectClass, closedWorld)));
       pop();
     });
@@ skipping 52 matching lines @@
       Selector call = Selectors.current;
       TypeMask mask = elementInferenceResults.typeOfIteratorCurrent(node);
       pushInvokeDynamic(node, call, mask, [iterator]);
       buildAssignLoopVariable(node, pop());
       visit(node.body);
     }
 
     loopHandler.handleLoop(
         node,
         closureDataLookup.getClosureRepresentationInfoForLoop(node),
+        elements.getTargetDefinition(node),
         buildInitializer,
         buildCondition,
         () {},
         buildBody);
   }
 
   buildAssignLoopVariable(ast.ForIn node, HInstruction value) {
     ast.Node identifier = node.declaredIdentifier;
     Element variable = elements.getForInVariable(node);
     Selector selector = elements.getSelector(identifier);
@@ skipping 104 matching lines @@
       HInstruction one = graph.addConstantInt(1, closedWorld);
       HInstruction addInstruction =
           new HAdd(index, one, null, commonMasks.positiveIntType);
       add(addInstruction);
       localsHandler.updateLocal(indexVariable, addInstruction);
     }
 
     loopHandler.handleLoop(
         node,
         closureDataLookup.getClosureRepresentationInfoForLoop(node),
+        elements.getTargetDefinition(node),
         buildInitializer,
         buildCondition,
         buildUpdate,
         buildBody);
   }
 
   visitLabel(ast.Label node) {
     reporter.internalError(node, 'SsaFromAstMixin.visitLabel.');
   }
 
@@ skipping 179 matching lines @@
       buildComplexSwitchStatement(node, constants, caseIndex, hasDefault);
     }
   }
 
   /**
    * Builds a simple switch statement which does not handle uses of continue
    * statements to labeled switch cases.
    */
   void buildSimpleSwitchStatement(
       ast.SwitchStatement node, Map<ast.CaseMatch, ConstantValue> constants) {
-    JumpHandler jumpHandler = createJumpHandler(node, isLoopJump: false);
+    JumpHandler jumpHandler = createJumpHandler(
+        node, elements.getTargetDefinition(node),
+        isLoopJump: false);
     HInstruction buildExpression() {
       visit(node.expression);
       return pop();
     }
 
     Iterable<ConstantValue> getConstants(ast.SwitchCase switchCase) {
       List<ConstantValue> constantList = <ConstantValue>[];
       for (ast.Node labelOrCase in switchCase.labelsAndCases) {
         if (labelOrCase is ast.CaseMatch) {
           constantList.add(constants[labelOrCase]);
@@ skipping 49 matching lines @@
     //       case 2: s_2; target = i; continue l;
     //       ...
     //       case n: s_n; target = j; continue l;
     //     }
     //   }
 
     JumpTarget switchTarget = elements.getTargetDefinition(node);
     HInstruction initialValue = graph.addConstantNull(closedWorld);
     localsHandler.updateLocal(switchTarget, initialValue);
 
-    JumpHandler jumpHandler = createJumpHandler(node, isLoopJump: false);
+    JumpHandler jumpHandler =
+        createJumpHandler(node, switchTarget, isLoopJump: false);
     dynamic switchCases = node.cases;
     if (!hasDefault) {
       // Use [:null:] as the marker for a synthetic default clause.
       // The synthetic default is added because otherwise, there would be no
       // good place to give a default value to the local.
       switchCases = node.cases.nodes.toList()..add(null);
     }
     HInstruction buildExpression() {
       visit(node.expression);
       return pop();
@@ skipping 63 matching lines @@
           node.cases,
           getConstants,
           (_) => false, // No case is default.
           buildSwitchCase);
     }
 
     void buildLoop() {
       loopHandler.handleLoop(
           node,
           closureDataLookup.getClosureRepresentationInfoForLoop(node),
+          switchTarget,
           () {},
           buildCondition,
           () {},
           buildSwitch);
     }
 
     if (hasDefault) {
       buildLoop();
     } else {
       // If the switch statement has no default case, surround the loop with
@@ skipping 842 matching lines @@
       this.oldReturnLocal,
       this.oldReturnType,
       this.oldResolvedAst,
       this.oldStack,
       this.oldLocalsHandler,
       this.inTryStatement,
       this.allFunctionsCalledOnce,
       this.oldElementInferenceResults)
       : super(function);
 }